@ts-cloud/core 0.2.3 → 0.2.5

package/dist/lambda/versions.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Lambda Versions and Aliases
+ * Immutable versions and mutable aliases for Lambda functions
+ */
+export interface LambdaVersion {
+    id: string;
+    functionName: string;
+    version: string;
+    functionArn: string;
+    codeHash: string;
+    description?: string;
+    runtime: string;
+    memorySize: number;
+    timeout: number;
+    publishedAt: Date;
+}
+export interface LambdaAlias {
+    id: string;
+    functionName: string;
+    aliasName: string;
+    aliasArn: string;
+    functionVersion: string;
+    description?: string;
+    routingConfig?: RoutingConfig;
+    revisionId?: string;
+}
+export interface RoutingConfig {
+    additionalVersionWeights?: Record<string, number>;
+}
+export interface VersionDeployment {
+    id: string;
+    functionName: string;
+    fromVersion: string;
+    toVersion: string;
+    aliasName: string;
+    strategy: 'all_at_once' | 'linear' | 'canary';
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    startedAt?: Date;
+    completedAt?: Date;
+}
+/**
+ * Lambda versions manager
+ */
+export declare class LambdaVersionsManager {
+    private versions;
+    private aliases;
+    private deployments;
+    private versionCounter;
+    private aliasCounter;
+    private deploymentCounter;
+    /**
+     * Publish function version
+     */
+    publishVersion(options: {
+        functionName: string;
+        description?: string;
+        runtime: string;
+        memorySize: number;
+        timeout: number;
+    }): LambdaVersion;
+    /**
+     * Get next version number
+     */
+    private getNextVersionNumber;
+    /**
+     * Create alias
+     */
+    createAlias(alias: Omit<LambdaAlias, 'id' | 'aliasArn' | 'revisionId'>): LambdaAlias;
+    /**
+     * Create production alias
+     */
+    createProductionAlias(options: {
+        functionName: string;
+        version: string;
+    }): LambdaAlias;
+    /**
+     * Create staging alias
+     */
+    createStagingAlias(options: {
+        functionName: string;
+        version: string;
+    }): LambdaAlias;
+    /**
+     * Update alias
+     */
+    updateAlias(aliasId: string, newVersion: string): LambdaAlias;
+    /**
+     * Configure weighted routing
+     */
+    configureWeightedRouting(aliasId: string, weights: Record<string, number>): LambdaAlias;
+    /**
+     * Create canary deployment
+     */
+    createCanaryDeployment(options: {
+        functionName: string;
+        fromVersion: string;
+        toVersion: string;
+        aliasName: string;
+        canaryWeight: number;
+    }): VersionDeployment;
+    /**
+     * Complete deployment
+     */
+    completeDeployment(deploymentId: string): VersionDeployment;
+    /**
+     * Rollback deployment
+     */
+    rollbackDeployment(deploymentId: string): VersionDeployment;
+    /**
+     * Generate hash
+     */
+    private generateHash;
+    /**
+     * Get version
+     */
+    getVersion(id: string): LambdaVersion | undefined;
+    /**
+     * List versions
+     */
+    listVersions(functionName?: string): LambdaVersion[];
+    /**
+     * Get alias
+     */
+    getAlias(id: string): LambdaAlias | undefined;
+    /**
+     * List aliases
+     */
+    listAliases(functionName?: string): LambdaAlias[];
+    /**
+     * Generate CloudFormation for version
+     */
+    generateVersionCF(version: LambdaVersion): any;
+    /**
+     * Generate CloudFormation for alias
+     */
+    generateAliasCF(alias: LambdaAlias): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda versions manager instance
+ */
+export declare const lambdaVersionsManager: LambdaVersionsManager;

package/dist/lambda/vpc.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Lambda VPC Configuration
+ * VPC networking for Lambda functions
+ */
+export interface LambdaVPCConfig {
+    id: string;
+    functionName: string;
+    vpcId: string;
+    subnetIds: string[];
+    securityGroupIds: string[];
+    ipv6Allowed?: boolean;
+}
+export interface VPCEndpoint {
+    id: string;
+    vpcId: string;
+    serviceName: string;
+    endpointType: 'Interface' | 'Gateway';
+    subnetIds?: string[];
+    securityGroupIds?: string[];
+    privateDnsEnabled?: boolean;
+}
+export interface NetworkInterface {
+    id: string;
+    functionName: string;
+    networkInterfaceId: string;
+    subnetId: string;
+    privateIpAddress: string;
+    status: 'creating' | 'available' | 'in-use' | 'deleting';
+    attachedAt?: Date;
+}
+export interface VPCConnectivity {
+    id: string;
+    functionName: string;
+    hasInternetAccess: boolean;
+    hasNATGateway: boolean;
+    hasVPCEndpoints: boolean;
+    endpoints: string[];
+    recommendations: string[];
+}
+/**
+ * Lambda VPC manager
+ */
+export declare class LambdaVPCManager {
+    private vpcConfigs;
+    private endpoints;
+    private networkInterfaces;
+    private connectivity;
+    private configCounter;
+    private endpointCounter;
+    private eniCounter;
+    private connectivityCounter;
+    /**
+     * Configure VPC
+     */
+    configureVPC(config: Omit<LambdaVPCConfig, 'id'>): LambdaVPCConfig;
+    /**
+     * Configure private VPC
+     */
+    configurePrivateVPC(options: {
+        functionName: string;
+        vpcId: string;
+        privateSubnetIds: string[];
+        securityGroupId: string;
+    }): LambdaVPCConfig;
+    /**
+     * Configure multi-AZ VPC
+     */
+    configureMultiAZVPC(options: {
+        functionName: string;
+        vpcId: string;
+        subnetIds: string[];
+        securityGroupIds: string[];
+    }): LambdaVPCConfig;
+    /**
+     * Create VPC endpoint
+     */
+    createVPCEndpoint(endpoint: Omit<VPCEndpoint, 'id'>): VPCEndpoint;
+    /**
+     * Create S3 VPC endpoint
+     */
+    createS3Endpoint(options: {
+        vpcId: string;
+        routeTableIds: string[];
+    }): VPCEndpoint;
+    /**
+     * Create DynamoDB VPC endpoint
+     */
+    createDynamoDBEndpoint(options: {
+        vpcId: string;
+        routeTableIds: string[];
+    }): VPCEndpoint;
+    /**
+     * Create Secrets Manager VPC endpoint
+     */
+    createSecretsManagerEndpoint(options: {
+        vpcId: string;
+        subnetIds: string[];
+        securityGroupIds: string[];
+    }): VPCEndpoint;
+    /**
+     * Create network interface
+     */
+    private createNetworkInterface;
+    /**
+     * Analyze VPC connectivity
+     */
+    analyzeConnectivity(options: {
+        functionName: string;
+        hasNATGateway?: boolean;
+        hasInternetGateway?: boolean;
+    }): VPCConnectivity;
+    /**
+     * Get VPC config
+     */
+    getVPCConfig(id: string): LambdaVPCConfig | undefined;
+    /**
+     * List VPC configs
+     */
+    listVPCConfigs(functionName?: string): LambdaVPCConfig[];
+    /**
+     * Get network interfaces
+     */
+    getNetworkInterfaces(functionName: string): NetworkInterface[];
+    /**
+     * List VPC endpoints
+     */
+    listVPCEndpoints(vpcId?: string): VPCEndpoint[];
+    /**
+     * Generate CloudFormation for VPC config
+     */
+    generateVPCConfigCF(config: LambdaVPCConfig): any;
+    /**
+     * Generate CloudFormation for VPC endpoint
+     */
+    generateVPCEndpointCF(endpoint: VPCEndpoint): any;
+    /**
+     * Generate security group CloudFormation
+     */
+    generateSecurityGroupCF(options: {
+        groupName: string;
+        vpcId: string;
+        ingressRules?: Array<{
+            protocol: string;
+            fromPort: number;
+            toPort: number;
+            cidrIp?: string;
+            sourceSecurityGroupId?: string;
+        }>;
+        egressRules?: Array<{
+            protocol: string;
+            fromPort: number;
+            toPort: number;
+            cidrIp?: string;
+        }>;
+    }): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda VPC manager instance
+ */
+export declare const lambdaVPCManager: LambdaVPCManager;

package/dist/local/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Local development configuration
+ * Configures ts-cloud to use LocalStack and local services
+ */
+export interface LocalConfig {
+    enabled: boolean;
+    localstackEndpoint: string;
+    postgresUrl: string;
+    redisUrl: string;
+    dynamodbEndpoint: string;
+    s3Endpoint: string;
+    emailEndpoint: string;
+    awsRegion: string;
+    awsAccessKeyId: string;
+    awsSecretAccessKey: string;
+}
+/**
+ * Default local development configuration
+ */
+export declare const defaultLocalConfig: LocalConfig;
+/**
+ * Get local configuration
+ */
+export declare function getLocalConfig(): LocalConfig;
+/**
+ * Check if running in local development mode
+ */
+export declare function isLocalDevelopment(): boolean;
+/**
+ * Get AWS endpoint for service in local mode
+ */
+export declare function getLocalEndpoint(service: string): string;
+/**
+ * Get local credentials
+ */
+export declare function getLocalCredentials(): {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+};
+/**
+ * Create local environment variables for AWS CLI
+ */
+export declare function getLocalEnvVars(): Record<string, string>;

package/dist/local/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Local development and testing utilities
+ */
+export * from './config';
+export * from './mock-aws';

package/dist/local/mock-aws.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Mock AWS services for unit testing
+ * Provides in-memory implementations of AWS services without external dependencies
+ */
+export interface MockAWSConfig {
+    region?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+}
+/**
+ * Mock CloudFormation service
+ */
+export declare class MockCloudFormation {
+    private stacks;
+    private stackEvents;
+    createStack(params: any): Promise<any>;
+    updateStack(params: any): Promise<any>;
+    deleteStack(params: any): Promise<void>;
+    describeStacks(params: any): Promise<any>;
+    describeStackEvents(params: any): Promise<any>;
+    private addEvent;
+    /**
+     * Reset mock state (useful for testing)
+     */
+    reset(): void;
+}
+/**
+ * Mock S3 service
+ */
+export declare class MockS3 {
+    private buckets;
+    createBucket(params: any): Promise<any>;
+    deleteBucket(params: any): Promise<void>;
+    putObject(params: any): Promise<any>;
+    getObject(params: any): Promise<any>;
+    deleteObject(params: any): Promise<void>;
+    listObjects(params: any): Promise<any>;
+    /**
+     * Reset mock state
+     */
+    reset(): void;
+}
+/**
+ * Mock DynamoDB service
+ */
+export declare class MockDynamoDB {
+    private tables;
+    private data;
+    createTable(params: any): Promise<any>;
+    deleteTable(params: any): Promise<void>;
+    putItem(params: any): Promise<void>;
+    getItem(params: any): Promise<any>;
+    deleteItem(params: any): Promise<void>;
+    scan(params: any): Promise<any>;
+    /**
+     * Reset mock state
+     */
+    reset(): void;
+}
+/**
+ * Create mock AWS services
+ */
+export declare function createMockAWS(_config?: MockAWSConfig): {
+    cloudformation: MockCloudFormation;
+    s3: MockS3;
+    dynamodb: MockDynamoDB;
+};

package/dist/modules/ai.d.ts

@@ -0,0 +1,108 @@
+import type { IAMRole, IAMManagedPolicy } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+export interface BedrockRoleOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    models?: string[];
+    allowStreaming?: boolean;
+}
+export interface BedrockPolicyOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    models?: string[];
+    allowInvoke?: boolean;
+    allowStreaming?: boolean;
+    allowAsync?: boolean;
+}
+/**
+ * AI Module - Amazon Bedrock
+ * Provides clean API for setting up Bedrock permissions and roles
+ */
+export declare class AI {
+    /**
+     * Create an IAM role for Bedrock access
+     */
+    static createBedrockRole(servicePrincipal: string, options: BedrockRoleOptions): {
+        role: IAMRole;
+        logicalId: string;
+    };
+    /**
+     * Create an IAM policy for Bedrock model invocation
+     */
+    static createBedrockPolicy(options: BedrockPolicyOptions): {
+        policy: IAMManagedPolicy;
+        logicalId: string;
+    };
+    /**
+     * Enable Bedrock for Lambda function
+     * Returns a role with Bedrock permissions
+     */
+    static enableBedrockForLambda(options: BedrockRoleOptions): {
+        role: IAMRole;
+        logicalId: string;
+    };
+    /**
+     * Enable Bedrock for ECS task
+     * Returns a role with Bedrock permissions
+     */
+    static enableBedrockForEcs(options: BedrockRoleOptions): {
+        role: IAMRole;
+        logicalId: string;
+    };
+    /**
+     * Enable Bedrock for EC2 instance
+     * Returns a role with Bedrock permissions
+     */
+    static enableBedrockForEc2(options: BedrockRoleOptions): {
+        role: IAMRole;
+        logicalId: string;
+    };
+    /**
+     * Add Bedrock permissions to an existing role
+     */
+    static addBedrockPermissions(role: IAMRole, models?: string[], allowStreaming?: boolean): IAMRole;
+    /**
+     * Common Bedrock model IDs
+     */
+    static readonly Models: {
+        readonly Claude3_5_Sonnet: "anthropic.claude-3-5-sonnet-20241022-v2:0";
+        readonly Claude3_5_Haiku: "anthropic.claude-3-5-haiku-20241022-v1:0";
+        readonly Claude3_Opus: "anthropic.claude-3-opus-20240229-v1:0";
+        readonly Claude3_Sonnet: "anthropic.claude-3-sonnet-20240229-v1:0";
+        readonly Claude3_Haiku: "anthropic.claude-3-haiku-20240307-v1:0";
+        readonly TitanTextG1Express: "amazon.titan-text-express-v1";
+        readonly TitanTextG1Lite: "amazon.titan-text-lite-v1";
+        readonly TitanEmbedG1Text: "amazon.titan-embed-text-v1";
+        readonly TitanImageG1: "amazon.titan-image-generator-v1";
+        readonly JurassicUltra: "ai21.j2-ultra-v1";
+        readonly JurassicMid: "ai21.j2-mid-v1";
+        readonly CommandText: "cohere.command-text-v14";
+        readonly CommandLight: "cohere.command-light-text-v14";
+        readonly EmbedEnglish: "cohere.embed-english-v3";
+        readonly EmbedMultilingual: "cohere.embed-multilingual-v3";
+        readonly Llama3_2_1B: "meta.llama3-2-1b-instruct-v1:0";
+        readonly Llama3_2_3B: "meta.llama3-2-3b-instruct-v1:0";
+        readonly Llama3_2_11B: "meta.llama3-2-11b-instruct-v1:0";
+        readonly Llama3_2_90B: "meta.llama3-2-90b-instruct-v1:0";
+        readonly Llama3_1_8B: "meta.llama3-1-8b-instruct-v1:0";
+        readonly Llama3_1_70B: "meta.llama3-1-70b-instruct-v1:0";
+        readonly Llama3_1_405B: "meta.llama3-1-405b-instruct-v1:0";
+        readonly Mistral7B: "mistral.mistral-7b-instruct-v0:2";
+        readonly Mixtral8x7B: "mistral.mixtral-8x7b-instruct-v0:1";
+        readonly MistralLarge: "mistral.mistral-large-2402-v1:0";
+        readonly StableDiffusionXL: "stability.stable-diffusion-xl-v1";
+    };
+    /**
+     * Common model groups for easier permission management
+     */
+    static readonly ModelGroups: {
+        readonly AllClaude: readonly ["anthropic.claude-3-5-sonnet-20241022-v2:0", "anthropic.claude-3-5-haiku-20241022-v1:0", "anthropic.claude-3-opus-20240229-v1:0", "anthropic.claude-3-sonnet-20240229-v1:0", "anthropic.claude-3-haiku-20240307-v1:0"];
+        readonly AllTitan: readonly ["amazon.titan-text-express-v1", "amazon.titan-text-lite-v1", "amazon.titan-embed-text-v1", "amazon.titan-image-generator-v1"];
+        readonly AllLlama: readonly ["meta.llama3-2-1b-instruct-v1:0", "meta.llama3-2-3b-instruct-v1:0", "meta.llama3-2-11b-instruct-v1:0", "meta.llama3-2-90b-instruct-v1:0", "meta.llama3-1-8b-instruct-v1:0", "meta.llama3-1-70b-instruct-v1:0", "meta.llama3-1-405b-instruct-v1:0"];
+        readonly TextModels: readonly ["anthropic.claude-3-5-sonnet-20241022-v2:0", "anthropic.claude-3-5-haiku-20241022-v1:0", "amazon.titan-text-express-v1", "meta.llama3-2-11b-instruct-v1:0", "mistral.mistral-7b-instruct-v0:2"];
+        readonly EmbeddingModels: readonly ["amazon.titan-embed-text-v1", "cohere.embed-english-v3", "cohere.embed-multilingual-v3"];
+        readonly ImageModels: readonly ["amazon.titan-image-generator-v1", "stability.stable-diffusion-xl-v1"];
+    };
+}

package/dist/modules/api.d.ts

@@ -0,0 +1,157 @@
+import type { ApiGatewayAuthorizer, ApiGatewayDeployment, ApiGatewayHttpApi, ApiGatewayRestApi, ApiGatewayStage } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+export interface RestApiOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    apiName?: string;
+    description?: string;
+    endpointType?: 'EDGE' | 'REGIONAL' | 'PRIVATE';
+    binaryMediaTypes?: string[];
+    compressionSize?: number;
+}
+export interface HttpApiOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    description?: string;
+    corsEnabled?: boolean;
+    corsOrigins?: string[];
+    corsMethods?: string[];
+    corsHeaders?: string[];
+    corsMaxAge?: number;
+    corsAllowCredentials?: boolean;
+}
+export interface WebSocketApiOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    description?: string;
+}
+export interface StageOptions {
+    slug: string;
+    environment: EnvironmentType;
+    stageName?: string;
+    description?: string;
+    cacheEnabled?: boolean;
+    cacheSize?: '0.5' | '1.6' | '6.1' | '13.5' | '28.4' | '58.2' | '118' | '237';
+    variables?: Record<string, string>;
+    throttling?: {
+        burstLimit?: number;
+        rateLimit?: number;
+    };
+}
+export interface AuthorizerOptions {
+    slug: string;
+    environment: EnvironmentType;
+    name?: string;
+    type: 'TOKEN' | 'REQUEST' | 'COGNITO_USER_POOLS';
+    functionArn?: string;
+    identitySource?: string;
+    userPoolArns?: string[];
+    ttl?: number;
+}
+/**
+ * API Gateway Module - REST, HTTP, and WebSocket APIs
+ * Provides clean API for creating and configuring API Gateway resources
+ */
+export declare class ApiGateway {
+    /**
+     * Create a REST API
+     */
+    static createRestApi(options: RestApiOptions): {
+        restApi: ApiGatewayRestApi;
+        logicalId: string;
+    };
+    /**
+     * Create an HTTP API (cheaper and simpler than REST API)
+     */
+    static createHttpApi(options: HttpApiOptions): {
+        httpApi: ApiGatewayHttpApi;
+        logicalId: string;
+    };
+    /**
+     * Create a WebSocket API
+     */
+    static createWebSocketApi(options: WebSocketApiOptions): {
+        webSocketApi: ApiGatewayHttpApi;
+        logicalId: string;
+    };
+    /**
+     * Create a deployment for REST API
+     */
+    static createDeployment(restApiLogicalId: string, options: {
+        slug: string;
+        environment: EnvironmentType;
+        description?: string;
+    }): {
+        deployment: ApiGatewayDeployment;
+        logicalId: string;
+    };
+    /**
+     * Create a stage for REST API
+     */
+    static createStage(restApiLogicalId: string, deploymentLogicalId: string, options: StageOptions): {
+        stage: ApiGatewayStage;
+        logicalId: string;
+    };
+    /**
+     * Create an authorizer for REST API
+     */
+    static createAuthorizer(restApiLogicalId: string, options: AuthorizerOptions): {
+        authorizer: ApiGatewayAuthorizer;
+        logicalId: string;
+    };
+    /**
+     * Enable CORS on HTTP API
+     */
+    static setCors(httpApi: ApiGatewayHttpApi, options?: {
+        origins?: string[];
+        methods?: string[];
+        headers?: string[];
+        maxAge?: number;
+        allowCredentials?: boolean;
+    }): ApiGatewayHttpApi;
+    /**
+     * Add throttling to stage
+     */
+    static addThrottling(stage: ApiGatewayStage, burstLimit?: number, rateLimit?: number): ApiGatewayStage;
+    /**
+     * Enable caching on stage
+     */
+    static enableCaching(stage: ApiGatewayStage, cacheSize?: '0.5' | '1.6' | '6.1' | '13.5' | '28.4' | '58.2' | '118' | '237', ttl?: number): ApiGatewayStage;
+    /**
+     * Common cache sizes (in GB)
+     */
+    static readonly CacheSizes: {
+        readonly Small: "0.5";
+        readonly Medium: "1.6";
+        readonly Large: "6.1";
+        readonly XLarge: "13.5";
+        readonly XXLarge: "28.4";
+        readonly XXXLarge: "58.2";
+        readonly Huge: "118";
+        readonly Massive: "237";
+    };
+    /**
+     * Common throttling presets
+     */
+    static readonly ThrottlingPresets: {
+        readonly Light: {
+            readonly burstLimit: 100;
+            readonly rateLimit: 50;
+        };
+        readonly Medium: {
+            readonly burstLimit: 500;
+            readonly rateLimit: 250;
+        };
+        readonly Heavy: {
+            readonly burstLimit: 2000;
+            readonly rateLimit: 1000;
+        };
+        readonly Default: {
+            readonly burstLimit: 5000;
+            readonly rateLimit: 10000;
+        };
+    };
+}