@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/containers/build-optimization.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Global build optimization manager instance
+ */
+export declare const buildOptimizationManager: BuildOptimizationManager;
+/**
+ * Container Build Optimization
+ * Multi-stage builds, layer caching, and build performance
+ */
+export declare interface BuildConfig {
+  id: string
+  name: string
+  dockerfile: string
+  context: string
+  target?: string
+  buildArgs?: Record<string, string>
+  labels?: Record<string, string>
+  cacheStrategy: CacheStrategy
+  platform?: string
+}
+export declare interface CacheStrategy {
+  type: 'inline' | 'registry' | 'local' | 's3'
+  cacheFrom?: string[]
+  cacheTo?: string
+  maxCacheAge?: number
+}
+export declare interface MultiStageConfig {
+  id: string
+  name: string
+  stages: BuildStage[]
+  targetStage?: string
+}
+export declare interface BuildStage {
+  name: string
+  baseImage: string
+  commands: string[]
+  copyFrom?: string[]
+  workdir?: string
+  env?: Record<string, string>
+}
+export declare interface BuildOptimization {
+  id: string
+  name: string
+  recommendations: OptimizationRecommendation[]
+  estimatedSavings: BuildSavings
+}
+export declare interface OptimizationRecommendation {
+  type: 'layer_reduction' | 'cache_optimization' | 'base_image' | 'dependencies'
+  priority: 'high' | 'medium' | 'low'
+  title: string
+  description: string
+  example?: string
+  impact: string
+}
+export declare interface BuildSavings {
+  sizeBefore: number
+  sizeAfter: number
+  timeBefore: number
+  timeAfter: number
+}
+export declare interface LayerAnalysis {
+  id: string
+  imageId: string
+  layers: ImageLayer[]
+  totalSize: number
+  unnecessaryLayers: number
+}
+export declare interface ImageLayer {
+  index: number
+  command: string
+  size: number
+  created: Date
+  cacheable: boolean
+}
+/**
+ * Build optimization manager
+ */
+export declare class BuildOptimizationManager {
+  private configs: Map<string, BuildConfig>;
+  private multiStageConfigs: Map<string, MultiStageConfig>;
+  private optimizations: Map<string, BuildOptimization>;
+  private analyses: Map<string, LayerAnalysis>;
+  private configCounter: any;
+  private multiStageCounter: any;
+  private optimizationCounter: any;
+  private analysisCounter: any;
+  createBuildConfig(config: Omit<BuildConfig, 'id'>): BuildConfig;
+  createOptimizedBuildConfig(options: {
+    name: string
+    dockerfile: string
+    enableCache?: boolean
+    registry?: string
+  }): BuildConfig;
+  createMultiStageConfig(config: Omit<MultiStageConfig, 'id'>): MultiStageConfig;
+  createNodeMultiStageBuild(options: {
+    name: string
+    nodeVersion?: string
+    targetStage?: 'production' | 'development'
+  }): MultiStageConfig;
+  generateDockerfile(configId: string): string;
+  analyzeImage(imageId: string, layers: Omit<ImageLayer, 'cacheable'>[]): LayerAnalysis;
+  private isLayerCacheable(command: string): boolean;
+  generateOptimizations(analysisId: string): BuildOptimization;
+  getBuildConfig(id: string): BuildConfig | undefined;
+  listBuildConfigs(): BuildConfig[];
+  getMultiStageConfig(id: string): MultiStageConfig | undefined;
+  listMultiStageConfigs(): MultiStageConfig[];
+  getOptimization(id: string): BuildOptimization | undefined;
+  listOptimizations(): BuildOptimization[];
+  clear(): void;
+}

package/dist/containers/image-scanning.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Global image scanning manager instance
+ */
+export declare const imageScanningManager: ImageScanningManager;
+/**
+ * Container Image Scanning
+ * Vulnerability scanning with Trivy, Snyk, and other tools
+ */
+export declare interface ImageScanConfig {
+  id: string
+  repository: string
+  imageTag: string
+  scanner: ScannerType
+  scanOnPush: boolean
+  scanSchedule?: string
+  failOnSeverity?: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW'
+  ignoreUnfixed?: boolean
+}
+export declare interface ImageScanResult {
+  id: string
+  imageUri: string
+  scannerType: ScannerType
+  scanDate: Date
+  vulnerabilities: ImageVulnerability[]
+  summary: VulnerabilitySummary
+  passed: boolean
+}
+export declare interface ImageVulnerability {
+  id: string
+  cve: string
+  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'UNKNOWN'
+  packageName: string
+  installedVersion: string
+  fixedVersion?: string
+  title: string
+  description: string
+  references: string[]
+  cvss?: number
+}
+export declare interface VulnerabilitySummary {
+  total: number
+  critical: number
+  high: number
+  medium: number
+  low: number
+  unknown: number
+}
+export declare interface ScanPolicy {
+  id: string
+  name: string
+  allowedSeverities: string[]
+  maxCritical: number
+  maxHigh: number
+  blockOnFailure: boolean
+  exemptions: string[]
+}
+export type ScannerType = 'trivy' | 'snyk' | 'clair' | 'anchore' | 'ecr'
+/**
+ * Image scanning manager
+ */
+export declare class ImageScanningManager {
+  private configs: Map<string, ImageScanConfig>;
+  private results: Map<string, ImageScanResult>;
+  private policies: Map<string, ScanPolicy>;
+  private configCounter: any;
+  private resultCounter: any;
+  private policyCounter: any;
+  configureScan(config: Omit<ImageScanConfig, 'id'>): ImageScanConfig;
+  configureTrivyScan(options: {
+    repository: string
+    imageTag: string
+    scanOnPush?: boolean
+    ignoreUnfixed?: boolean
+  }): ImageScanConfig;
+  configureSnykScan(options: {
+    repository: string
+    imageTag: string
+    scanOnPush?: boolean
+  }): ImageScanConfig;
+  configureECRScan(options: {
+    repository: string
+    scanOnPush?: boolean
+  }): ImageScanConfig;
+  scanImage(configId: string): Promise<ImageScanResult>;
+  private simulateVulnerabilities(config: ImageScanConfig): ImageVulnerability[];
+  private evaluateScanResult(config: ImageScanConfig, summary: VulnerabilitySummary): boolean;
+  createPolicy(policy: Omit<ScanPolicy, 'id'>): ScanPolicy;
+  createStrictPolicy(name: string): ScanPolicy;
+  createPermissivePolicy(name: string): ScanPolicy;
+  getConfig(id: string): ImageScanConfig | undefined;
+  listConfigs(): ImageScanConfig[];
+  getResult(id: string): ImageScanResult | undefined;
+  listResults(): ImageScanResult[];
+  generateECRScanCF(config: ImageScanConfig): any;
+  clear(): void;
+}

package/dist/containers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './image-scanning';
+export * from './build-optimization';
+export * from './registry';
+export * from './service-mesh';

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