moai-adk 0.25.4__py3-none-any.whl → 0.32.8__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-platform-baas/reference.md

@@ -0,0 +1,567 @@
+# BaaS Provider Reference Documentation
+
+## Authentication Providers
+
+### Auth0
+Context7 ID: `/auth0/auth0-docs` 
+Enterprise Focus: SSO, B2B SaaS, 50+ enterprise connections 
+Key Features:
+- Enterprise SSO with SAML, OIDC, ADFS
+- B2B SaaS with organizations and RBAC
+- 50+ pre-built enterprise connections
+- Advanced security with anomaly detection
+- Custom database connections
+
+API Documentation:
+```python
+# Auth0 Management API
+import auth0
+
+management = auth0.Auth0(
+ domain='YOUR_DOMAIN.auth0.com',
+ client_id='YOUR_CLIENT_ID',
+ client_secret='YOUR_CLIENT_SECRET'
+)
+
+# Create organization
+org = management.organizations.create({
+ 'name': 'Acme Corp',
+ 'display_name': 'Acme Corporation',
+ 'metadata': {'tier': 'enterprise'}
+})
+```
+
+Context7 Integration:
+```python
+async def get_auth0_patterns():
+ """Get latest Auth0 enterprise patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/auth0/auth0-docs",
+ topic="enterprise sso b2b saas organizations connections",
+ tokens=4000
+ )
+ return docs
+```
+
+### Clerk
+Context7 ID: `/clerk/clerk-docs` 
+Modern Focus: WebAuthn, Organizations, Multi-platform 
+Key Features:
+- Modern WebAuthn and passkey support
+- Built-in organization management
+- Multi-platform SDKs (React, Next.js, Vue, Svelte)
+- Beautiful pre-built UI components
+- Backend API for custom integrations
+
+API Documentation:
+```python
+# Clerk Backend SDK
+import clerk
+
+client = clerk.Clerk(api_key='sk_test_...')
+
+# Create user with WebAuthn
+user = client.users.create({
+ 'first_name': 'John',
+ 'last_name': 'Doe',
+ 'email_address': ['john@example.com'],
+ 'webauthn_options': {
+ 'verification_requirement': 'required'
+ }
+})
+```
+
+Context7 Integration:
+```python
+async def get_clerk_patterns():
+ """Get latest Clerk modern authentication patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/clerk/clerk-docs",
+ topic="webauthn passkeys organizations multi-platform",
+ tokens=4000
+ )
+ return docs
+```
+
+### Firebase Auth
+Context7 ID: `/firebase/firebase-docs` 
+Google Focus: Google ecosystem integration 
+Key Features:
+- Deep Google services integration
+- Firebase Analytics integration
+- Cloud Functions triggers
+- Mobile-first design
+- Google Cloud Platform integration
+
+API Documentation:
+```python
+# Firebase Admin SDK
+import firebase_admin
+from firebase_admin import auth
+
+# Initialize Firebase
+cred = firebase_admin.credentials.Certificate('service-account.json')
+firebase_admin.initialize_app(cred)
+
+# Create user with Google provider
+user = auth.create_user(
+ email='user@example.com',
+ password='password123',
+ provider='google.com'
+)
+```
+
+Context7 Integration:
+```python
+async def get_firebase_auth_patterns():
+ """Get latest Firebase Auth patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/firebase/firebase-docs",
+ topic="authentication google integration mobile-first",
+ tokens=4000
+ )
+ return docs
+```
+
+## Database Providers
+
+### Supabase
+Context7 ID: `/supabase/supabase` 
+PostgreSQL Focus: PostgreSQL 16+, RLS, Edge Functions 
+Key Features:
+- PostgreSQL 16 with pgvector and AI extensions
+- Row-Level Security for multi-tenant
+- Real-time subscriptions
+- Edge Functions (Deno runtime)
+- Auto-generated REST APIs
+
+API Documentation:
+```python
+# Supabase Python Client
+from supabase import create_client, Client
+
+# Initialize Supabase
+supabase: Client = create_client(
+ supabase_url='https://YOUR_PROJECT.supabase.co',
+ supabase_key='YOUR_ANON_KEY'
+)
+
+# Real-time subscription
+def handle_changes(payload):
+ print('Change received!', payload)
+
+supabase.table('messages').on(
+ 'INSERT',
+ handle_changes
+).subscribe()
+```
+
+Context7 Integration:
+```python
+async def get_supabase_patterns():
+ """Get latest Supabase PostgreSQL 16 patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/supabase/supabase",
+ topic="postgresql-16 rls edge-functions pgvector realtime",
+ tokens=5000
+ )
+ return docs
+```
+
+### Neon
+Context7 ID: `/neondatabase/neon` 
+Serverless Focus: Auto-scaling, 30-day PIT 
+Key Features:
+- Serverless PostgreSQL with auto-scaling
+- Instant database branching
+- 30-day Point-in-Time Recovery
+- Compute isolation
+- Global edge locations
+
+API Documentation:
+```python
+# Neon Python Client
+import neon
+
+# Initialize Neon client
+client = neon.Client(api_key='YOUR_API_KEY')
+
+# Create branch
+branch = client.branches.create(
+ project_id='YOUR_PROJECT_ID',
+ name='feature-branch',
+ parent_id='main'
+)
+```
+
+Context7 Integration:
+```python
+async def get_neon_patterns():
+ """Get latest Neon serverless PostgreSQL patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/neondatabase/neon",
+ topic="serverless auto-scaling branching pitr compute",
+ tokens=4000
+ )
+ return docs
+```
+
+### Convex
+Context7 ID: `/get-convex/convex` 
+Real-time Focus: Real-time backend, Database branching 
+Key Features:
+- Real-time reactive queries
+- Instant database branching
+- Optimistic updates
+- TypeScript-first design
+- Built-in caching and persistence
+
+API Documentation:
+```python
+# Convex Client
+import { convexHono } from 'convex/server';
+import { mutation, query } from './_generated/server';
+
+// Real-time mutation
+export const sendMessage = mutation({
+ args: { text: v.string(), author: v.string() },
+ handler: async (ctx, args) => {
+ await ctx.db.insert('messages', {
+ text: args.text,
+ author: args.author,
+ createdAt: Date.now()
+ });
+ }
+});
+
+// Reactive query
+export const listMessages = query({
+ handler: async (ctx) => {
+ return await ctx.db.query('messages').order('desc').collect();
+ }
+});
+```
+
+Context7 Integration:
+```python
+async def get_convex_patterns():
+ """Get latest Convex real-time patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/get-convex/convex",
+ topic="realtime reactive database-branching optimistic-updates",
+ tokens=4000
+ )
+ return docs
+```
+
+### Firebase Firestore
+Context7 ID: `/firebase/firebase-docs` 
+Mobile Focus: Real-time sync, Mobile-first 
+Key Features:
+- Real-time synchronization
+- Mobile-first SDKs
+- Offline caching
+- Cloud Functions integration
+- Google ecosystem integration
+
+API Documentation:
+```python
+# Firebase Firestore
+from firebase_admin import firestore
+
+# Initialize Firestore
+db = firestore.client()
+
+# Real-time listener
+def on_snapshot(doc_snapshot, changes, read_time):
+ for doc in doc_snapshot:
+ print(f'{doc.id} => {doc.to_dict()}')
+
+doc_ref = db.collection('cities').document('SF')
+doc_ref.on_snapshot(on_snapshot)
+```
+
+Context7 Integration:
+```python
+async def get_firestore_patterns():
+ """Get latest Firestore mobile-first patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/firebase/firebase-docs",
+ topic="firestore realtime sync mobile offline",
+ tokens=4000
+ )
+ return docs
+```
+
+## Deployment Platforms
+
+### Vercel
+Context7 ID: `/vercel/vercel` 
+Edge Focus: Edge deployment, Next.js optimization 
+Key Features:
+- Global edge network
+- Next.js optimization
+- Edge Functions
+- Zero-configuration deployments
+- Analytics and observability
+
+API Documentation:
+```python
+# Vercel SDK
+from vercel import Vercel
+
+# Initialize Vercel client
+client = Vercel(token='YOUR_VERCEL_TOKEN')
+
+# Deploy project
+deployment = client.deployments.create(
+ project_id='YOUR_PROJECT_ID',
+ git_source={
+ 'type': 'github',
+ 'repo': 'your-org/your-repo'
+ }
+)
+```
+
+Context7 Integration:
+```python
+async def get_vercel_patterns():
+ """Get latest Vercel edge deployment patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/vercel/vercel",
+ topic="edge deployment nextjs optimization edge-functions",
+ tokens=5000
+ )
+ return docs
+```
+
+### Railway
+Context7 ID: `/railwayapp/docs` 
+Container Focus: Full-stack containers, Multi-region 
+Key Features:
+- Full-stack container deployment
+- Multi-region support
+- Built-in CI/CD
+- Environment variables management
+- Database as a service
+
+API Documentation:
+```python
+# Railway CLI Commands
+# Install Railway CLI
+npm install -g @railway/cli
+
+# Login
+railway login
+
+# Deploy project
+railway up
+
+# Set environment variables
+railway variables set DATABASE_URL=postgresql://...
+```
+
+Context7 Integration:
+```python
+async def get_railway_patterns():
+ """Get latest Railway container deployment patterns."""
+ docs = await mcp__context7__get_library_docs(
+ context7CompatibleLibraryID="/railwayapp/docs",
+ topic="container deployment multi-region ci-cd docker",
+ tokens=4000
+ )
+ return docs
+```
+
+## Cross-Provider Integration Patterns
+
+### Pattern 1: Auth0 + Supabase + Vercel (Enterprise)
+```python
+class EnterpriseStack:
+ """Enterprise SaaS integration pattern."""
+ 
+ def setup(self):
+ return {
+ "authentication": {
+ "provider": "auth0",
+ "features": ["sso", "organizations", "rbac"]
+ },
+ "database": {
+ "provider": "supabase", 
+ "features": ["postgresql_16", "rls", "realtime"]
+ },
+ "deployment": {
+ "provider": "vercel",
+ "features": ["edge_functions", "analytics"]
+ }
+ }
+```
+
+### Pattern 2: Clerk + Neon + Railway (Modern)
+```python
+class ModernStack:
+ """Modern web application pattern."""
+ 
+ def setup(self):
+ return {
+ "authentication": {
+ "provider": "clerk",
+ "features": ["webauthn", "organizations"]
+ },
+ "database": {
+ "provider": "neon",
+ "features": ["serverless", "branching", "pitr"]
+ },
+ "deployment": {
+ "provider": "railway",
+ "features": ["containers", "ci_cd"]
+ }
+ }
+```
+
+### Pattern 3: Clerk + Convex + Vercel (Real-time)
+```python
+class RealtimeStack:
+ """Real-time collaborative pattern."""
+ 
+ def setup(self):
+ return {
+ "authentication": {
+ "provider": "clerk",
+ "features": ["organizations", "multi_tenant"]
+ },
+ "database": {
+ "provider": "convex",
+ "features": ["realtime", "reactive", "optimistic_updates"]
+ },
+ "deployment": {
+ "provider": "vercel",
+ "features": ["edge", "websocket_support"]
+ }
+ }
+```
+
+## Migration Templates
+
+### Auth0 → Clerk Migration
+```python
+class Auth0ToClerkMigration:
+ """Complete migration from Auth0 to Clerk."""
+ 
+ def export_auth0_data(self):
+ """Export users and organizations from Auth0."""
+ return {
+ "users": self.export_users(),
+ "organizations": self.export_organizations(),
+ "connections": self.export_connections()
+ }
+ 
+ def transform_for_clerk(self, auth0_data):
+ """Transform Auth0 data for Clerk import."""
+ return {
+ "users": self.transform_users(auth0_data["users"]),
+ "organizations": self.transform_organizations(auth0_data["organizations"])
+ }
+ 
+ def import_to_clerk(self, clerk_data):
+ """Import transformed data to Clerk."""
+ self.import_users(clerk_data["users"])
+ self.import_organizations(clerk_data["organizations"])
+```
+
+### Supabase → Neon Migration
+```python
+class SupabaseToNeonMigration:
+ """Migration from Supabase to Neon."""
+ 
+ def export_supabase_schema(self):
+ """Export PostgreSQL schema from Supabase."""
+ return self.execute_sql("pg_dump --schema-only")
+ 
+ def export_supabase_data(self):
+ """Export data from Supabase."""
+ return self.execute_sql("pg_dump --data-only")
+ 
+ def create_neon_database(self):
+ """Create new Neon database."""
+ return neon_client.databases.create(project_id=self.project_id)
+ 
+ def import_to_neon(self, schema, data):
+ """Import schema and data to Neon."""
+ self.execute_sql_on_neon(schema)
+ self.execute_sql_on_neon(data)
+```
+
+## Cost Analysis
+
+### Provider Cost Comparison
+| Provider | Free Tier | Pro Tier | Enterprise | Key Metrics |
+|----------|-----------|----------|------------|-------------|
+| Auth0 | 7k MAU | Custom | Custom | SSO connections |
+| Clerk | 5k MAU | $25/mo 10k | Custom | Organizations |
+| Firebase Auth | 10k MAU | $0.02/MAU | Custom | Google integration |
+| Supabase | 500MB DB | $25/mo | Custom | PostgreSQL 16 |
+| Neon | 3GB DB | $0.10/GB | Custom | Serverless scaling |
+| Convex | 500MB DB | $25/mo | Custom | Real-time queries |
+| Firestore | 1GB storage | $0.18/GB | Custom | Mobile sync |
+| Vercel | Hobby $20/mo | Pro $20/mo | Enterprise | Edge functions |
+| Railway | $5/mo | $20/mo | Enterprise | Container instances |
+
+### Cost Optimization Strategies
+```python
+class CostOptimizer:
+ """AI-powered cost optimization for BaaS providers."""
+ 
+ def analyze_usage_patterns(self, metrics):
+ """Analyze usage patterns and identify optimization opportunities."""
+ return {
+ "database": self.analyze_database_usage(metrics["database"]),
+ "authentication": self.analyze_auth_usage(metrics["auth"]),
+ "deployment": self.analyze_deployment_usage(metrics["deployment"])
+ }
+ 
+ def recommend_optimizations(self, analysis):
+ """Generate optimization recommendations."""
+ recommendations = []
+ 
+ if analysis["database"]["wasted_capacity"] > 0.3:
+ recommendations.append({
+ "type": "database_rightsize",
+ "savings": "$50-200/month",
+ "action": "Downgrade database tier or switch to serverless"
+ })
+ 
+ if analysis["authentication"]["unused_features"]:
+ recommendations.append({
+ "type": "feature_cleanup",
+ "savings": "$20-100/month", 
+ "action": "Remove unused auth features"
+ })
+ 
+ return recommendations
+```
+
+## Security Compliance
+
+### GDPR Compliance Matrix
+| Provider | Data Residency | Right to Deletion | Data Processing | Audit Logs |
+|----------|----------------|-------------------|-----------------|------------|
+| Auth0 | EU/US | API | DPA | Available |
+| Clerk | EU/US | API | DPA | Available |
+| Supabase | EU/US | API | DPA | PostgreSQL |
+| Neon | EU/US | API | DPA | PostgreSQL |
+| Vercel | Global | API | DPA | Available |
+
+### HIPAA Compliance Matrix
+| Provider | BAA Available | PHI Storage | Audit Trail | Access Controls |
+|----------|---------------|-------------|-------------|----------------|
+| Auth0 | Enterprise | No | Available | Role-based |
+| Supabase | Enterprise | RLS | PostgreSQL | Row-level |
+| Neon | Enterprise | Custom | PostgreSQL | Custom |
+| Vercel | Enterprise | No | Available | Team-based |
+
+---
+
+Last Updated: 2025-11-25 
+Context7 Mappings: All 9 providers mapped and integrated 
+Status: Production Ready (Enterprise)