@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/database/performance.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Global performance manager instance
+ */
+export declare const performanceManager: PerformanceManager;
+/**
+ * Database Performance Monitoring
+ * Query performance insights, slow query detection, and optimization
+ */
+export declare interface PerformanceInsights {
+  id: string
+  name: string
+  databaseIdentifier: string
+  enabled: boolean
+  retentionPeriod: number
+  kmsKeyId?: string
+}
+export declare interface SlowQueryLog {
+  id: string
+  name: string
+  databaseIdentifier: string
+  enabled: boolean
+  logDestination: 'cloudwatch' | 's3'
+  cloudwatchLogGroup?: string
+  s3Bucket?: string
+  s3Prefix?: string
+  minExecutionTime?: number
+}
+export declare 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 declare interface PerformanceReport {
+  id: string
+  name: string
+  databaseIdentifier: string
+  reportType: 'daily' | 'weekly' | 'monthly'
+  metrics: PerformanceMetrics
+  topQueries: QueryMetric[]
+  slowQueries: QueryMetric[]
+  recommendations: PerformanceRecommendation[]
+  generatedAt: Date
+}
+export declare 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 declare 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 declare interface IndexRecommendation {
+  id: string
+  tableName: string
+  columns: string[]
+  reason: string
+  estimatedImprovement: number
+  estimatedSize: number
+  createSQL: string
+}
+export declare interface QueryAnalysis {
+  id: string
+  queryId: string
+  sql: string
+  executionPlan: ExecutionPlanNode[]
+  bottlenecks: Bottleneck[]
+  recommendations: string[]
+  estimatedCost: number
+}
+export declare interface ExecutionPlanNode {
+  id: number
+  operation: string
+  table?: string
+  rows: number
+  cost: number
+  children?: ExecutionPlanNode[]
+}
+export declare 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: Map<string, PerformanceInsights>;
+  private slowQueryLogs: Map<string, SlowQueryLog>;
+  private queryMetrics: Map<string, QueryMetric>;
+  private reports: Map<string, PerformanceReport>;
+  private indexRecommendations: Map<string, IndexRecommendation>;
+  private insightsCounter: any;
+  private logCounter: any;
+  private metricCounter: any;
+  private reportCounter: any;
+  private recommendationCounter: any;
+  enablePerformanceInsights(options: {
+    name: string
+    databaseIdentifier: string
+    retentionPeriod?: number
+    kmsKeyId?: string
+  }): PerformanceInsights;
+  enableSlowQueryLog(options: {
+    name: string
+    databaseIdentifier: string
+    logDestination: 'cloudwatch' | 's3'
+    cloudwatchLogGroup?: string
+    s3Bucket?: string
+    minExecutionTime?: number
+  }): SlowQueryLog;
+  recordQueryMetric(metric: Omit<QueryMetric, 'id' | 'timestamp'>): QueryMetric;
+  generatePerformanceReport(options: {
+    name: string
+    databaseIdentifier: string
+    reportType: 'daily' | 'weekly' | 'monthly'
+  }): PerformanceReport;
+  private generateRecommendations(metrics: PerformanceMetrics, slowQueries: QueryMetric[]): PerformanceRecommendation[];
+  analyzeQuery(sql: string): QueryAnalysis;
+  recommendIndex(options: {
+    tableName: string
+    columns: string[]
+    reason: string
+    estimatedImprovement?: number
+  }): IndexRecommendation;
+  getInsights(id: string): PerformanceInsights | undefined;
+  listInsights(): PerformanceInsights[];
+  getSlowQueryLog(id: string): SlowQueryLog | undefined;
+  listSlowQueryLogs(): SlowQueryLog[];
+  getReport(id: string): PerformanceReport | undefined;
+  listReports(): PerformanceReport[];
+  listIndexRecommendations(): IndexRecommendation[];
+  generatePerformanceInsightsCF(insights: PerformanceInsights): any;
+  generateSlowQueryAlarmCF(options: {
+    alarmName: string
+    logGroupName: string
+    threshold: number
+    snsTopicArn?: string
+  }): any;
+  clear(): void;
+}

package/dist/database/replicas.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Global replica manager instance
+ */
+export declare const replicaManager: ReplicaManager;
+/**
+ * Database Replicas & Connection Pooling
+ * Read replica management and RDS Proxy for connection pooling
+ */
+export declare 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 declare interface ReplicationGroup {
+  id: string
+  name: string
+  primaryDatabase: string
+  replicas: ReadReplica[]
+  loadBalancing?: LoadBalancingStrategy
+  failoverEnabled?: boolean
+  autoScaling?: AutoScalingConfig
+}
+export declare interface LoadBalancingStrategy {
+  type: 'round-robin' | 'least-connections' | 'weighted' | 'latency-based'
+  weights?: Record<string, number>
+}
+export declare interface AutoScalingConfig {
+  enabled: boolean
+  minReplicas: number
+  maxReplicas: number
+  targetCPU?: number
+  targetConnections?: number
+  scaleUpCooldown?: number
+  scaleDownCooldown?: number
+}
+export declare 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 declare interface ProxyTarget {
+  id: string
+  proxyId: string
+  targetArn: string
+  targetType: 'RDS_INSTANCE' | 'RDS_CLUSTER' | 'TRACKED_CLUSTER'
+  isWritable: boolean
+  weight?: number
+}
+export declare interface ConnectionPoolConfig {
+  minPoolSize: number
+  maxPoolSize: number
+  connectionTimeout: number
+  idleTimeout: number
+  maxLifetime?: number
+  statementTimeout?: number
+}
+export type SessionPinningFilter = | 'EXCLUDE_VARIABLE_SETS'
+/**
+ * Replica manager
+ */
+export declare class ReplicaManager {
+  private replicas: Map<string, ReadReplica>;
+  private replicationGroups: Map<string, ReplicationGroup>;
+  private proxies: Map<string, RDSProxy>;
+  private proxyTargets: Map<string, ProxyTarget>;
+  private replicaCounter: any;
+  private groupCounter: any;
+  private proxyCounter: any;
+  private targetCounter: any;
+  createReplica(replica: Omit<ReadReplica, 'id'>): ReadReplica;
+  createRDSReplica(options: {
+    sourceDatabase: string
+    name: string
+    region?: string
+    instanceClass?: string
+    multiAZ?: boolean
+  }): ReadReplica;
+  createCrossRegionReplica(options: {
+    sourceDatabase: string
+    name: string
+    targetRegion: string
+    instanceClass?: string
+    encrypted?: boolean
+  }): ReadReplica;
+  createReplicationGroup(group: Omit<ReplicationGroup, 'id'>): ReplicationGroup;
+  createAutoScalingReplicationGroup(options: {
+    name: string
+    primaryDatabase: string
+    minReplicas: number
+    maxReplicas: number
+    targetCPU?: number
+    loadBalancing?: LoadBalancingStrategy
+  }): ReplicationGroup;
+  addReplicaToGroup(groupId: string, replica: ReadReplica): void;
+  createProxy(proxy: Omit<RDSProxy, 'id'>): RDSProxy;
+  createConnectionPoolProxy(options: {
+    name: string
+    engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER'
+    targetDatabase: string
+    vpcSubnetIds: string[]
+    securityGroupIds: string[]
+    secretArn: string
+    maxConnections?: number
+  }): RDSProxy;
+  createServerlessProxy(options: {
+    name: string
+    engineFamily: 'MYSQL' | 'POSTGRESQL' | 'SQLSERVER'
+    targetDatabase: string
+    vpcSubnetIds: string[]
+    securityGroupIds: string[]
+    secretArn: string
+  }): RDSProxy;
+  addProxyTarget(target: Omit<ProxyTarget, 'id'>): ProxyTarget;
+  promoteReplica(replicaId: string): { success: boolean; message: string };
+  getReplicationLag(replicaId: string): number;
+  getReplica(id: string): ReadReplica | undefined;
+  listReplicas(): ReadReplica[];
+  getReplicationGroup(id: string): ReplicationGroup | undefined;
+  listReplicationGroups(): ReplicationGroup[];
+  getProxy(id: string): RDSProxy | undefined;
+  listProxies(): RDSProxy[];
+  generateReplicaCF(replica: ReadReplica): any;
+  generateProxyCF(proxy: RDSProxy): any;
+  generateProxyTargetCF(target: ProxyTarget, proxy: RDSProxy): any;
+  generateProxyRoleCF(): any;
+  clear(): void;
+}

package/dist/database/users.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Global database user manager instance
+ */
+export declare const databaseUserManager: DatabaseUserManager;
+/**
+ * Database User Management
+ * User creation, permissions, and access control
+ */
+export declare interface DatabaseUser {
+  id: string
+  username: string
+  database: string
+  privileges: DatabasePrivilege[]
+  passwordSecretArn?: string
+  createdAt: Date
+  lastRotated?: Date
+  rotationEnabled?: boolean
+  rotationDays?: number
+}
+export declare interface DatabasePrivilege {
+  database?: string
+  table?: string
+  privileges: PrivilegeType[]
+}
+export declare interface UserRole {
+  id: string
+  name: string
+  description?: string
+  privileges: DatabasePrivilege[]
+  users: string[]
+}
+export declare interface AccessAudit {
+  id: string
+  username: string
+  action: 'LOGIN' | 'QUERY' | 'MODIFY' | 'GRANT' | 'REVOKE'
+  database?: string
+  table?: string
+  query?: string
+  timestamp: Date
+  success: boolean
+  ipAddress?: string
+}
+export type PrivilegeType = | 'SELECT'
+  | 'INSERT'
+  | 'UPDATE'
+  | 'DELETE'
+  | 'CREATE'
+  | 'DROP'
+  | 'ALTER'
+  | 'INDEX'
+  | 'EXECUTE'
+  | 'ALL'
+/**
+ * Database user manager
+ */
+export declare class DatabaseUserManager {
+  private users: Map<string, DatabaseUser>;
+  private roles: Map<string, UserRole>;
+  private audits: Map<string, AccessAudit>;
+  private userCounter: any;
+  private roleCounter: any;
+  private auditCounter: any;
+  createUser(user: Omit<DatabaseUser, 'id' | 'createdAt'>): DatabaseUser;
+  createReadOnlyUser(options: {
+    username: string
+    database: string
+    passwordSecretArn?: string
+    tables?: string[]
+  }): DatabaseUser;
+  createReadWriteUser(options: {
+    username: string
+    database: string
+    passwordSecretArn?: string
+    tables?: string[]
+  }): DatabaseUser;
+  createAdminUser(options: {
+    username: string
+    database: string
+    passwordSecretArn?: string
+  }): DatabaseUser;
+  createApplicationUser(options: {
+    username: string
+    database: string
+    tables: { name: string; privileges: PrivilegeType[] }[]
+    passwordSecretArn?: string
+  }): DatabaseUser;
+  createRole(role: Omit<UserRole, 'id' | 'users'>): UserRole;
+  assignUserToRole(userId: string, roleId: string): void;
+  grantPrivileges(userId: string, privileges: DatabasePrivilege[]): { success: boolean; message: string };
+  revokePrivileges(userId: string, privileges: DatabasePrivilege[]): { success: boolean; message: string };
+  rotatePassword(userId: string): { success: boolean; newSecretArn?: string };
+  needsPasswordRotation(userId: string): boolean;
+  auditAccess(audit: Omit<AccessAudit, 'id' | 'timestamp'>): AccessAudit;
+  getUserAccessHistory(username: string, limit?: number): AccessAudit[];
+  getFailedLoginAttempts(username: string, hours?: number): AccessAudit[];
+  generateCreateUserSQL(user: DatabaseUser, engine?: 'postgres' | 'mysql'): string;
+  getUser(id: string): DatabaseUser | undefined;
+  listUsers(): DatabaseUser[];
+  getRole(id: string): UserRole | undefined;
+  listRoles(): UserRole[];
+  clear(): void;
+}

package/dist/dependency-graph.d.ts

@@ -0,0 +1,19 @@
+import type { CloudFormationResource } from '@stacksjs/ts-cloud-aws-types';
+export declare interface ResourceNode {
+  logicalId: string
+  resource: CloudFormationResource
+  dependencies: Set<string>
+}
+/**
+ * Dependency Graph for CloudFormation resources
+ * Ensures resources are created in the correct order
+ */
+export declare class DependencyGraph {
+  private nodes: Map<string, ResourceNode>;
+  addResource(logicalId: string, resource: CloudFormationResource): void;
+  private extractDependencies(resource: CloudFormationResource): Set<string>;
+  private findReferences(obj: any, dependencies: Set<string>): void;
+  topologicalSort(): string[];
+  validate(): void;
+  getDependents(logicalId: string): string[];
+}

package/dist/deployment/ab-testing.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Global A/B testing manager instance
+ */
+export declare const abTestManager: ABTestManager;
+/**
+ * A/B Testing Infrastructure
+ * Traffic splitting based on user attributes, headers, or cookies
+ */
+export declare interface ABTest {
+  id: string
+  name: string
+  description?: string
+  variants: ABVariant[]
+  routingStrategy: RoutingStrategy
+  startTime: Date
+  endTime?: Date
+  status: 'draft' | 'active' | 'paused' | 'completed'
+  metrics?: ABMetrics
+  winner?: string
+}
+export declare interface ABVariant {
+  id: string
+  name: string
+  description?: string
+  trafficPercentage: number
+  targetGroupArn?: string
+  functionVersionArn?: string
+  originId?: string
+  weight: number
+}
+export declare interface RoutingStrategy {
+  type: 'random' | 'cookie' | 'header' | 'geo' | 'device' | 'user-attribute'
+  cookieName?: string
+  headerName?: string
+  attributeName?: string
+  stickySession?: boolean
+  sessionDuration?: number
+}
+export declare interface ABMetrics {
+  variants: Record<string, VariantMetrics>
+  totalRequests: number
+  startTime: Date
+  lastUpdated: Date
+}
+export declare interface VariantMetrics {
+  requests: number
+  conversions: number
+  conversionRate: number
+  averageLatency: number
+  errorRate: number
+  revenue?: number
+  customMetrics?: Record<string, number>
+}
+export declare interface ABTestResult {
+  testId: string
+  winningVariant: string
+  confidence: number
+  improvement: number
+  statisticalSignificance: boolean
+  metrics: ABMetrics
+  recommendation: string
+}
+/**
+ * A/B testing manager
+ */
+export declare class ABTestManager {
+  private tests: Map<string, ABTest>;
+  private testCounter: any;
+  createTest(test: Omit<ABTest, 'id'>): ABTest;
+  createSimpleABTest(options: {
+    name: string
+    description?: string
+    controlTargetGroupArn: string
+    variantTargetGroupArn: string
+    variantTrafficPercentage?: number
+    stickySession?: boolean
+  }): ABTest;
+  createMultivariateTest(options: {
+    name: string
+    description?: string
+    variants: Array<{
+      name: string
+      description?: string
+      targetGroupArn: string
+      trafficPercentage: number
+    }>
+    routingStrategy?: RoutingStrategy
+  }): ABTest;
+  createHeaderBasedTest(options: {
+    name: string
+    controlTargetGroupArn: string
+    variantTargetGroupArn: string
+    headerName: string
+    headerValue: string
+  }): ABTest;
+  createGeoBasedTest(options: {
+    name: string
+    controlTargetGroupArn: string
+    variantTargetGroupArn: string
+    regions: string[] // For variant (e.g., ['US', 'CA'])
+  }): ABTest;
+  startTest(testId: string): void;
+  pauseTest(testId: string): void;
+  updateTrafficSplit(testId: string, variantId: string, newPercentage: number): void;
+  analyzeResults(testId: string): ABTestResult;
+  declareWinner(testId: string, variantId: string): void;
+  private collectMetrics(test: ABTest): ABMetrics;
+  private generateRecommendation(improvement: number, significant: boolean, winnerName: string): string;
+  getTest(id: string): ABTest | undefined;
+  listTests(): ABTest[];
+  generateALBListenerRuleCF(test: ABTest): any;
+  generateLambdaEdgeFunction(test: ABTest): string;
+  clear(): void;
+}

package/dist/deployment/blue-green.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Global blue/green manager instance
+ */
+export declare const blueGreenManager: BlueGreenManager;
+/**
+ * Blue/Green Deployment Strategy
+ * Zero-downtime deployments with instant rollback capability
+ */
+export declare interface BlueGreenDeployment {
+  id: string
+  name: string
+  blueEnvironment: Environment
+  greenEnvironment: Environment
+  activeEnvironment: 'blue' | 'green'
+  routingConfig: RoutingConfig
+  autoPromote?: boolean
+  autoRollback?: boolean
+  healthCheckConfig?: HealthCheckConfig
+}
+export declare interface Environment {
+  name: string
+  targetGroupArn: string
+  autoScalingGroupName?: string
+  taskDefinitionArn?: string
+  functionVersionArn?: string
+  instanceIds?: string[]
+  weight?: number
+}
+export declare interface RoutingConfig {
+  type: 'alb' | 'route53' | 'cloudfront' | 'api-gateway'
+  listenerArn?: string
+  hostedZoneId?: string
+  distributionId?: string
+  apiId?: string
+  switchoverTimeSeconds?: number
+}
+export declare interface HealthCheckConfig {
+  healthyThreshold: number
+  unhealthyThreshold: number
+  interval: number
+  timeout: number
+  path?: string
+  port?: number
+}
+export declare interface DeploymentResult {
+  success: boolean
+  deploymentId: string
+  startTime: Date
+  endTime?: Date
+  switchedAt?: Date
+  rolledBackAt?: Date
+  healthChecksPassed: boolean
+  errors?: string[]
+}
+/**
+ * Blue/Green deployment manager
+ */
+export declare class BlueGreenManager {
+  private deployments: Map<string, BlueGreenDeployment>;
+  private deploymentHistory: Map<string, DeploymentResult[]>;
+  private deploymentCounter: any;
+  private resultCounter: any;
+  createDeployment(deployment: Omit<BlueGreenDeployment, 'id'>): BlueGreenDeployment;
+  createALBDeployment(options: {
+    name: string
+    listenerArn: string
+    blueTargetGroupArn: string
+    greenTargetGroupArn: string
+    autoPromote?: boolean
+    healthCheckConfig?: HealthCheckConfig
+  }): BlueGreenDeployment;
+  createRoute53Deployment(options: {
+    name: string
+    hostedZoneId: string
+    blueTargetGroupArn: string
+    greenTargetGroupArn: string
+    switchoverTimeSeconds?: number
+  }): BlueGreenDeployment;
+  createECSDeployment(options: {
+    name: string
+    listenerArn: string
+    blueTargetGroupArn: string
+    greenTargetGroupArn: string
+    blueTaskDefinitionArn: string
+    greenTaskDefinitionArn: string
+    autoRollback?: boolean
+  }): BlueGreenDeployment;
+  executeDeployment(deploymentId: string, dryRun?: boolean): Promise<DeploymentResult>;
+  rollback(deploymentId: string): Promise<DeploymentResult>;
+  private runHealthChecks(deployment: BlueGreenDeployment, environment: 'blue' | 'green', dryRun: boolean): Promise<boolean>;
+  private recordDeployment(deploymentId: string, result: DeploymentResult): void;
+  getDeployment(id: string): BlueGreenDeployment | undefined;
+  listDeployments(): BlueGreenDeployment[];
+  getDeploymentHistory(deploymentId: string): DeploymentResult[];
+  generateALBListenerCF(deployment: BlueGreenDeployment): any;
+  generateRoute53RecordSetCF(deployment: BlueGreenDeployment, recordName: string): any[];
+  clear(): void;
+}