@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/containers/registry.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Global container registry manager instance
+ */
+export declare const containerRegistryManager: ContainerRegistryManager;
+/**
+ * Private Container Registry
+ * ECR repository management and access control
+ */
+export declare interface ContainerRegistry {
+  id: string
+  name: string
+  registryType: 'ecr' | 'dockerhub' | 'gcr' | 'acr'
+  repositoryUri: string
+  region?: string
+  encryption?: RegistryEncryption
+  scanning?: ScanningConfig
+  lifecycle?: LifecyclePolicy
+  replication?: ReplicationConfig
+}
+export declare interface RegistryEncryption {
+  encryptionType: 'AES256' | 'KMS'
+  kmsKeyId?: string
+}
+export declare interface ScanningConfig {
+  scanOnPush: boolean
+  scanFilters?: ScanFilter[]
+}
+export declare interface ScanFilter {
+  tagPattern: string
+  scanFrequency: 'on_push' | 'daily' | 'weekly'
+}
+export declare interface LifecyclePolicy {
+  id: string
+  rules: LifecycleRule[]
+}
+export declare interface LifecycleRule {
+  rulePriority: number
+  description: string
+  selection: {
+    tagStatus: 'tagged' | 'untagged' | 'any'
+    tagPrefixList?: string[]
+    countType: 'imageCountMoreThan' | 'sinceImagePushed'
+    countNumber: number
+    countUnit?: 'days'
+  }
+  action: {
+    type: 'expire'
+  }
+}
+export declare interface ReplicationConfig {
+  enabled: boolean
+  destinations: ReplicationDestination[]
+  rules?: ReplicationRule[]
+}
+export declare interface ReplicationDestination {
+  region: string
+  registryId?: string
+}
+export declare interface ReplicationRule {
+  repositoryFilter: string[]
+  destinations: ReplicationDestination[]
+}
+export declare interface RegistryCredentials {
+  id: string
+  registryId: string
+  username: string
+  passwordSecretArn: string
+  expiresAt?: Date
+}
+/**
+ * Container registry manager
+ */
+export declare class ContainerRegistryManager {
+  private registries: Map<string, ContainerRegistry>;
+  private credentials: Map<string, RegistryCredentials>;
+  private registryCounter: any;
+  private credentialsCounter: any;
+  createRegistry(registry: Omit<ContainerRegistry, 'id'>): ContainerRegistry;
+  createECRRepository(options: {
+    name: string
+    region?: string
+    scanOnPush?: boolean
+    encryption?: 'AES256' | 'KMS'
+    kmsKeyId?: string
+  }): ContainerRegistry;
+  createManagedRepository(options: {
+    name: string
+    region?: string
+    maxImageCount?: number
+    maxImageAgeDays?: number
+  }): ContainerRegistry;
+  enableReplication(registryId: string, destinations: ReplicationDestination[]): ContainerRegistry;
+  createCredentials(credentials: Omit<RegistryCredentials, 'id'>): RegistryCredentials;
+  getRegistry(id: string): ContainerRegistry | undefined;
+  listRegistries(): ContainerRegistry[];
+  generateECRRepositoryCF(registry: ContainerRegistry): any;
+  generateReplicationConfigCF(replication: ReplicationConfig): any;
+  clear(): void;
+}

package/dist/containers/service-mesh.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Global service mesh manager instance
+ */
+export declare const serviceMeshManager: ServiceMeshManager;
+/**
+ * Service Mesh Integration
+ * AWS App Mesh configuration for microservices
+ */
+export declare interface ServiceMesh {
+  id: string
+  name: string
+  meshType: 'app_mesh' | 'istio' | 'linkerd'
+  services: MeshService[]
+  virtualNodes?: VirtualNode[]
+  virtualRouters?: VirtualRouter[]
+  virtualGateways?: VirtualGateway[]
+}
+export declare interface MeshService {
+  id: string
+  name: string
+  namespace: string
+  port: number
+  protocol: 'http' | 'http2' | 'grpc' | 'tcp'
+  backends?: string[]
+  healthCheck?: HealthCheck
+}
+export declare interface VirtualNode {
+  id: string
+  name: string
+  serviceName: string
+  listeners: Listener[]
+  backends?: Backend[]
+  serviceDiscovery: ServiceDiscovery
+}
+export declare interface Listener {
+  port: number
+  protocol: 'http' | 'http2' | 'grpc' | 'tcp'
+  healthCheck?: HealthCheck
+  timeout?: Timeout
+  tls?: TLSConfig
+}
+export declare interface HealthCheck {
+  protocol: 'http' | 'tcp' | 'grpc'
+  path?: string
+  port?: number
+  interval: number
+  timeout: number
+  healthyThreshold: number
+  unhealthyThreshold: number
+}
+export declare interface Timeout {
+  perRequest?: number
+  idle?: number
+}
+export declare interface TLSConfig {
+  mode: 'STRICT' | 'PERMISSIVE' | 'DISABLED'
+  certificate?: {
+    acm?: string
+    file?: {
+      certificateChain: string
+      privateKey: string
+    }
+  }
+  validation?: {
+    trust: {
+      acm?: string[]
+      file?: {
+        certificateChain: string
+      }
+    }
+  }
+}
+export declare interface Backend {
+  virtualServiceName: string
+  clientPolicy?: ClientPolicy
+}
+export declare interface ClientPolicy {
+  tls?: {
+    enforce: boolean
+    ports?: number[]
+    validation: {
+      trust: {
+        acm?: string[]
+      }
+    }
+  }
+}
+export declare interface ServiceDiscovery {
+  type: 'aws_cloud_map' | 'dns'
+  namespace?: string
+  serviceName?: string
+  hostname?: string
+}
+export declare interface VirtualRouter {
+  id: string
+  name: string
+  listeners: RouterListener[]
+  routes: Route[]
+}
+export declare interface RouterListener {
+  port: number
+  protocol: 'http' | 'http2' | 'grpc' | 'tcp'
+}
+export declare interface Route {
+  name: string
+  match: RouteMatch
+  action: RouteAction
+  priority?: number
+  retryPolicy?: RetryPolicy
+}
+export declare interface RouteMatch {
+  prefix?: string
+  path?: string
+  headers?: HeaderMatch[]
+  method?: string
+}
+export declare interface HeaderMatch {
+  name: string
+  match?: {
+    exact?: string
+    prefix?: string
+    suffix?: string
+    regex?: string
+  }
+}
+export declare interface RouteAction {
+  weightedTargets: WeightedTarget[]
+}
+export declare interface WeightedTarget {
+  virtualNode: string
+  weight: number
+  port?: number
+}
+export declare interface RetryPolicy {
+  maxRetries: number
+  perRetryTimeout: number
+  httpRetryEvents?: string[]
+  tcpRetryEvents?: string[]
+}
+export declare interface VirtualGateway {
+  id: string
+  name: string
+  listeners: GatewayListener[]
+  logging?: {
+    accessLog?: {
+      file?: {
+        path: string
+      }
+    }
+  }
+}
+export declare interface GatewayListener {
+  port: number
+  protocol: 'http' | 'http2' | 'grpc'
+  healthCheck?: HealthCheck
+  tls?: TLSConfig
+}
+/**
+ * Service mesh manager
+ */
+export declare class ServiceMeshManager {
+  private meshes: Map<string, ServiceMesh>;
+  private virtualNodes: Map<string, VirtualNode>;
+  private virtualRouters: Map<string, VirtualRouter>;
+  private virtualGateways: Map<string, VirtualGateway>;
+  private meshCounter: any;
+  private nodeCounter: any;
+  private routerCounter: any;
+  private gatewayCounter: any;
+  createMesh(mesh: Omit<ServiceMesh, 'id'>): ServiceMesh;
+  createAppMesh(options: {
+    name: string
+    services: MeshService[]
+  }): ServiceMesh;
+  createVirtualNode(node: Omit<VirtualNode, 'id'>): VirtualNode;
+  createHTTPVirtualNode(options: {
+    name: string
+    serviceName: string
+    port: number
+    namespace: string
+  }): VirtualNode;
+  createVirtualRouter(router: Omit<VirtualRouter, 'id'>): VirtualRouter;
+  createCanaryRoute(options: {
+    name: string
+    port: number
+    protocol: 'http' | 'http2' | 'grpc'
+    stableTarget: string
+    canaryTarget: string
+    canaryWeight: number // 0-100
+  }): VirtualRouter;
+  createVirtualGateway(gateway: Omit<VirtualGateway, 'id'>): VirtualGateway;
+  createIngressGateway(options: {
+    name: string
+    port: number
+    enableTLS?: boolean
+    certificateArn?: string
+  }): VirtualGateway;
+  getMesh(id: string): ServiceMesh | undefined;
+  listMeshes(): ServiceMesh[];
+  getVirtualNode(id: string): VirtualNode | undefined;
+  listVirtualNodes(): VirtualNode[];
+  generateMeshCF(mesh: ServiceMesh): any;
+  generateVirtualNodeCF(node: VirtualNode, meshName: string): any;
+  generateVirtualRouterCF(router: VirtualRouter, meshName: string): any;
+  clear(): void;
+}

package/dist/database/index.d.ts

@@ -0,0 +1,4 @@
+export * from './migrations';
+export * from './replicas';
+export * from './performance';
+export * from './users';

package/dist/database/migrations.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Global migration manager instance
+ */
+export declare const migrationManager: MigrationManager;
+/**
+ * Database Migration Management
+ * Version-controlled schema changes with rollback support
+ */
+export declare interface Migration {
+  id: string
+  version: string
+  name: string
+  description?: string
+  up: string
+  down: string
+  checksum: string
+  appliedAt?: Date
+  rolledBackAt?: Date
+  executionTimeMs?: number
+}
+export declare interface MigrationPlan {
+  id: string
+  name: string
+  database: DatabaseTarget
+  migrations: Migration[]
+  autoApply?: boolean
+  backupBeforeMigration?: boolean
+  testMigrations?: boolean
+  validateRollback?: boolean
+}
+export declare interface DatabaseTarget {
+  type: 'rds' | 'aurora' | 'dynamodb'
+  identifier: string
+  engine?: 'postgres' | 'mysql' | 'mariadb'
+  endpoint?: string
+  database?: string
+}
+export declare interface MigrationResult {
+  success: boolean
+  version: string
+  appliedMigrations: string[]
+  failedMigrations: string[]
+  executionTimeMs: number
+  error?: string
+  rollbackPerformed?: boolean
+}
+export declare interface MigrationStatus {
+  currentVersion: string
+  pendingMigrations: Migration[]
+  appliedMigrations: Migration[]
+  lastMigration?: Migration
+}
+/**
+ * Schema change types
+ */
+export declare 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[]
+}
+/**
+ * Migration manager
+ */
+export declare class MigrationManager {
+  private plans: Map<string, MigrationPlan>;
+  private migrations: Map<string, Migration>;
+  private planCounter: any;
+  private migrationCounter: any;
+  createPlan(plan: Omit<MigrationPlan, 'id'>): MigrationPlan;
+  createMigration(migration: Omit<Migration, 'id' | 'checksum'>): Migration;
+  createSchemaMigration(options: {
+    version: string
+    name: string
+    tableName: string
+    changes: SchemaChange[]
+    engine?: 'postgres' | 'mysql'
+  }): Migration;
+  createDataMigration(options: {
+    version: string
+    name: string
+    description?: string
+    upSQL: string
+    downSQL: string
+  }): Migration;
+  addMigrationToPlan(planId: string, migration: Migration): void;
+  executePlan(planId: string, dryRun?: boolean): Promise<MigrationResult>;
+  private rollbackMigrations(versions: string[], plan: MigrationPlan): Promise<void>;
+  getMigrationStatus(planId: string): MigrationStatus;
+  private generateSchemaSQL(changes: SchemaChange[], tableName: string, engine?: 'postgres' | 'mysql'): { up: string; down: string };
+  private generateChecksum(content: string): string;
+  validatePlan(planId: string): { valid: boolean; errors: string[] };
+  getPlan(id: string): MigrationPlan | undefined;
+  listPlans(): MigrationPlan[];
+  getMigration(id: string): Migration | undefined;
+  listMigrations(): Migration[];
+  clear(): void;
+}

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