@stacksjs/ts-cloud-core 0.1.7 → 0.1.9

package/src/database/replicas.ts

@@ -0,0 +1,534 @@
+/**
+ * Database Replicas & Connection Pooling
+ * Read replica management and RDS Proxy for connection pooling
+ */
+
+export interface ReadReplica {
+  id: string
+  name: string
+  sourceDatabase: string
+  region: string
+  instanceClass: string
+  multiAZ?: boolean
+  autoMinorVersionUpgrade?: boolean
+  backupRetentionPeriod?: number
+  preferredBackupWindow?: string
+  preferredMaintenanceWindow?: string
+  replicationLag?: number // milliseconds
+  status?: 'creating' | 'available' | 'failing-over' | 'failed'
+}
+
+export interface ReplicationGroup {
+  id: string
+  name: string
+  primaryDatabase: string
+  replicas: ReadReplica[]
+  loadBalancing?: LoadBalancingStrategy
+  failoverEnabled?: boolean
+  autoScaling?: AutoScalingConfig
+}
+
+export interface LoadBalancingStrategy {
+  type: 'round-robin' | 'least-connections' | 'weighted' | 'latency-based'
+  weights?: Record<string, number> // replica ID -> weight
+}
+
+export interface AutoScalingConfig {
+  enabled: boolean
+  minReplicas: number
+  maxReplicas: number
+  targetCPU?: number
+  targetConnections?: number
+  scaleUpCooldown?: number // seconds
+  scaleDownCooldown?: number // seconds
+}
+
+export interface RDSProxy {
+  id: string
+  name: string
+  engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER'
+  targetDatabase: string
+  maxConnectionsPercent?: number
+  maxIdleConnectionsPercent?: number
+  connectionBorrowTimeout?: number // seconds
+  sessionPinningFilters?: SessionPinningFilter[]
+  requireTLS?: boolean
+  idleClientTimeout?: number // seconds
+  vpcSubnetIds: string[]
+  securityGroupIds: string[]
+  secretArn?: string
+}
+
+export type SessionPinningFilter =
+  | 'EXCLUDE_VARIABLE_SETS'
+
+export interface ProxyTarget {
+  id: string
+  proxyId: string
+  targetArn: string
+  targetType: 'RDS_INSTANCE' | 'RDS_CLUSTER' | 'TRACKED_CLUSTER'
+  isWritable: boolean
+  weight?: number
+}
+
+export interface ConnectionPoolConfig {
+  minPoolSize: number
+  maxPoolSize: number
+  connectionTimeout: number // seconds
+  idleTimeout: number // seconds
+  maxLifetime?: number // seconds
+  statementTimeout?: number // seconds
+}
+
+/**
+ * Replica manager
+ */
+export class ReplicaManager {
+  private replicas: Map<string, ReadReplica> = new Map()
+  private replicationGroups: Map<string, ReplicationGroup> = new Map()
+  private proxies: Map<string, RDSProxy> = new Map()
+  private proxyTargets: Map<string, ProxyTarget> = new Map()
+  private replicaCounter = 0
+  private groupCounter = 0
+  private proxyCounter = 0
+  private targetCounter = 0
+
+  /**
+   * Create read replica
+   */
+  createReplica(replica: Omit<ReadReplica, 'id'>): ReadReplica {
+    const id = `replica-${Date.now()}-${this.replicaCounter++}`
+
+    const readReplica: ReadReplica = {
+      id,
+      status: 'creating',
+      ...replica,
+    }
+
+    this.replicas.set(id, readReplica)
+
+    return readReplica
+  }
+
+  /**
+   * Create read replica for RDS instance
+   */
+  createRDSReplica(options: {
+    sourceDatabase: string
+    name: string
+    region?: string
+    instanceClass?: string
+    multiAZ?: boolean
+  }): ReadReplica {
+    return this.createReplica({
+      name: options.name,
+      sourceDatabase: options.sourceDatabase,
+      region: options.region || 'us-east-1',
+      instanceClass: options.instanceClass || 'db.t3.medium',
+      multiAZ: options.multiAZ || false,
+      autoMinorVersionUpgrade: true,
+      backupRetentionPeriod: 7,
+    })
+  }
+
+  /**
+   * Create cross-region replica
+   */
+  createCrossRegionReplica(options: {
+    sourceDatabase: string
+    name: string
+    targetRegion: string
+    instanceClass?: string
+    encrypted?: boolean
+  }): ReadReplica {
+    return this.createReplica({
+      name: options.name,
+      sourceDatabase: options.sourceDatabase,
+      region: options.targetRegion,
+      instanceClass: options.instanceClass || 'db.t3.medium',
+      multiAZ: true, // Cross-region replicas should be multi-AZ
+      autoMinorVersionUpgrade: true,
+      backupRetentionPeriod: 7,
+    })
+  }
+
+  /**
+   * Create replication group
+   */
+  createReplicationGroup(group: Omit<ReplicationGroup, 'id'>): ReplicationGroup {
+    const id = `replication-group-${Date.now()}-${this.groupCounter++}`
+
+    const replicationGroup: ReplicationGroup = {
+      id,
+      ...group,
+    }
+
+    this.replicationGroups.set(id, replicationGroup)
+
+    return replicationGroup
+  }
+
+  /**
+   * Create replication group with auto-scaling
+   */
+  createAutoScalingReplicationGroup(options: {
+    name: string
+    primaryDatabase: string
+    minReplicas: number
+    maxReplicas: number
+    targetCPU?: number
+    loadBalancing?: LoadBalancingStrategy
+  }): ReplicationGroup {
+    return this.createReplicationGroup({
+      name: options.name,
+      primaryDatabase: options.primaryDatabase,
+      replicas: [],
+      loadBalancing: options.loadBalancing || { type: 'round-robin' },
+      failoverEnabled: true,
+      autoScaling: {
+        enabled: true,
+        minReplicas: options.minReplicas,
+        maxReplicas: options.maxReplicas,
+        targetCPU: options.targetCPU || 70,
+        scaleUpCooldown: 300,
+        scaleDownCooldown: 600,
+      },
+    })
+  }
+
+  /**
+   * Add replica to group
+   */
+  addReplicaToGroup(groupId: string, replica: ReadReplica): void {
+    const group = this.replicationGroups.get(groupId)
+
+    if (!group) {
+      throw new Error(`Replication group not found: ${groupId}`)
+    }
+
+    group.replicas.push(replica)
+  }
+
+  /**
+   * Create RDS Proxy
+   */
+  createProxy(proxy: Omit<RDSProxy, 'id'>): RDSProxy {
+    const id = `rds-proxy-${Date.now()}-${this.proxyCounter++}`
+
+    const rdsProxy: RDSProxy = {
+      id,
+      ...proxy,
+    }
+
+    this.proxies.set(id, rdsProxy)
+
+    return rdsProxy
+  }
+
+  /**
+   * Create RDS Proxy for connection pooling
+   */
+  createConnectionPoolProxy(options: {
+    name: string
+    engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER'
+    targetDatabase: string
+    vpcSubnetIds: string[]
+    securityGroupIds: string[]
+    secretArn: string
+    maxConnections?: number
+  }): RDSProxy {
+    return this.createProxy({
+      name: options.name,
+      engineFamily: options.engineFamily,
+      targetDatabase: options.targetDatabase,
+      maxConnectionsPercent: options.maxConnections || 100,
+      maxIdleConnectionsPercent: 50,
+      connectionBorrowTimeout: 120,
+      sessionPinningFilters: ['EXCLUDE_VARIABLE_SETS'],
+      requireTLS: true,
+      idleClientTimeout: 1800,
+      vpcSubnetIds: options.vpcSubnetIds,
+      securityGroupIds: options.securityGroupIds,
+      secretArn: options.secretArn,
+    })
+  }
+
+  /**
+   * Create serverless proxy (optimized for Lambda)
+   */
+  createServerlessProxy(options: {
+    name: string
+    engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER'
+    targetDatabase: string
+    vpcSubnetIds: string[]
+    securityGroupIds: string[]
+    secretArn: string
+  }): RDSProxy {
+    return this.createProxy({
+      name: options.name,
+      engineFamily: options.engineFamily,
+      targetDatabase: options.targetDatabase,
+      maxConnectionsPercent: 100,
+      maxIdleConnectionsPercent: 10, // Low for serverless to reduce idle connections
+      connectionBorrowTimeout: 60, // Lower timeout for serverless
+      sessionPinningFilters: ['EXCLUDE_VARIABLE_SETS'],
+      requireTLS: true,
+      idleClientTimeout: 300, // Shorter timeout for serverless
+      vpcSubnetIds: options.vpcSubnetIds,
+      securityGroupIds: options.securityGroupIds,
+      secretArn: options.secretArn,
+    })
+  }
+
+  /**
+   * Add proxy target
+   */
+  addProxyTarget(target: Omit<ProxyTarget, 'id'>): ProxyTarget {
+    const id = `proxy-target-${Date.now()}-${this.targetCounter++}`
+
+    const proxyTarget: ProxyTarget = {
+      id,
+      ...target,
+    }
+
+    this.proxyTargets.set(id, proxyTarget)
+
+    return proxyTarget
+  }
+
+  /**
+   * Promote replica to primary
+   */
+  promoteReplica(replicaId: string): { success: boolean; message: string } {
+    const replica = this.replicas.get(replicaId)
+
+    if (!replica) {
+      return { success: false, message: 'Replica not found' }
+    }
+
+    console.log(`Promoting replica to primary: ${replica.name}`)
+    console.log(`Region: ${replica.region}`)
+    console.log(`\n1. Checking replication lag...`)
+
+    if (replica.replicationLag && replica.replicationLag > 5000) {
+      return {
+        success: false,
+        message: `Replication lag too high: ${replica.replicationLag}ms`,
+      }
+    }
+
+    console.log(`   Replication lag: ${replica.replicationLag || 0}ms (acceptable)`)
+    console.log(`\n2. Promoting replica to standalone instance...`)
+    console.log(`\n3. Updating DNS records...`)
+    console.log(`\n4. Updating application configuration...`)
+    console.log(`\n✓ Promotion completed successfully`)
+
+    replica.status = 'available'
+
+    return { success: true, message: 'Replica promoted successfully' }
+  }
+
+  /**
+   * Get replication lag for replica
+   */
+  getReplicationLag(replicaId: string): number {
+    const replica = this.replicas.get(replicaId)
+
+    if (!replica) {
+      throw new Error(`Replica not found: ${replicaId}`)
+    }
+
+    // Simulate replication lag (in production, query RDS metrics)
+    return Math.floor(Math.random() * 1000)
+  }
+
+  /**
+   * Get replica
+   */
+  getReplica(id: string): ReadReplica | undefined {
+    return this.replicas.get(id)
+  }
+
+  /**
+   * List replicas
+   */
+  listReplicas(): ReadReplica[] {
+    return Array.from(this.replicas.values())
+  }
+
+  /**
+   * Get replication group
+   */
+  getReplicationGroup(id: string): ReplicationGroup | undefined {
+    return this.replicationGroups.get(id)
+  }
+
+  /**
+   * List replication groups
+   */
+  listReplicationGroups(): ReplicationGroup[] {
+    return Array.from(this.replicationGroups.values())
+  }
+
+  /**
+   * Get proxy
+   */
+  getProxy(id: string): RDSProxy | undefined {
+    return this.proxies.get(id)
+  }
+
+  /**
+   * List proxies
+   */
+  listProxies(): RDSProxy[] {
+    return Array.from(this.proxies.values())
+  }
+
+  /**
+   * Generate CloudFormation for read replica
+   */
+  generateReplicaCF(replica: ReadReplica): any {
+    return {
+      Type: 'AWS::RDS::DBInstance',
+      Properties: {
+        SourceDBInstanceIdentifier: replica.sourceDatabase,
+        DBInstanceIdentifier: replica.name,
+        DBInstanceClass: replica.instanceClass,
+        MultiAZ: replica.multiAZ || false,
+        AutoMinorVersionUpgrade: replica.autoMinorVersionUpgrade ?? true,
+        ...(replica.backupRetentionPeriod && {
+          BackupRetentionPeriod: replica.backupRetentionPeriod,
+        }),
+        ...(replica.preferredBackupWindow && {
+          PreferredBackupWindow: replica.preferredBackupWindow,
+        }),
+        ...(replica.preferredMaintenanceWindow && {
+          PreferredMaintenanceWindow: replica.preferredMaintenanceWindow,
+        }),
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for RDS Proxy
+   */
+  generateProxyCF(proxy: RDSProxy): any {
+    return {
+      Type: 'AWS::RDS::DBProxy',
+      Properties: {
+        DBProxyName: proxy.name,
+        EngineFamily: proxy.engineFamily,
+        Auth: [
+          {
+            AuthScheme: 'SECRETS',
+            SecretArn: proxy.secretArn,
+            IAMAuth: 'DISABLED',
+          },
+        ],
+        RoleArn: { 'Fn::GetAtt': ['RDSProxyRole', 'Arn'] },
+        VpcSubnetIds: proxy.vpcSubnetIds,
+        VpcSecurityGroupIds: proxy.securityGroupIds,
+        RequireTLS: proxy.requireTLS ?? true,
+        IdleClientTimeout: proxy.idleClientTimeout || 1800,
+        ...(proxy.maxConnectionsPercent && {
+          MaxConnectionsPercent: proxy.maxConnectionsPercent,
+        }),
+        ...(proxy.maxIdleConnectionsPercent && {
+          MaxIdleConnectionsPercent: proxy.maxIdleConnectionsPercent,
+        }),
+        ...(proxy.connectionBorrowTimeout && {
+          ConnectionBorrowTimeout: proxy.connectionBorrowTimeout,
+        }),
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for proxy target
+   */
+  generateProxyTargetCF(target: ProxyTarget, proxy: RDSProxy): any {
+    return {
+      Type: 'AWS::RDS::DBProxyTargetGroup',
+      Properties: {
+        DBProxyName: proxy.name,
+        TargetGroupName: 'default',
+        DBInstanceIdentifiers: [target.targetArn],
+        ConnectionPoolConfig: {
+          MaxConnectionsPercent: 100,
+          MaxIdleConnectionsPercent: 50,
+          ConnectionBorrowTimeout: 120,
+        },
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for proxy IAM role
+   */
+  generateProxyRoleCF(): any {
+    return {
+      Type: 'AWS::IAM::Role',
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: '2012-10-17',
+          Statement: [
+            {
+              Effect: 'Allow',
+              Principal: {
+                Service: 'rds.amazonaws.com',
+              },
+              Action: 'sts:AssumeRole',
+            },
+          ],
+        },
+        Policies: [
+          {
+            PolicyName: 'RDSProxySecretsPolicy',
+            PolicyDocument: {
+              Version: '2012-10-17',
+              Statement: [
+                {
+                  Effect: 'Allow',
+                  Action: [
+                    'secretsmanager:GetSecretValue',
+                    'secretsmanager:DescribeSecret',
+                  ],
+                  Resource: 'arn:aws:secretsmanager:*:*:secret:*',
+                },
+                {
+                  Effect: 'Allow',
+                  Action: ['kms:Decrypt'],
+                  Resource: 'arn:aws:kms:*:*:key/*',
+                  Condition: {
+                    StringEquals: {
+                      'kms:ViaService': 'secretsmanager.*.amazonaws.com',
+                    },
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.replicas.clear()
+    this.replicationGroups.clear()
+    this.proxies.clear()
+    this.proxyTargets.clear()
+    this.replicaCounter = 0
+    this.groupCounter = 0
+    this.proxyCounter = 0
+    this.targetCounter = 0
+  }
+}
+
+/**
+ * Global replica manager instance
+ */
+export const replicaManager: ReplicaManager = new ReplicaManager()