SaaS Architectuur Patronen: Schaalbare Applicaties Bouwen

// Probleem: Database queries die niet schalen
const userCount = await db.query('SELECT COUNT(*) FROM users');
console.log(`Gebruikers: ${userCount}`); // 1000 gebruikers

// Elke query raakt alle tenants
const users = await db.query('SELECT * FROM users WHERE tenant_id = ?', [tenantId]);
// Geen indexering, geen caching, geen optimalisatie

// Multi-tenant database patronen
interface Tenant {
  id: string;
  name: string;
  subdomain: string;
  plan: 'starter' | 'professional' | 'enterprise';
  createdAt: Date;
  settings: TenantSettings;
}

// Patroon 1: Shared Schema (aanbevolen voor startups)
interface SharedSchemaDesign {
  tables: {
    users: 'tenant_id + user_data';
    orders: 'tenant_id + order_data';
    products: 'tenant_id + product_data';
  };
  benefits: [
    'Eenvoudige implementatie',
    'Kosteneffectief',
    'Eenvoudige backup/restore'
  ];
  drawbacks: [
    'Mogelijke data lekken',
    'Complexe queries',
    'Moeilijke tenant isolatie'
  ];
}

// Patroon 2: Separate Schema (aanbevolen voor groei)
interface SeparateSchemaDesign {
  schemas: {
    tenant_1: 'Alle tabellen voor tenant 1';
    tenant_2: 'Alle tabellen voor tenant 2';
    tenant_3: 'Alle tabellen voor tenant 3';
  };
  benefits: [
    'Betere tenant isolatie',
    'Eenvoudigere queries',
    'Betere performance'
  ];
  drawbacks: [
    'Complexere implementatie',
    'Hogere kosten',
    'Complexere backup/restore'
  ];
}

// Implementatie: Shared Schema met tenant isolatie
class TenantAwareRepository {
  private db: Database;
  private tenantId: string;

  constructor(db: Database, tenantId: string) {
    this.db = db;
    this.tenantId = tenantId;
  }

  async findUsers(): Promise<User[]> {
    // Automatische tenant isolatie
    return this.db.query(
      'SELECT * FROM users WHERE tenant_id = ?',
      [this.tenantId]
    );
  }

  async createUser(userData: UserData): Promise<User> {
    // Automatische tenant_id toevoeging
    const result = await this.db.query(
      'INSERT INTO users (tenant_id, name, email) VALUES (?, ?, ?)',
      [this.tenantId, userData.name, userData.email]
    );
    
    return this.findUserById(result.insertId);
  }
}

// Tenant resolution systeem
interface TenantResolver {
  resolveTenant(request: Request): Promise<Tenant>;
  cacheTenant(tenant: Tenant): void;
  invalidateTenant(tenantId: string): void;
}

class CachedTenantResolver implements TenantResolver {
  private redis: Redis;
  private db: Database;
  private cache: Map<string, Tenant> = new Map();

  async resolveTenant(request: Request): Promise<Tenant> {
    const subdomain = this.extractSubdomain(request);
    const cacheKey = `tenant:${subdomain}`;
    
    // Probeer cache eerst
    let tenant = this.cache.get(cacheKey);
    if (tenant) {
      return tenant;
    }

    // Probeer Redis cache
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      tenant = JSON.parse(cached);
      this.cache.set(cacheKey, tenant);
      return tenant;
    }

    // Haal uit database
    const result = await this.db.query(
      'SELECT * FROM tenants WHERE subdomain = ?',
      [subdomain]
    );

    if (result.length === 0) {
      throw new Error('Tenant niet gevonden');
    }

    tenant = result[0];
    
    // Cache voor volgende keer
    await this.redis.setex(cacheKey, 3600, JSON.stringify(tenant)); // 1 uur TTL
    this.cache.set(cacheKey, tenant);

    return tenant;
  }

  private extractSubdomain(request: Request): string {
    const host = request.headers.host;
    const parts = host.split('.');
    return parts[0]; // eerste deel is subdomain
  }

  async invalidateTenant(tenantId: string): Promise<void> {
    // Verwijder uit alle caches
    const tenant = await this.db.query(
      'SELECT subdomain FROM tenants WHERE id = ?',
      [tenantId]
    );

    if (tenant.length > 0) {
      const subdomain = tenant[0].subdomain;
      const cacheKey = `tenant:${subdomain}`;
      
      await this.redis.del(cacheKey);
      this.cache.delete(cacheKey);
    }
  }
}

// Schaalbare API architectuur
interface APIDesign {
  versioning: 'URL-based' | 'Header-based';
  authentication: 'JWT' | 'OAuth2';
  rateLimiting: 'Per-tenant' | 'Per-user';
  caching: 'Redis' | 'CDN';
  monitoring: 'Real-time' | 'Batch';
}

class ScalableAPIService {
  private tenantResolver: TenantResolver;
  private rateLimiter: RateLimiter;
  private cache: Cache;
  private monitor: Monitor;

  async handleRequest(request: Request): Promise<Response> {
    // 1. Resolve tenant
    const tenant = await this.tenantResolver.resolveTenant(request);
    
    // 2. Rate limiting per tenant
    const rateLimit = await this.rateLimiter.checkLimit(tenant.id);
    if (!rateLimit.allowed) {
      return new Response('Rate limit exceeded', { status: 429 });
    }

    // 3. Cache check
    const cacheKey = this.generateCacheKey(request, tenant.id);
    const cached = await this.cache.get(cacheKey);
    if (cached) {
      return new Response(cached, {
        headers: { 'X-Cache': 'HIT' }
      });
    }

    // 4. Process request
    const result = await this.processRequest(request, tenant);
    
    // 5. Cache result
    await this.cache.set(cacheKey, result, 300); // 5 minuten TTL
    
    // 6. Monitor performance
    await this.monitor.trackRequest(request, tenant, result);

    return new Response(result, {
      headers: { 'X-Cache': 'MISS' }
    });
  }

  private async processRequest(request: Request, tenant: Tenant): Promise<any> {
    // Tenant-aware request processing
    const repository = new TenantAwareRepository(this.db, tenant.id);
    
    switch (request.method) {
      case 'GET':
        return await repository.findUsers();
      case 'POST':
        return await repository.createUser(await request.json());
      default:
        throw new Error('Method not supported');
    }
  }
}

// Probleem: Monolithische SaaS
interface MonolithicSaaS {
  components: [
    'User Management',
    'Order Processing',
    'Payment Processing',
    'Notification Service',
    'Analytics Service'
  ];
  issues: [
    'Moeilijke schaalbaarheid',
    'Single point of failure',
    'Complexe deployment',
    'Technologie lock-in'
  ];
}

// Microservices architectuur
interface MicroservicesArchitecture {
  services: {
    userService: 'User management en authenticatie';
    orderService: 'Order processing en workflow';
    paymentService: 'Payment processing en billing';
    notificationService: 'Email, SMS, push notifications';
    analyticsService: 'Data analytics en reporting';
  };
  benefits: [
    'Individuele schaalbaarheid',
    'Technologie diversiteit',
    'Fault isolation',
    'Team autonomy'
  ];
}

// Service discovery en communicatie
class ServiceRegistry {
  private services: Map<string, ServiceEndpoint> = new Map();

  registerService(name: string, endpoint: ServiceEndpoint): void {
    this.services.set(name, endpoint);
  }

  getService(name: string): ServiceEndpoint {
    const service = this.services.get(name);
    if (!service) {
      throw new Error(`Service ${name} not found`);
    }
    return service;
  }

  async callService(serviceName: string, method: string, data: any): Promise<any> {
    const service = this.getService(serviceName);
    const response = await fetch(`${service.url}/${method}`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data)
    });
    
    if (!response.ok) {
      throw new Error(`Service call failed: ${response.statusText}`);
    }
    
    return response.json();
  }
}

// Tenant-aware service communicatie
class TenantAwareServiceClient {
  private serviceRegistry: ServiceRegistry;
  private tenantId: string;

  constructor(serviceRegistry: ServiceRegistry, tenantId: string) {
    this.serviceRegistry = serviceRegistry;
    this.tenantId = tenantId;
  }

  async callUserService(method: string, data: any): Promise<any> {
    return this.serviceRegistry.callService('userService', method, {
      ...data,
      tenantId: this.tenantId
    });
  }

  async callOrderService(method: string, data: any): Promise<any> {
    return this.serviceRegistry.callService('orderService', method, {
      ...data,
      tenantId: this.tenantId
    });
  }
}

// Probleem: Performance degradatie
interface PerformanceIssue {
  type: 'slow_queries' | 'memory_leaks' | 'connection_pool_exhaustion';
  service: string;
  impact: 'high' | 'medium' | 'low';
  timestamp: Date;
}

// Performance monitoring systeem
class PerformanceMonitor {
  private metrics: Map<string, Metric[]> = new Map();
  private alerts: Alert[] = [];

  async trackMetric(service: string, metric: Metric): Promise<void> {
    if (!this.metrics.has(service)) {
      this.metrics.set(service, []);
    }
    
    this.metrics.get(service)!.push(metric);
    
    // Controleer op alerts
    await this.checkAlerts(service, metric);
  }

  private async checkAlerts(service: string, metric: Metric): Promise<void> {
    // Response time alert
    if (metric.type === 'response_time' && metric.value > 1000) {
      await this.triggerAlert({
        type: 'high_response_time',
        service,
        value: metric.value,
        threshold: 1000,
        timestamp: new Date()
      });
    }

    // Memory usage alert
    if (metric.type === 'memory_usage' && metric.value > 80) {
      await this.triggerAlert({
        type: 'high_memory_usage',
        service,
        value: metric.value,
        threshold: 80,
        timestamp: new Date()
      });
    }
  }

  async triggerAlert(alert: Alert): Promise<void> {
    this.alerts.push(alert);
    
    // Notificeer beheerder
    await this.notifyAdmin(alert);
    
    // Auto-scaling trigger
    if (alert.type === 'high_response_time') {
      await this.triggerAutoScaling(alert.service);
    }
  }

  async triggerAutoScaling(service: string): Promise<void> {
    // Implementeer auto-scaling logica
    const currentInstances = await this.getServiceInstances(service);
    const targetInstances = Math.min(currentInstances * 2, 10); // Max 10 instances
    
    await this.scaleService(service, targetInstances);
  }
}