@ts-cloud/core 0.2.2 → 0.2.4

package/dist/database/migrations.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Database Migration Management
+ * Version-controlled schema changes with rollback support
+ */
+export interface Migration {
+    id: string;
+    version: string;
+    name: string;
+    description?: string;
+    up: string;
+    down: string;
+    checksum: string;
+    appliedAt?: Date;
+    rolledBackAt?: Date;
+    executionTimeMs?: number;
+}
+export interface MigrationPlan {
+    id: string;
+    name: string;
+    database: DatabaseTarget;
+    migrations: Migration[];
+    autoApply?: boolean;
+    backupBeforeMigration?: boolean;
+    testMigrations?: boolean;
+    validateRollback?: boolean;
+}
+export interface DatabaseTarget {
+    type: 'rds' | 'aurora' | 'dynamodb';
+    identifier: string;
+    engine?: 'postgres' | 'mysql' | 'mariadb';
+    endpoint?: string;
+    database?: string;
+}
+export interface MigrationResult {
+    success: boolean;
+    version: string;
+    appliedMigrations: string[];
+    failedMigrations: string[];
+    executionTimeMs: number;
+    error?: string;
+    rollbackPerformed?: boolean;
+}
+export interface MigrationStatus {
+    currentVersion: string;
+    pendingMigrations: Migration[];
+    appliedMigrations: Migration[];
+    lastMigration?: Migration;
+}
+/**
+ * Migration manager
+ */
+export declare class MigrationManager {
+    private plans;
+    private migrations;
+    private planCounter;
+    private migrationCounter;
+    /**
+     * Create migration plan
+     */
+    createPlan(plan: Omit<MigrationPlan, 'id'>): MigrationPlan;
+    /**
+     * Create migration
+     */
+    createMigration(migration: Omit<Migration, 'id' | 'checksum'>): Migration;
+    /**
+     * Create schema change migration
+     */
+    createSchemaMigration(options: {
+        version: string;
+        name: string;
+        tableName: string;
+        changes: SchemaChange[];
+        engine?: 'postgres' | 'mysql';
+    }): Migration;
+    /**
+     * Create data migration
+     */
+    createDataMigration(options: {
+        version: string;
+        name: string;
+        description?: string;
+        upSQL: string;
+        downSQL: string;
+    }): Migration;
+    /**
+     * Add migration to plan
+     */
+    addMigrationToPlan(planId: string, migration: Migration): void;
+    /**
+     * Execute migration plan
+     */
+    executePlan(planId: string, dryRun?: boolean): Promise<MigrationResult>;
+    /**
+     * Rollback migrations
+     */
+    private rollbackMigrations;
+    /**
+     * Get migration status
+     */
+    getMigrationStatus(planId: string): MigrationStatus;
+    /**
+     * Generate schema SQL from changes
+     */
+    private generateSchemaSQL;
+    /**
+     * Generate checksum for migration
+     */
+    private generateChecksum;
+    /**
+     * Validate migration plan
+     */
+    validatePlan(planId: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get plan
+     */
+    getPlan(id: string): MigrationPlan | undefined;
+    /**
+     * List plans
+     */
+    listPlans(): MigrationPlan[];
+    /**
+     * Get migration
+     */
+    getMigration(id: string): Migration | undefined;
+    /**
+     * List migrations
+     */
+    listMigrations(): Migration[];
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Schema change types
+ */
+export interface SchemaChange {
+    type: 'add_column' | 'drop_column' | 'modify_column' | 'add_index' | 'drop_index';
+    columnName?: string;
+    columnType?: string;
+    newType?: string;
+    nullable?: boolean;
+    defaultValue?: string;
+    indexName?: string;
+    columns?: string[];
+}
+/**
+ * Global migration manager instance
+ */
+export declare const migrationManager: MigrationManager;

package/dist/database/performance.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Database Performance Monitoring
+ * Query performance insights, slow query detection, and optimization
+ */
+export interface PerformanceInsights {
+    id: string;
+    name: string;
+    databaseIdentifier: string;
+    enabled: boolean;
+    retentionPeriod: number;
+    kmsKeyId?: string;
+}
+export interface SlowQueryLog {
+    id: string;
+    name: string;
+    databaseIdentifier: string;
+    enabled: boolean;
+    logDestination: 'cloudwatch' | 's3';
+    cloudwatchLogGroup?: string;
+    s3Bucket?: string;
+    s3Prefix?: string;
+    minExecutionTime?: number;
+}
+export interface QueryMetric {
+    id: string;
+    queryId: string;
+    sql: string;
+    executionCount: number;
+    avgExecutionTime: number;
+    maxExecutionTime: number;
+    minExecutionTime: number;
+    totalCPUTime: number;
+    totalIOWait: number;
+    totalLockWait: number;
+    rowsExamined: number;
+    rowsReturned: number;
+    timestamp: Date;
+}
+export interface PerformanceReport {
+    id: string;
+    name: string;
+    databaseIdentifier: string;
+    reportType: 'daily' | 'weekly' | 'monthly';
+    metrics: PerformanceMetrics;
+    topQueries: QueryMetric[];
+    slowQueries: QueryMetric[];
+    recommendations: PerformanceRecommendation[];
+    generatedAt: Date;
+}
+export interface PerformanceMetrics {
+    avgCPU: number;
+    maxCPU: number;
+    avgConnections: number;
+    maxConnections: number;
+    avgReadIOPS: number;
+    avgWriteIOPS: number;
+    avgReadThroughput: number;
+    avgWriteThroughput: number;
+    avgReadLatency: number;
+    avgWriteLatency: number;
+    cacheHitRatio: number;
+    deadlocks: number;
+    longRunningTransactions: number;
+}
+export interface PerformanceRecommendation {
+    type: 'index' | 'query' | 'schema' | 'configuration' | 'scaling';
+    severity: 'high' | 'medium' | 'low';
+    title: string;
+    description: string;
+    impact: string;
+    effort: 'low' | 'medium' | 'high';
+    sqlExample?: string;
+}
+export interface IndexRecommendation {
+    id: string;
+    tableName: string;
+    columns: string[];
+    reason: string;
+    estimatedImprovement: number;
+    estimatedSize: number;
+    createSQL: string;
+}
+export interface QueryAnalysis {
+    id: string;
+    queryId: string;
+    sql: string;
+    executionPlan: ExecutionPlanNode[];
+    bottlenecks: Bottleneck[];
+    recommendations: string[];
+    estimatedCost: number;
+}
+export interface ExecutionPlanNode {
+    id: number;
+    operation: string;
+    table?: string;
+    rows: number;
+    cost: number;
+    children?: ExecutionPlanNode[];
+}
+export interface Bottleneck {
+    type: 'full_table_scan' | 'missing_index' | 'suboptimal_join' | 'high_cardinality';
+    severity: 'critical' | 'warning' | 'info';
+    description: string;
+    tableName?: string;
+    columnName?: string;
+}
+/**
+ * Performance manager
+ */
+export declare class PerformanceManager {
+    private insights;
+    private slowQueryLogs;
+    private queryMetrics;
+    private reports;
+    private indexRecommendations;
+    private insightsCounter;
+    private logCounter;
+    private metricCounter;
+    private reportCounter;
+    private recommendationCounter;
+    /**
+     * Enable performance insights
+     */
+    enablePerformanceInsights(options: {
+        name: string;
+        databaseIdentifier: string;
+        retentionPeriod?: number;
+        kmsKeyId?: string;
+    }): PerformanceInsights;
+    /**
+     * Enable slow query log
+     */
+    enableSlowQueryLog(options: {
+        name: string;
+        databaseIdentifier: string;
+        logDestination: 'cloudwatch' | 's3';
+        cloudwatchLogGroup?: string;
+        s3Bucket?: string;
+        minExecutionTime?: number;
+    }): SlowQueryLog;
+    /**
+     * Record query metric
+     */
+    recordQueryMetric(metric: Omit<QueryMetric, 'id' | 'timestamp'>): QueryMetric;
+    /**
+     * Generate performance report
+     */
+    generatePerformanceReport(options: {
+        name: string;
+        databaseIdentifier: string;
+        reportType: 'daily' | 'weekly' | 'monthly';
+    }): PerformanceReport;
+    /**
+     * Generate recommendations based on metrics
+     */
+    private generateRecommendations;
+    /**
+     * Analyze query
+     */
+    analyzeQuery(sql: string): QueryAnalysis;
+    /**
+     * Recommend index
+     */
+    recommendIndex(options: {
+        tableName: string;
+        columns: string[];
+        reason: string;
+        estimatedImprovement?: number;
+    }): IndexRecommendation;
+    /**
+     * Get performance insights
+     */
+    getInsights(id: string): PerformanceInsights | undefined;
+    /**
+     * List performance insights
+     */
+    listInsights(): PerformanceInsights[];
+    /**
+     * Get slow query log
+     */
+    getSlowQueryLog(id: string): SlowQueryLog | undefined;
+    /**
+     * List slow query logs
+     */
+    listSlowQueryLogs(): SlowQueryLog[];
+    /**
+     * Get report
+     */
+    getReport(id: string): PerformanceReport | undefined;
+    /**
+     * List reports
+     */
+    listReports(): PerformanceReport[];
+    /**
+     * List index recommendations
+     */
+    listIndexRecommendations(): IndexRecommendation[];
+    /**
+     * Generate CloudFormation for Performance Insights
+     */
+    generatePerformanceInsightsCF(insights: PerformanceInsights): any;
+    /**
+     * Generate CloudWatch alarm for slow queries
+     */
+    generateSlowQueryAlarmCF(options: {
+        alarmName: string;
+        logGroupName: string;
+        threshold: number;
+        snsTopicArn?: string;
+    }): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global performance manager instance
+ */
+export declare const performanceManager: PerformanceManager;

package/dist/database/replicas.d.ts

@@ -0,0 +1,218 @@
+/**
+ * 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;
+    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>;
+}
+export interface AutoScalingConfig {
+    enabled: boolean;
+    minReplicas: number;
+    maxReplicas: number;
+    targetCPU?: number;
+    targetConnections?: number;
+    scaleUpCooldown?: number;
+    scaleDownCooldown?: number;
+}
+export interface RDSProxy {
+    id: string;
+    name: string;
+    engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER';
+    targetDatabase: string;
+    maxConnectionsPercent?: number;
+    maxIdleConnectionsPercent?: number;
+    connectionBorrowTimeout?: number;
+    sessionPinningFilters?: SessionPinningFilter[];
+    requireTLS?: boolean;
+    idleClientTimeout?: number;
+    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;
+    idleTimeout: number;
+    maxLifetime?: number;
+    statementTimeout?: number;
+}
+/**
+ * Replica manager
+ */
+export declare class ReplicaManager {
+    private replicas;
+    private replicationGroups;
+    private proxies;
+    private proxyTargets;
+    private replicaCounter;
+    private groupCounter;
+    private proxyCounter;
+    private targetCounter;
+    /**
+     * Create read replica
+     */
+    createReplica(replica: Omit<ReadReplica, 'id'>): ReadReplica;
+    /**
+     * Create read replica for RDS instance
+     */
+    createRDSReplica(options: {
+        sourceDatabase: string;
+        name: string;
+        region?: string;
+        instanceClass?: string;
+        multiAZ?: boolean;
+    }): ReadReplica;
+    /**
+     * Create cross-region replica
+     */
+    createCrossRegionReplica(options: {
+        sourceDatabase: string;
+        name: string;
+        targetRegion: string;
+        instanceClass?: string;
+        encrypted?: boolean;
+    }): ReadReplica;
+    /**
+     * Create replication group
+     */
+    createReplicationGroup(group: Omit<ReplicationGroup, 'id'>): ReplicationGroup;
+    /**
+     * Create replication group with auto-scaling
+     */
+    createAutoScalingReplicationGroup(options: {
+        name: string;
+        primaryDatabase: string;
+        minReplicas: number;
+        maxReplicas: number;
+        targetCPU?: number;
+        loadBalancing?: LoadBalancingStrategy;
+    }): ReplicationGroup;
+    /**
+     * Add replica to group
+     */
+    addReplicaToGroup(groupId: string, replica: ReadReplica): void;
+    /**
+     * Create RDS Proxy
+     */
+    createProxy(proxy: Omit<RDSProxy, 'id'>): 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;
+    /**
+     * Create serverless proxy (optimized for Lambda)
+     */
+    createServerlessProxy(options: {
+        name: string;
+        engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER';
+        targetDatabase: string;
+        vpcSubnetIds: string[];
+        securityGroupIds: string[];
+        secretArn: string;
+    }): RDSProxy;
+    /**
+     * Add proxy target
+     */
+    addProxyTarget(target: Omit<ProxyTarget, 'id'>): ProxyTarget;
+    /**
+     * Promote replica to primary
+     */
+    promoteReplica(replicaId: string): {
+        success: boolean;
+        message: string;
+    };
+    /**
+     * Get replication lag for replica
+     */
+    getReplicationLag(replicaId: string): number;
+    /**
+     * Get replica
+     */
+    getReplica(id: string): ReadReplica | undefined;
+    /**
+     * List replicas
+     */
+    listReplicas(): ReadReplica[];
+    /**
+     * Get replication group
+     */
+    getReplicationGroup(id: string): ReplicationGroup | undefined;
+    /**
+     * List replication groups
+     */
+    listReplicationGroups(): ReplicationGroup[];
+    /**
+     * Get proxy
+     */
+    getProxy(id: string): RDSProxy | undefined;
+    /**
+     * List proxies
+     */
+    listProxies(): RDSProxy[];
+    /**
+     * Generate CloudFormation for read replica
+     */
+    generateReplicaCF(replica: ReadReplica): any;
+    /**
+     * Generate CloudFormation for RDS Proxy
+     */
+    generateProxyCF(proxy: RDSProxy): any;
+    /**
+     * Generate CloudFormation for proxy target
+     */
+    generateProxyTargetCF(target: ProxyTarget, proxy: RDSProxy): any;
+    /**
+     * Generate CloudFormation for proxy IAM role
+     */
+    generateProxyRoleCF(): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global replica manager instance
+ */
+export declare const replicaManager: ReplicaManager;