@ts-cloud/core 0.2.2 → 0.2.4

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

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

package/dist/containers/containers.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,144 @@
+/**
+ * Container Image Scanning
+ * Vulnerability scanning with Trivy, Snyk, and other tools
+ */
+export interface ImageScanConfig {
+    id: string;
+    repository: string;
+    imageTag: string;
+    scanner: ScannerType;
+    scanOnPush: boolean;
+    scanSchedule?: string;
+    failOnSeverity?: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    ignoreUnfixed?: boolean;
+}
+export type ScannerType = 'trivy' | 'snyk' | 'clair' | 'anchore' | 'ecr';
+export interface ImageScanResult {
+    id: string;
+    imageUri: string;
+    scannerType: ScannerType;
+    scanDate: Date;
+    vulnerabilities: ImageVulnerability[];
+    summary: VulnerabilitySummary;
+    passed: boolean;
+}
+export 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 interface VulnerabilitySummary {
+    total: number;
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+    unknown: number;
+}
+export interface ScanPolicy {
+    id: string;
+    name: string;
+    allowedSeverities: string[];
+    maxCritical: number;
+    maxHigh: number;
+    blockOnFailure: boolean;
+    exemptions: string[];
+}
+/**
+ * Image scanning manager
+ */
+export declare class ImageScanningManager {
+    private configs;
+    private results;
+    private policies;
+    private configCounter;
+    private resultCounter;
+    private policyCounter;
+    /**
+     * Configure image scanning
+     */
+    configureScan(config: Omit<ImageScanConfig, 'id'>): ImageScanConfig;
+    /**
+     * Configure Trivy scanning
+     */
+    configureTrivyScan(options: {
+        repository: string;
+        imageTag: string;
+        scanOnPush?: boolean;
+        ignoreUnfixed?: boolean;
+    }): ImageScanConfig;
+    /**
+     * Configure Snyk scanning
+     */
+    configureSnykScan(options: {
+        repository: string;
+        imageTag: string;
+        scanOnPush?: boolean;
+    }): ImageScanConfig;
+    /**
+     * Configure ECR scanning
+     */
+    configureECRScan(options: {
+        repository: string;
+        scanOnPush?: boolean;
+    }): ImageScanConfig;
+    /**
+     * Scan image
+     */
+    scanImage(configId: string): Promise<ImageScanResult>;
+    /**
+     * Simulate vulnerabilities (in production, call actual scanner)
+     */
+    private simulateVulnerabilities;
+    /**
+     * Evaluate scan result
+     */
+    private evaluateScanResult;
+    /**
+     * Create scan policy
+     */
+    createPolicy(policy: Omit<ScanPolicy, 'id'>): ScanPolicy;
+    /**
+     * Create strict policy
+     */
+    createStrictPolicy(name: string): ScanPolicy;
+    /**
+     * Create permissive policy
+     */
+    createPermissivePolicy(name: string): ScanPolicy;
+    /**
+     * Get config
+     */
+    getConfig(id: string): ImageScanConfig | undefined;
+    /**
+     * List configs
+     */
+    listConfigs(): ImageScanConfig[];
+    /**
+     * Get result
+     */
+    getResult(id: string): ImageScanResult | undefined;
+    /**
+     * List results
+     */
+    listResults(): ImageScanResult[];
+    /**
+     * Generate CloudFormation for ECR scanning
+     */
+    generateECRScanCF(config: ImageScanConfig): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global image scanning manager instance
+ */
+export declare const imageScanningManager: ImageScanningManager;

package/dist/containers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Container Advanced Features Module
+ * Image scanning, build optimization, registry management, and service mesh
+ */
+export * from './image-scanning';
+export * from './build-optimization';
+export * from './registry';
+export * from './service-mesh';

package/dist/containers/registry.d.ts

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

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

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

package/dist/database/database.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/database/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Database Advanced Features Module
+ * Migration management, replicas, performance monitoring, and user management
+ */
+export * from './migrations';
+export * from './replicas';
+export * from './performance';
+export * from './users';