Supabase アーキテクチャパターン選択ガイド
Supabase実践アーキテクチャパターン 1.0版 株式会社アイティードゥ 2025年6月2日
目次
クイック選択フローチャート
graph TD
A[プロジェクト開始] --> B{チーム規模は?}
B -->|1-3人| C{開発期間は?}
B -->|4-10人| D{ビジネスロジックの複雑さは?}
B -->|10人以上| E{エンタープライズ要件は?}
C -->|1-3ヶ月| F[クライアント実装]
C -->|3ヶ月以上| G{外部連携必要?}
G -->|はい| H[Edge Functions]
G -->|いいえ| F
D -->|シンプル| I{パフォーマンス要件は?}
D -->|複雑| J{外部システム連携は?}
I -->|標準| F
I -->|高要求| H
J -->|あり| H
J -->|なし| K{スケール要件は?}
K -->|中規模| H
K -->|大規模| L[独立APIサーバー]
E -->|あり| L
E -->|なし| M{カスタマイズ要件は?}
M -->|高| L
M -->|中| H
M -->|低| F
style F fill:#e1f5fe
style H fill:#fff3e0
style L fill:#fce4ec
簡易診断フロー
ステップ1: 基本要件確認
interface BasicRequirements {
projectType: 'mvp' | 'startup' | 'enterprise'
timeline: 'urgent' | 'normal' | 'flexible'
budget: 'limited' | 'moderate' | 'ample'
teamExperience: 'beginner' | 'intermediate' | 'expert'
}
function quickRecommendation(req: BasicRequirements): string {
// MVP + 緊急 + 限定予算 + 初心者 → クライアント実装
if (req.projectType === 'mvp' && req.timeline === 'urgent' &&
req.budget === 'limited' && req.teamExperience === 'beginner') {
return 'client_implementation'
}
// スタートアップ + 通常 + 中程度予算 + 中級者 → Edge Functions
if (req.projectType === 'startup' && req.timeline === 'normal' &&
req.budget === 'moderate' && req.teamExperience === 'intermediate') {
return 'edge_functions'
}
// エンタープライズ + 柔軟 + 十分予算 + 専門家 → 独立APIサーバー
if (req.projectType === 'enterprise' && req.budget === 'ample' &&
req.teamExperience === 'expert') {
return 'independent_api'
}
return 'needs_detailed_analysis'
}
ステップ2: 技術要件スコアリング
interface TechnicalRequirements {
userScale: 'small' | 'medium' | 'large' // ~1K, ~10K, 100K+
dataComplexity: 'simple' | 'moderate' | 'complex' // CRUD, Relations, Advanced
integrations: 'none' | 'few' | 'many' // 0, 1-3, 4+
realtime: 'none' | 'basic' | 'advanced' // No, Simple, Complex
customAuth: 'standard' | 'custom' | 'complex' // Basic, Custom, Enterprise
compliance: 'none' | 'basic' | 'strict' // No, Some, High
}
function calculatePatternScore(
pattern: string,
requirements: TechnicalRequirements
): number {
const scores = {
client_implementation: {
small: 10, medium: 6, large: 2,
simple: 10, moderate: 7, complex: 3,
none: 10, few: 6, many: 2,
none: 10, basic: 8, advanced: 4,
standard: 10, custom: 5, complex: 2,
none: 10, basic: 8, strict: 3
},
edge_functions: {
small: 8, medium: 10, large: 7,
simple: 8, moderate: 10, complex: 8,
none: 6, few: 10, many: 9,
none: 8, basic: 9, advanced: 8,
standard: 8, custom: 9, complex: 6,
none: 8, basic: 9, strict: 7
},
independent_api: {
small: 4, medium: 7, large: 10,
simple: 6, moderate: 8, complex: 10,
none: 7, few: 8, many: 10,
none: 7, basic: 8, advanced: 10,
standard: 7, custom: 10, complex: 10,
none: 7, basic: 9, strict: 10
}
}
const patternScores = scores[pattern as keyof typeof scores]
if (!patternScores) return 0
const weights = {
userScale: 0.25,
dataComplexity: 0.20,
integrations: 0.15,
realtime: 0.15,
customAuth: 0.15,
compliance: 0.10
}
let totalScore = 0
for (const [key, value] of Object.entries(requirements)) {
const score = patternScores[value as keyof typeof patternScores] || 0
const weight = weights[key as keyof typeof weights] || 0
totalScore += score * weight
}
return Math.round(totalScore * 10) / 10
}
詳細評価フレームワーク
多次元評価マトリックス
評価軸 | クライアント実装 | Edge Functions | 独立APIサーバー |
---|---|---|---|
開発速度 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
スケーラビリティ | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
カスタマイズ性 | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
セキュリティ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
運用負荷 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
コスト効率 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
学習コスト | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
長期保守性 | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
詳細評価基準
interface DetailedEvaluation {
development: {
timeToMarket: number // weeks
teamSkillRequirement: number // 1-5 scale
toolingMaturity: number // 1-5 scale
debuggingComplexity: number // 1-5 scale
}
operation: {
deploymentComplexity: number // 1-5 scale
monitoringRequirement: number // 1-5 scale
maintenanceEffort: number // hours/week
troubleshootingEase: number // 1-5 scale
}
business: {
initialCost: number // USD
monthlyOperationalCost: number // USD/month
scalingCost: number // USD per 10x growth
timeToBreakeven: number // months
}
technical: {
performanceBaseline: number // requests/second
maxScalability: number // max users
customizationFlexibility: number // 1-5 scale
integrationCapability: number // 1-5 scale
}
}
const patternEvaluations: Record<string, DetailedEvaluation> = {
client_implementation: {
development: {
timeToMarket: 4, // 4週間
teamSkillRequirement: 2, // 初級-中級
toolingMaturity: 5, // 非常に成熟
debuggingComplexity: 2 // 簡単
},
operation: {
deploymentComplexity: 1, // 非常に簡単
monitoringRequirement: 2, // 基本的な監視
maintenanceEffort: 5, // 5時間/週
troubleshootingEase: 4 // 比較的簡単
},
business: {
initialCost: 5000, // $5K
monthlyOperationalCost: 100, // $100/月
scalingCost: 500, // $500 per 10x
timeToBreakeven: 3 // 3ヶ月
},
technical: {
performanceBaseline: 100, // 100 req/sec
maxScalability: 10000, // 1万ユーザー
customizationFlexibility: 2, // 限定的
integrationCapability: 2 // 基本的
}
},
edge_functions: {
development: {
timeToMarket: 8, // 8週間
teamSkillRequirement: 3, // 中級
toolingMaturity: 4, // 成熟
debuggingComplexity: 3 // 中程度
},
operation: {
deploymentComplexity: 2, // 簡単
monitoringRequirement: 3, // 中程度の監視
maintenanceEffort: 10, // 10時間/週
troubleshootingEase: 3 // 中程度
},
business: {
initialCost: 15000, // $15K
monthlyOperationalCost: 300, // $300/月
scalingCost: 1500, // $1.5K per 10x
timeToBreakeven: 6 // 6ヶ月
},
technical: {
performanceBaseline: 500, // 500 req/sec
maxScalability: 100000, // 10万ユーザー
customizationFlexibility: 4, // 高い
integrationCapability: 5 // 非常に高い
}
},
independent_api: {
development: {
timeToMarket: 16, // 16週間
teamSkillRequirement: 4, // 上級
toolingMaturity: 5, // 非常に成熟
debuggingComplexity: 4 // 複雑
},
operation: {
deploymentComplexity: 4, // 複雑
monitoringRequirement: 5, // 包括的な監視
maintenanceEffort: 25, // 25時間/週
troubleshootingEase: 2 // 困難
},
business: {
initialCost: 50000, // $50K
monthlyOperationalCost: 1000, // $1K/月
scalingCost: 2000, // $2K per 10x
timeToBreakeven: 12 // 12ヶ月
},
technical: {
performanceBaseline: 2000, // 2000 req/sec
maxScalability: 1000000, // 100万ユーザー
customizationFlexibility: 5, // 無制限
integrationCapability: 5 // 無制限
}
}
}
要件別推奨パターン
1. プロジェクトタイプ別推奨
スタートアップ・MVP
const mvpRequirements = {
primaryGoals: ['迅速な市場投入', '低初期コスト', '検証可能性'],
constraints: ['限定予算', '小チーム', '短期間'],
recommendation: {
primary: 'client_implementation',
reason: '最速での市場投入と低コストを実現',
migrationPath: ['edge_functions', 'independent_api'],
keyBenefits: [
'2-4週間での初期リリース可能',
'初期コスト$5K以下',
'スキル要件が低い'
]
}
}
成長期スタートアップ
const growthStartupRequirements = {
primaryGoals: ['機能拡張', '外部連携', 'パフォーマンス向上'],
constraints: ['中程度予算', '中規模チーム', '競合対応'],
recommendation: {
primary: 'edge_functions',
reason: '拡張性と開発効率のバランス',
migrationPath: ['independent_api'],
keyBenefits: [
'複雑なビジネスロジック対応',
'外部API統合が容易',
'スケーラビリティ確保'
]
}
}
エンタープライズ
const enterpriseRequirements = {
primaryGoals: ['高可用性', 'セキュリティ', 'カスタマイズ', 'コンプライアンス'],
constraints: ['品質要求', '長期運用', '監査対応'],
recommendation: {
primary: 'independent_api',
reason: '最高レベルの制御と信頼性',
migrationPath: [], // 最終形態
keyBenefits: [
'完全なカスタマイズ制御',
'エンタープライズレベルの監視',
'コンプライアンス要件対応'
]
}
}
2. 業界・ドメイン別推奨
SaaS プラットフォーム
const saasRecommendation = {
characteristics: ['マルチテナント', 'API提供', 'サブスクリプション'],
stages: {
validation: {
pattern: 'client_implementation',
duration: '1-3 months',
focus: 'プロダクトマーケットフィット検証'
},
growth: {
pattern: 'edge_functions',
duration: '6-12 months',
focus: '機能拡張と外部連携'
},
scale: {
pattern: 'independent_api',
duration: '12+ months',
focus: 'エンタープライズ対応'
}
}
}
E-commerce
const ecommerceRecommendation = {
characteristics: ['決済処理', '在庫管理', '注文処理', '外部連携'],
criticalRequirements: ['PCI DSS', '高可用性', 'リアルタイム在庫'],
recommendation: {
primary: 'edge_functions',
reason: '決済・外部API統合が重要',
specialConsiderations: [
'決済処理の Edge Function 分離',
'在庫管理のリアルタイム同期',
'セキュリティ要件の厳格対応'
]
}
}
IoT・リアルタイムシステム
const iotRecommendation = {
characteristics: ['大量データ', 'リアルタイム処理', 'デバイス管理'],
criticalRequirements: ['低レイテンシ', 'スケーラビリティ', 'データ処理'],
recommendation: {
primary: 'independent_api',
reason: '大量データとリアルタイム処理要件',
specialConsiderations: [
'ストリーミングデータ処理',
'デバイス認証・管理',
'エッジコンピューティング連携'
]
}
}
3. チーム・組織特性別推奨
小規模チーム (1-3人)
const smallTeamStrategy = {
challenges: ['リソース制限', 'スキル制約', '時間圧迫'],
recommendation: {
start: 'client_implementation',
strategy: 'シンプルさ最優先',
learningPath: [
'Supabase基本機能習得',
'フロントエンド開発強化',
'RLS設計パターン学習'
],
avoidance: ['複雑な設定', '多重技術スタック', '高度な運用']
}
}
中規模チーム (4-10人)
const mediumTeamStrategy = {
opportunities: ['専門分化可能', '並行開発', '品質向上'],
recommendation: {
start: 'edge_functions',
strategy: '機能分散と専門化',
teamStructure: {
frontend: '2-3人',
backend: '2-3人',
infrastructure: '1-2人',
qa: '1人'
},
learningPath: [
'Deno/TypeScript習得',
'アーキテクチャ設計',
'CI/CD構築'
]
}
}
大規模チーム (10人以上)
const largeTeamStrategy = {
advantages: ['高度専門化', '品質保証', '運用体制'],
recommendation: {
start: 'independent_api',
strategy: '企業レベルの開発・運用',
teamStructure: {
architecture: '1-2人',
backend: '3-5人',
frontend: '3-5人',
devops: '2-3人',
qa: '2-3人',
security: '1-2人'
},
processes: [
'エンタープライズ開発プロセス',
'包括的テスト戦略',
'運用監視体制'
]
}
}
実装難易度・コスト分析
開発コスト詳細分析
interface CostBreakdown {
development: {
planning: number // person-days
implementation: number // person-days
testing: number // person-days
deployment: number // person-days
}
infrastructure: {
setup: number // USD one-time
monthly: number // USD/month
scaling: number // USD per 10x growth
}
maintenance: {
monitoring: number // hours/week
updates: number // hours/month
support: number // hours/week
}
team: {
minSkillLevel: 'junior' | 'mid' | 'senior'
specialistRequired: boolean
trainingRequired: number // days
}
}
const costAnalysis: Record<string, CostBreakdown> = {
client_implementation: {
development: {
planning: 3,
implementation: 15,
testing: 5,
deployment: 2
},
infrastructure: {
setup: 0,
monthly: 25,
scaling: 50
},
maintenance: {
monitoring: 2,
updates: 4,
support: 3
},
team: {
minSkillLevel: 'junior',
specialistRequired: false,
trainingRequired: 3
}
},
edge_functions: {
development: {
planning: 8,
implementation: 30,
testing: 12,
deployment: 5
},
infrastructure: {
setup: 500,
monthly: 75,
scaling: 150
},
maintenance: {
monitoring: 5,
updates: 8,
support: 6
},
team: {
minSkillLevel: 'mid',
specialistRequired: false,
trainingRequired: 7
}
},
independent_api: {
development: {
planning: 20,
implementation: 80,
testing: 30,
deployment: 15
},
infrastructure: {
setup: 5000,
monthly: 300,
scaling: 500
},
maintenance: {
monitoring: 15,
updates: 20,
support: 12
},
team: {
minSkillLevel: 'senior',
specialistRequired: true,
trainingRequired: 14
}
}
}
ROI 計算モデル
function calculateROI(
pattern: string,
projectParams: {
expectedRevenue: number, // monthly
projectDuration: number, // months
teamSize: number,
averageSalary: number // monthly per person
}
): {
totalCost: number,
breakEvenPoint: number, // months
roi12Months: number, // percentage
riskFactor: number // 1-5 scale
} {
const costs = costAnalysis[pattern]
if (!costs) throw new Error('Pattern not found')
// 開発コスト計算
const developmentCost = (
costs.development.planning +
costs.development.implementation +
costs.development.testing +
costs.development.deployment
) * (projectParams.averageSalary / 20) // day rate
// インフラコスト計算
const infrastructureCost = costs.infrastructure.setup +
(costs.infrastructure.monthly * projectParams.projectDuration)
// 運用コスト計算
const maintenanceCost = (
costs.maintenance.monitoring +
costs.maintenance.support
) * 4 * projectParams.projectDuration * (projectParams.averageSalary / 160) // hour rate
const totalCost = developmentCost + infrastructureCost + maintenanceCost
// ROI計算
const monthlyRevenue = projectParams.expectedRevenue
const breakEvenPoint = totalCost / monthlyRevenue
const revenue12Months = monthlyRevenue * 12
const roi12Months = ((revenue12Months - totalCost) / totalCost) * 100
// リスクファクター
const riskFactors = {
client_implementation: 2,
edge_functions: 3,
independent_api: 4
}
return {
totalCost,
breakEvenPoint,
roi12Months,
riskFactor: riskFactors[pattern as keyof typeof riskFactors] || 3
}
}
成功事例・ケーススタディ
ケーススタディ1: EdTech スタートアップ
背景
- 業界: 教育技術
- チーム: 3人(フルスタック2人、デザイナー1人)
- 予算: $50K
- 期間: 6ヶ月でMVP
選択パターン: クライアント実装
const edtechCase = {
initialDecision: {
pattern: 'client_implementation',
reasons: [
'小規模チーム',
'迅速なMVP開発',
'限定予算',
'シンプルな機能要件'
]
},
implementation: {
frontend: 'React + TypeScript',
authentication: 'Supabase Auth',
database: 'PostgreSQL via Supabase',
storage: 'Supabase Storage',
realtime: 'Supabase Realtime'
},
results: {
timeToMarket: '3 months',
initialUsers: 1000,
monthlyGrowth: '20%',
customerAcquisitionCost: '$25'
},
challenges: [
'RLS複雑性の増加',
'カスタム認証要件',
'パフォーマンス制限'
],
migrationPlan: {
trigger: '10,000 users',
nextPattern: 'edge_functions',
estimatedEffort: '2 months'
}
}
ケーススタディ2: フィンテック企業
背景
- 業界: 金融技術
- チーム: 12人
- 予算: $500K
- 要件: 決済処理、外部銀行API連携
選択パターン: Edge Functions
const fintechCase = {
initialDecision: {
pattern: 'edge_functions',
reasons: [
'複雑な決済ロジック',
'外部API統合重要',
'セキュリティ要件',
'コンプライアンス対応'
]
},
architecture: {
frontend: 'Next.js',
edgeFunctions: [
'payment_processing',
'bank_api_integration',
'compliance_checks',
'notification_service'
],
database: 'Supabase PostgreSQL',
monitoring: 'Grafana + Prometheus'
},
results: {
timeToMarket: '8 months',
transactionVolume: '$10M/month',
uptime: '99.95%',
complianceAuditPassed: true
},
keySuccessFactors: [
'Edge Functions による決済処理分離',
'包括的なエラーハンドリング',
'詳細な監査ログ',
'段階的ロールアウト'
]
}
ケーススタディ3: エンタープライズSaaS
背景
- 業界: HR Tech
- チーム: 25人
- 要件: マルチテナント、SOC2準拠、カスタマイズ対応
選択パターン: 独立APIサーバー
const enterpriseCase = {
initialDecision: {
pattern: 'independent_api',
reasons: [
'エンタープライズ顧客要件',
'SOC2コンプライアンス',
'高度なカスタマイズ',
'大規模スケーリング'
]
},
architecture: {
apiServer: 'FastAPI + Python',
database: 'Supabase PostgreSQL + Read Replicas',
cache: 'Redis Cluster',
queue: 'Celery + RabbitMQ',
monitoring: 'DataDog',
deployment: 'Kubernetes + Helm'
},
results: {
customers: 500,
averageContractValue: '$50K/year',
uptime: '99.99%',
soc2Compliance: true,
customizations: '80% of customers'
},
criticalDecisions: [
'マイクロサービス vs モノリス → モノリス選択',
'カスタムORM vs 既存ORM → SQLAlchemy選択',
'セルフホスト vs クラウド → ハイブリッド選択'
]
}
意思決定支援ツール
パターン選択診断ツール
interface ProjectAssessment {
// 基本情報
teamSize: number
budget: number
timeline: number
// 技術要件
expectedUsers: number
dataComplexity: 1 | 2 | 3 | 4 | 5
integrationNeeds: number
customAuthRequired: boolean
complianceRequired: boolean
// ビジネス要件
revenueModel: 'subscription' | 'transaction' | 'advertising' | 'enterprise'
competitiveAdvantage: 'speed' | 'features' | 'quality' | 'cost'
riskTolerance: 'low' | 'medium' | 'high'
}
class PatternRecommendationEngine {
assessProject(assessment: ProjectAssessment): {
primaryRecommendation: string
confidence: number
alternatives: Array<{pattern: string, score: number}>
warnings: string[]
nextSteps: string[]
} {
const scores = this.calculateScores(assessment)
const primaryPattern = this.getPrimaryRecommendation(scores)
const confidence = this.calculateConfidence(scores, primaryPattern)
return {
primaryRecommendation: primaryPattern,
confidence,
alternatives: this.getAlternatives(scores, primaryPattern),
warnings: this.generateWarnings(assessment, primaryPattern),
nextSteps: this.getNextSteps(primaryPattern)
}
}
private calculateScores(assessment: ProjectAssessment): Record<string, number> {
const weights = {
teamSize: 0.2,
budget: 0.15,
timeline: 0.15,
expectedUsers: 0.15,
dataComplexity: 0.1,
integrationNeeds: 0.1,
customAuth: 0.05,
compliance: 0.1
}
// スコア計算ロジック
const clientScore = this.calculateClientScore(assessment, weights)
const edgeScore = this.calculateEdgeScore(assessment, weights)
const apiScore = this.calculateApiScore(assessment, weights)
return {
client_implementation: clientScore,
edge_functions: edgeScore,
independent_api: apiScore
}
}
private calculateClientScore(assessment: ProjectAssessment, weights: any): number {
let score = 0
// チームサイズ (小さいほど高スコア)
score += (assessment.teamSize <= 3 ? 10 :
assessment.teamSize <= 6 ? 7 : 3) * weights.teamSize
// 予算 (少ないほど高スコア)
score += (assessment.budget <= 50000 ? 10 :
assessment.budget <= 100000 ? 6 : 2) * weights.budget
// 期間 (短いほど高スコア)
score += (assessment.timeline <= 3 ? 10 :
assessment.timeline <= 6 ? 7 : 4) * weights.timeline
// ユーザー数 (少ないほど高スコア)
score += (assessment.expectedUsers <= 1000 ? 10 :
assessment.expectedUsers <= 10000 ? 6 : 2) * weights.expectedUsers
// データ複雑度 (シンプルほど高スコア)
score += (6 - assessment.dataComplexity) * 2 * weights.dataComplexity
// 外部連携 (少ないほど高スコア)
score += (assessment.integrationNeeds === 0 ? 10 :
assessment.integrationNeeds <= 2 ? 6 : 2) * weights.integrationNeeds
// カスタム認証 (不要なほど高スコア)
score += (!assessment.customAuthRequired ? 10 : 3) * weights.customAuth
// コンプライアンス (不要なほど高スコア)
score += (!assessment.complianceRequired ? 10 : 2) * weights.compliance
return Math.round(score * 10) / 10
}
private calculateEdgeScore(assessment: ProjectAssessment, weights: any): number {
// Edge Functions に適したスコア計算
let score = 0
// 中規模チームで高スコア
score += (assessment.teamSize >= 4 && assessment.teamSize <= 10 ? 10 : 6) * weights.teamSize
// 中程度予算で高スコア
score += (assessment.budget >= 50000 && assessment.budget <= 200000 ? 10 : 6) * weights.budget
// 外部連携があると高スコア
score += (assessment.integrationNeeds > 0 ? 10 : 5) * weights.integrationNeeds
// 中程度の複雑さで高スコア
score += (assessment.dataComplexity >= 2 && assessment.dataComplexity <= 4 ? 10 : 6) * weights.dataComplexity
return Math.round(score * 10) / 10
}
private calculateApiScore(assessment: ProjectAssessment, weights: any): number {
// 独立APIサーバーに適したスコア計算
let score = 0
// 大規模チームで高スコア
score += (assessment.teamSize >= 8 ? 10 : 4) * weights.teamSize
// 高予算で高スコア
score += (assessment.budget >= 100000 ? 10 : 3) * weights.budget
// 大規模ユーザーで高スコア
score += (assessment.expectedUsers >= 50000 ? 10 : 5) * weights.expectedUsers
// 高複雑度で高スコア
score += (assessment.dataComplexity >= 4 ? 10 : 5) * weights.dataComplexity
// コンプライアンス要件で高スコア
score += (assessment.complianceRequired ? 10 : 3) * weights.compliance
return Math.round(score * 10) / 10
}
private getPrimaryRecommendation(scores: Record<string, number>): string {
return Object.entries(scores).sort(([,a], [,b]) => b - a)[0][0]
}
private calculateConfidence(scores: Record<string, number>, primary: string): number {
const sortedScores = Object.values(scores).sort((a, b) => b - a)
const primaryScore = scores[primary]
const secondaryScore = sortedScores[1]
// スコア差に基づく信頼度計算
const scoreDiff = primaryScore - secondaryScore
return Math.min(Math.round((scoreDiff / primaryScore) * 100), 95)
}
private getAlternatives(scores: Record<string, number>, primary: string): Array<{pattern: string, score: number}> {
return Object.entries(scores)
.filter(([pattern]) => pattern !== primary)
.map(([pattern, score]) => ({pattern, score}))
.sort((a, b) => b.score - a.score)
}
private generateWarnings(assessment: ProjectAssessment, recommendation: string): string[] {
const warnings: string[] = []
if (recommendation === 'client_implementation') {
if (assessment.expectedUsers > 10000) {
warnings.push('大規模ユーザー対応時にパフォーマンス問題が発生する可能性があります')
}
if (assessment.complianceRequired) {
warnings.push('コンプライアンス要件の実装が困難な場合があります')
}
}
if (recommendation === 'edge_functions') {
if (assessment.teamSize < 3) {
warnings.push('Deno/TypeScriptの学習コストが発生します')
}
if (assessment.dataComplexity >= 4) {
warnings.push('複雑なデータ処理には制限があります')
}
}
if (recommendation === 'independent_api') {
if (assessment.teamSize < 8) {
warnings.push('運用負荷が高く、専門知識が必要です')
}
if (assessment.timeline < 6) {
warnings.push('開発期間が長期化する可能性があります')
}
}
return warnings
}
private getNextSteps(recommendation: string): string[] {
const nextSteps = {
client_implementation: [
'Supabaseプロジェクトのセットアップ',
'RLS設計の検討',
'フロントエンド開発環境の構築',
'プロトタイプ開発開始'
],
edge_functions: [
'Deno開発環境のセットアップ',
'Edge Functions設計の検討',
'外部API連携の調査',
'パイロット機能の実装'
],
independent_api: [
'アーキテクチャ設計の詳細化',
'インフラ要件の定義',
'開発チーム編成',
'プロトタイプ環境構築'
]
}
return nextSteps[recommendation as keyof typeof nextSteps] || []
}
}
// 使用例
const assessmentTool = new PatternRecommendationEngine()
const result = assessmentTool.assessProject({
teamSize: 5,
budget: 75000,
timeline: 6,
expectedUsers: 25000,
dataComplexity: 3,
integrationNeeds: 2,
customAuthRequired: true,
complianceRequired: false,
revenueModel: 'subscription',
competitiveAdvantage: 'features',
riskTolerance: 'medium'
})
console.log('推奨パターン:', result.primaryRecommendation)
console.log('信頼度:', result.confidence + '%')
console.log('次のステップ:', result.nextSteps)
このガイドにより、プロジェクトの特性と要件に基づいて最適なSupabaseアーキテクチャパターンを体系的に選択できるようになります。