@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

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;
+}

package/dist/deployment/canary.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Global canary manager instance
+ */
+export declare const canaryManager: CanaryManager;
+/**
+ * Canary Deployment Strategy
+ * Gradual rollout with automatic rollback based on metrics
+ */
+export declare interface CanaryDeployment {
+  id: string
+  name: string
+  baselineVersion: DeploymentVersion
+  canaryVersion: DeploymentVersion
+  stages: CanaryStage[]
+  currentStage: number
+  status: 'pending' | 'in_progress' | 'completed' | 'rolled_back' | 'failed'
+  metrics?: CanaryMetrics
+  autoPromote?: boolean
+  autoRollback?: boolean
+}
+export declare interface DeploymentVersion {
+  version: string
+  targetGroupArn?: string
+  taskDefinitionArn?: string
+  functionVersionArn?: string
+  weight: number
+}
+export declare interface CanaryStage {
+  name: string
+  trafficPercentage: number
+  durationMinutes: number
+  alarmThresholds?: AlarmThresholds
+}
+export declare interface AlarmThresholds {
+  errorRate?: number
+  latencyP99?: number
+  latencyP95?: number
+  httpErrorRate?: number
+  customMetrics?: CustomMetric[]
+}
+export declare interface CustomMetric {
+  name: string
+  namespace: string
+  threshold: number
+  comparisonOperator: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold'
+}
+export declare interface CanaryMetrics {
+  baselineErrorRate: number
+  canaryErrorRate: number
+  baselineLatencyP99: number
+  canaryLatencyP99: number
+  baselineRequestCount: number
+  canaryRequestCount: number
+}
+export declare interface CanaryResult {
+  success: boolean
+  deploymentId: string
+  startTime: Date
+  endTime?: Date
+  completedStages: number
+  rolledBack: boolean
+  reason?: string
+  metricsAtCompletion?: CanaryMetrics
+}
+/**
+ * Canary deployment manager
+ */
+export declare class CanaryManager {
+  private deployments: Map<string, CanaryDeployment>;
+  private deploymentHistory: Map<string, CanaryResult[]>;
+  private deploymentCounter: any;
+  private resultCounter: any;
+  static readonly Strategies: any;
+  createDeployment(deployment: Omit<CanaryDeployment, 'id'>): CanaryDeployment;
+  createLambdaCanaryDeployment(options: {
+    name: string
+    baselineVersionArn: string
+    canaryVersionArn: string
+    strategy?: keyof typeof CanaryManager.Strategies
+    autoPromote?: boolean
+    errorRateThreshold?: number
+    latencyThreshold?: number
+  }): CanaryDeployment;
+  createECSCanaryDeployment(options: {
+    name: string
+    baselineTaskDefinitionArn: string
+    canaryTaskDefinitionArn: string
+    baselineTargetGroupArn: string
+    canaryTargetGroupArn: string
+    strategy?: keyof typeof CanaryManager.Strategies
+  }): CanaryDeployment;
+  executeDeployment(deploymentId: string, dryRun?: boolean): Promise<CanaryResult>;
+  private monitorStage(deployment: CanaryDeployment, stage: CanaryStage, dryRun: boolean): Promise<boolean>;
+  rollback(deploymentId: string, dryRun?: boolean): Promise<void>;
+  promoteCanary(deploymentId: string): void;
+  private recordDeployment(deploymentId: string, result: CanaryResult): void;
+  getDeployment(id: string): CanaryDeployment | undefined;
+  listDeployments(): CanaryDeployment[];
+  getDeploymentHistory(deploymentId: string): CanaryResult[];
+  generateLambdaAliasCF(deployment: CanaryDeployment, aliasName: string): any;
+  generateALBListenerRuleCF(deployment: CanaryDeployment): any;
+  clear(): void;
+}

package/dist/deployment/index.d.ts

@@ -0,0 +1,45 @@
+export type {
+  BlueGreenDeployment,
+  Environment,
+  RoutingConfig,
+  HealthCheckConfig,
+  DeploymentResult,
+} from './blue-green';
+export type {
+  CanaryDeployment,
+  DeploymentVersion,
+  CanaryStage,
+  AlarmThresholds,
+  CustomMetric,
+  CanaryMetrics,
+  CanaryResult,
+} from './canary';
+export type {
+  ABTest,
+  ABVariant,
+  RoutingStrategy,
+  ABMetrics,
+  VariantMetrics,
+  ABTestResult,
+} from './ab-testing';
+export type {
+  ProgressiveRollout,
+  FeatureFlag,
+  DeploymentGate,
+} from './progressive';
+export {
+  BlueGreenManager,
+  blueGreenManager,
+} from './blue-green';
+export {
+  CanaryManager,
+  canaryManager,
+} from './canary';
+export {
+  ABTestManager,
+  abTestManager,
+} from './ab-testing';
+export {
+  ProgressiveDeploymentManager,
+  progressiveDeploymentManager,
+} from './progressive';

package/dist/deployment/progressive.d.ts

@@ -0,0 +1,34 @@
+export declare const progressiveDeploymentManager: ProgressiveDeploymentManager;
+/**
+ * Progressive Rollouts, Feature Flags, and Deployment Gates
+ */
+export declare interface ProgressiveRollout {
+  id: string
+  name: string
+  stages: Array<{ percentage: number; durationMinutes: number }>
+  currentStage: number
+}
+export declare interface FeatureFlag {
+  id: string
+  name: string
+  enabled: boolean
+  rolloutPercentage: number
+  targetingRules: Array<{ attribute: string; operator: string; value: any }>
+}
+export declare interface DeploymentGate {
+  id: string
+  name: string
+  type: 'manual' | 'automated'
+  approvers?: string[]
+  conditions?: Array<{ metric: string; threshold: number }>
+}
+export declare class ProgressiveDeploymentManager {
+  private rollouts: any;
+  private flags: any;
+  private gates: any;
+  private counter: any;
+  createProgressiveRollout(name: string, stages: Array<{ percentage: number; durationMinutes: number }>): ProgressiveRollout;
+  createFeatureFlag(name: string, rolloutPercentage?: any): FeatureFlag;
+  createDeploymentGate(name: string, type: 'manual' | 'automated', approvers?: string[], conditions?: Array<{ metric: string; threshold: number }>): DeploymentGate;
+  clear(): void;
+}