@ts-cloud/core 0.2.3 → 0.2.5

package/dist/database/users.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Database User Management
+ * User creation, permissions, and access control
+ */
+export interface DatabaseUser {
+    id: string;
+    username: string;
+    database: string;
+    privileges: DatabasePrivilege[];
+    passwordSecretArn?: string;
+    createdAt: Date;
+    lastRotated?: Date;
+    rotationEnabled?: boolean;
+    rotationDays?: number;
+}
+export interface DatabasePrivilege {
+    database?: string;
+    table?: string;
+    privileges: PrivilegeType[];
+}
+export type PrivilegeType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'CREATE' | 'DROP' | 'ALTER' | 'INDEX' | 'EXECUTE' | 'ALL';
+export interface UserRole {
+    id: string;
+    name: string;
+    description?: string;
+    privileges: DatabasePrivilege[];
+    users: string[];
+}
+export interface AccessAudit {
+    id: string;
+    username: string;
+    action: 'LOGIN' | 'QUERY' | 'MODIFY' | 'GRANT' | 'REVOKE';
+    database?: string;
+    table?: string;
+    query?: string;
+    timestamp: Date;
+    success: boolean;
+    ipAddress?: string;
+}
+/**
+ * Database user manager
+ */
+export declare class DatabaseUserManager {
+    private users;
+    private roles;
+    private audits;
+    private userCounter;
+    private roleCounter;
+    private auditCounter;
+    /**
+     * Create database user
+     */
+    createUser(user: Omit<DatabaseUser, 'id' | 'createdAt'>): DatabaseUser;
+    /**
+     * Create read-only user
+     */
+    createReadOnlyUser(options: {
+        username: string;
+        database: string;
+        passwordSecretArn?: string;
+        tables?: string[];
+    }): DatabaseUser;
+    /**
+     * Create read-write user
+     */
+    createReadWriteUser(options: {
+        username: string;
+        database: string;
+        passwordSecretArn?: string;
+        tables?: string[];
+    }): DatabaseUser;
+    /**
+     * Create admin user
+     */
+    createAdminUser(options: {
+        username: string;
+        database: string;
+        passwordSecretArn?: string;
+    }): DatabaseUser;
+    /**
+     * Create application user with specific table access
+     */
+    createApplicationUser(options: {
+        username: string;
+        database: string;
+        tables: {
+            name: string;
+            privileges: PrivilegeType[];
+        }[];
+        passwordSecretArn?: string;
+    }): DatabaseUser;
+    /**
+     * Create user role
+     */
+    createRole(role: Omit<UserRole, 'id' | 'users'>): UserRole;
+    /**
+     * Assign user to role
+     */
+    assignUserToRole(userId: string, roleId: string): void;
+    /**
+     * Grant privileges to user
+     */
+    grantPrivileges(userId: string, privileges: DatabasePrivilege[]): {
+        success: boolean;
+        message: string;
+    };
+    /**
+     * Revoke privileges from user
+     */
+    revokePrivileges(userId: string, privileges: DatabasePrivilege[]): {
+        success: boolean;
+        message: string;
+    };
+    /**
+     * Rotate user password
+     */
+    rotatePassword(userId: string): {
+        success: boolean;
+        newSecretArn?: string;
+    };
+    /**
+     * Check if password rotation needed
+     */
+    needsPasswordRotation(userId: string): boolean;
+    /**
+     * Audit access
+     */
+    auditAccess(audit: Omit<AccessAudit, 'id' | 'timestamp'>): AccessAudit;
+    /**
+     * Get user access history
+     */
+    getUserAccessHistory(username: string, limit?: number): AccessAudit[];
+    /**
+     * Get failed login attempts
+     */
+    getFailedLoginAttempts(username: string, hours?: number): AccessAudit[];
+    /**
+     * Generate SQL for user creation
+     */
+    generateCreateUserSQL(user: DatabaseUser, engine?: 'postgres' | 'mysql'): string;
+    /**
+     * Get user
+     */
+    getUser(id: string): DatabaseUser | undefined;
+    /**
+     * List users
+     */
+    listUsers(): DatabaseUser[];
+    /**
+     * Get role
+     */
+    getRole(id: string): UserRole | undefined;
+    /**
+     * List roles
+     */
+    listRoles(): UserRole[];
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global database user manager instance
+ */
+export declare const databaseUserManager: DatabaseUserManager;

package/dist/dependency-graph.d.ts

@@ -0,0 +1,37 @@
+import type { CloudFormationResource } from '@ts-cloud/aws-types';
+export 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;
+    /**
+     * Add a resource to the dependency graph
+     */
+    addResource(logicalId: string, resource: CloudFormationResource): void;
+    /**
+     * Extract dependencies from a resource
+     */
+    private extractDependencies;
+    /**
+     * Find all Ref references in an object
+     */
+    private findReferences;
+    /**
+     * Perform topological sort to determine resource creation order
+     */
+    topologicalSort(): string[];
+    /**
+     * Validate that all dependencies exist
+     */
+    validate(): void;
+    /**
+     * Get resources that depend on a given resource
+     */
+    getDependents(logicalId: string): string[];
+}

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

@@ -0,0 +1,165 @@
+/**
+ * A/B Testing Infrastructure
+ * Traffic splitting based on user attributes, headers, or cookies
+ */
+export 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 interface ABVariant {
+    id: string;
+    name: string;
+    description?: string;
+    trafficPercentage: number;
+    targetGroupArn?: string;
+    functionVersionArn?: string;
+    originId?: string;
+    weight: number;
+}
+export interface RoutingStrategy {
+    type: 'random' | 'cookie' | 'header' | 'geo' | 'device' | 'user-attribute';
+    cookieName?: string;
+    headerName?: string;
+    attributeName?: string;
+    stickySession?: boolean;
+    sessionDuration?: number;
+}
+export interface ABMetrics {
+    variants: Record<string, VariantMetrics>;
+    totalRequests: number;
+    startTime: Date;
+    lastUpdated: Date;
+}
+export interface VariantMetrics {
+    requests: number;
+    conversions: number;
+    conversionRate: number;
+    averageLatency: number;
+    errorRate: number;
+    revenue?: number;
+    customMetrics?: Record<string, number>;
+}
+export 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;
+    private testCounter;
+    /**
+     * Create A/B test
+     */
+    createTest(test: Omit<ABTest, 'id'>): ABTest;
+    /**
+     * Create simple A/B test (control vs variant)
+     */
+    createSimpleABTest(options: {
+        name: string;
+        description?: string;
+        controlTargetGroupArn: string;
+        variantTargetGroupArn: string;
+        variantTrafficPercentage?: number;
+        stickySession?: boolean;
+    }): ABTest;
+    /**
+     * Create multivariate test
+     */
+    createMultivariateTest(options: {
+        name: string;
+        description?: string;
+        variants: Array<{
+            name: string;
+            description?: string;
+            targetGroupArn: string;
+            trafficPercentage: number;
+        }>;
+        routingStrategy?: RoutingStrategy;
+    }): ABTest;
+    /**
+     * Create header-based A/B test
+     */
+    createHeaderBasedTest(options: {
+        name: string;
+        controlTargetGroupArn: string;
+        variantTargetGroupArn: string;
+        headerName: string;
+        headerValue: string;
+    }): ABTest;
+    /**
+     * Create geo-based A/B test
+     */
+    createGeoBasedTest(options: {
+        name: string;
+        controlTargetGroupArn: string;
+        variantTargetGroupArn: string;
+        regions: string[];
+    }): ABTest;
+    /**
+     * Start A/B test
+     */
+    startTest(testId: string): void;
+    /**
+     * Pause A/B test
+     */
+    pauseTest(testId: string): void;
+    /**
+     * Update traffic split
+     */
+    updateTrafficSplit(testId: string, variantId: string, newPercentage: number): void;
+    /**
+     * Analyze test results
+     */
+    analyzeResults(testId: string): ABTestResult;
+    /**
+     * Declare winner and route all traffic
+     */
+    declareWinner(testId: string, variantId: string): void;
+    /**
+     * Collect metrics for test
+     */
+    private collectMetrics;
+    /**
+     * Generate recommendation
+     */
+    private generateRecommendation;
+    /**
+     * Get test
+     */
+    getTest(id: string): ABTest | undefined;
+    /**
+     * List tests
+     */
+    listTests(): ABTest[];
+    /**
+     * Generate CloudFormation for ALB weighted routing
+     */
+    generateALBListenerRuleCF(test: ABTest): any;
+    /**
+     * Generate Lambda@Edge function for A/B testing
+     */
+    generateLambdaEdgeFunction(test: ABTest): string;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global A/B testing manager instance
+ */
+export declare const abTestManager: ABTestManager;

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

@@ -0,0 +1,140 @@
+/**
+ * Blue/Green Deployment Strategy
+ * Zero-downtime deployments with instant rollback capability
+ */
+export interface BlueGreenDeployment {
+    id: string;
+    name: string;
+    blueEnvironment: Environment;
+    greenEnvironment: Environment;
+    activeEnvironment: 'blue' | 'green';
+    routingConfig: RoutingConfig;
+    autoPromote?: boolean;
+    autoRollback?: boolean;
+    healthCheckConfig?: HealthCheckConfig;
+}
+export interface Environment {
+    name: string;
+    targetGroupArn: string;
+    autoScalingGroupName?: string;
+    taskDefinitionArn?: string;
+    functionVersionArn?: string;
+    instanceIds?: string[];
+    weight?: number;
+}
+export interface RoutingConfig {
+    type: 'alb' | 'route53' | 'cloudfront' | 'api-gateway';
+    listenerArn?: string;
+    hostedZoneId?: string;
+    distributionId?: string;
+    apiId?: string;
+    switchoverTimeSeconds?: number;
+}
+export interface HealthCheckConfig {
+    healthyThreshold: number;
+    unhealthyThreshold: number;
+    interval: number;
+    timeout: number;
+    path?: string;
+    port?: number;
+}
+export 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;
+    private deploymentHistory;
+    private deploymentCounter;
+    private resultCounter;
+    /**
+     * Create blue/green deployment configuration
+     */
+    createDeployment(deployment: Omit<BlueGreenDeployment, 'id'>): BlueGreenDeployment;
+    /**
+     * Create ALB-based blue/green deployment
+     */
+    createALBDeployment(options: {
+        name: string;
+        listenerArn: string;
+        blueTargetGroupArn: string;
+        greenTargetGroupArn: string;
+        autoPromote?: boolean;
+        healthCheckConfig?: HealthCheckConfig;
+    }): BlueGreenDeployment;
+    /**
+     * Create Route53-based blue/green deployment
+     */
+    createRoute53Deployment(options: {
+        name: string;
+        hostedZoneId: string;
+        blueTargetGroupArn: string;
+        greenTargetGroupArn: string;
+        switchoverTimeSeconds?: number;
+    }): BlueGreenDeployment;
+    /**
+     * Create ECS blue/green deployment
+     */
+    createECSDeployment(options: {
+        name: string;
+        listenerArn: string;
+        blueTargetGroupArn: string;
+        greenTargetGroupArn: string;
+        blueTaskDefinitionArn: string;
+        greenTaskDefinitionArn: string;
+        autoRollback?: boolean;
+    }): BlueGreenDeployment;
+    /**
+     * Execute blue/green deployment
+     */
+    executeDeployment(deploymentId: string, dryRun?: boolean): Promise<DeploymentResult>;
+    /**
+     * Rollback deployment
+     */
+    rollback(deploymentId: string): Promise<DeploymentResult>;
+    /**
+     * Run health checks
+     */
+    private runHealthChecks;
+    /**
+     * Record deployment result
+     */
+    private recordDeployment;
+    /**
+     * Get deployment
+     */
+    getDeployment(id: string): BlueGreenDeployment | undefined;
+    /**
+     * List deployments
+     */
+    listDeployments(): BlueGreenDeployment[];
+    /**
+     * Get deployment history
+     */
+    getDeploymentHistory(deploymentId: string): DeploymentResult[];
+    /**
+     * Generate CloudFormation for ALB target group switching
+     */
+    generateALBListenerCF(deployment: BlueGreenDeployment): any;
+    /**
+     * Generate CloudFormation for Route53 weighted routing
+     */
+    generateRoute53RecordSetCF(deployment: BlueGreenDeployment, recordName: string): any[];
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global blue/green manager instance
+ */
+export declare const blueGreenManager: BlueGreenManager;

package/dist/deployment/canary.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Canary Deployment Strategy
+ * Gradual rollout with automatic rollback based on metrics
+ */
+export 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 interface DeploymentVersion {
+    version: string;
+    targetGroupArn?: string;
+    taskDefinitionArn?: string;
+    functionVersionArn?: string;
+    weight: number;
+}
+export interface CanaryStage {
+    name: string;
+    trafficPercentage: number;
+    durationMinutes: number;
+    alarmThresholds?: AlarmThresholds;
+}
+export interface AlarmThresholds {
+    errorRate?: number;
+    latencyP99?: number;
+    latencyP95?: number;
+    httpErrorRate?: number;
+    customMetrics?: CustomMetric[];
+}
+export interface CustomMetric {
+    name: string;
+    namespace: string;
+    threshold: number;
+    comparisonOperator: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold';
+}
+export interface CanaryMetrics {
+    baselineErrorRate: number;
+    canaryErrorRate: number;
+    baselineLatencyP99: number;
+    canaryLatencyP99: number;
+    baselineRequestCount: number;
+    canaryRequestCount: number;
+}
+export 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;
+    private deploymentHistory;
+    private deploymentCounter;
+    private resultCounter;
+    /**
+     * Predefined canary strategies
+     */
+    static readonly Strategies: {
+        /**
+         * Conservative: 10% -> 25% -> 50% -> 100%
+         */
+        CONSERVATIVE: CanaryStage[];
+        /**
+         * Balanced: 20% -> 50% -> 100%
+         */
+        BALANCED: CanaryStage[];
+        /**
+         * Aggressive: 50% -> 100%
+         */
+        AGGRESSIVE: CanaryStage[];
+        /**
+         * Linear 10%: Incremental 10% steps
+         */
+        LINEAR_10: CanaryStage[];
+    };
+    /**
+     * Create canary deployment
+     */
+    createDeployment(deployment: Omit<CanaryDeployment, 'id'>): CanaryDeployment;
+    /**
+     * Create Lambda canary deployment
+     */
+    createLambdaCanaryDeployment(options: {
+        name: string;
+        baselineVersionArn: string;
+        canaryVersionArn: string;
+        strategy?: keyof typeof CanaryManager.Strategies;
+        autoPromote?: boolean;
+        errorRateThreshold?: number;
+        latencyThreshold?: number;
+    }): CanaryDeployment;
+    /**
+     * Create ECS canary deployment
+     */
+    createECSCanaryDeployment(options: {
+        name: string;
+        baselineTaskDefinitionArn: string;
+        canaryTaskDefinitionArn: string;
+        baselineTargetGroupArn: string;
+        canaryTargetGroupArn: string;
+        strategy?: keyof typeof CanaryManager.Strategies;
+    }): CanaryDeployment;
+    /**
+     * Execute canary deployment
+     */
+    executeDeployment(deploymentId: string, dryRun?: boolean): Promise<CanaryResult>;
+    /**
+     * Monitor canary stage
+     */
+    private monitorStage;
+    /**
+     * Rollback canary deployment
+     */
+    rollback(deploymentId: string, dryRun?: boolean): Promise<void>;
+    /**
+     * Promote canary to baseline
+     */
+    promoteCanary(deploymentId: string): void;
+    /**
+     * Record deployment result
+     */
+    private recordDeployment;
+    /**
+     * Get deployment
+     */
+    getDeployment(id: string): CanaryDeployment | undefined;
+    /**
+     * List deployments
+     */
+    listDeployments(): CanaryDeployment[];
+    /**
+     * Get deployment history
+     */
+    getDeploymentHistory(deploymentId: string): CanaryResult[];
+    /**
+     * Generate CloudFormation for Lambda canary
+     */
+    generateLambdaAliasCF(deployment: CanaryDeployment, aliasName: string): any;
+    /**
+     * Generate CloudFormation for ALB weighted target groups
+     */
+    generateALBListenerRuleCF(deployment: CanaryDeployment): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global canary manager instance
+ */
+export declare const canaryManager: CanaryManager;

package/dist/deployment/deployment.test.d.ts

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

package/dist/deployment/index.d.ts

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