@ts-cloud/core 0.2.2 → 0.2.4

package/dist/intrinsic-functions.d.ts

@@ -0,0 +1,77 @@
+/**
+ * CloudFormation Intrinsic Functions Helpers
+ */
+export interface IntrinsicFunctions {
+    Ref: (logicalName: string) => {
+        Ref: string;
+    };
+    GetAtt: (logicalName: string, attributeName: string) => {
+        'Fn::GetAtt': [string, string];
+    };
+    Sub: (template: string, variables?: Record<string, any>) => {
+        'Fn::Sub': string | [string, Record<string, any>];
+    };
+    Join: (delimiter: string, values: any[]) => {
+        'Fn::Join': [string, any[]];
+    };
+    Select: (index: number | string, list: any[]) => {
+        'Fn::Select': [number | string, any[]];
+    };
+    Split: (delimiter: string, source: string) => {
+        'Fn::Split': [string, string];
+    };
+    GetAZs: (region?: string) => {
+        'Fn::GetAZs': string;
+    };
+    ImportValue: (name: string) => {
+        'Fn::ImportValue': string;
+    };
+    If: (condition: string, trueValue: any, falseValue: any) => {
+        'Fn::If': [string, any, any];
+    };
+    Equals: (value1: any, value2: any) => {
+        'Fn::Equals': [any, any];
+    };
+    And: (...conditions: any[]) => {
+        'Fn::And': any[];
+    };
+    Or: (...conditions: any[]) => {
+        'Fn::Or': any[];
+    };
+    Not: (condition: any) => {
+        'Fn::Not': [any];
+    };
+    Base64: (input: string) => {
+        'Fn::Base64': string;
+    };
+}
+export declare const Fn: IntrinsicFunctions;
+/**
+ * Pseudo Parameters - AWS CloudFormation provides several built-in parameters
+ */
+export declare const Pseudo: {
+    readonly AccountId: {
+        readonly Ref: "AWS::AccountId";
+    };
+    readonly Region: {
+        readonly Ref: "AWS::Region";
+    };
+    readonly StackId: {
+        readonly Ref: "AWS::StackId";
+    };
+    readonly StackName: {
+        readonly Ref: "AWS::StackName";
+    };
+    readonly NotificationARNs: {
+        readonly Ref: "AWS::NotificationARNs";
+    };
+    readonly Partition: {
+        readonly Ref: "AWS::Partition";
+    };
+    readonly URLSuffix: {
+        readonly Ref: "AWS::URLSuffix";
+    };
+    readonly NoValue: {
+        readonly Ref: "AWS::NoValue";
+    };
+};

package/dist/lambda/concurrency.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Lambda Concurrency Management
+ * Reserved and provisioned concurrency configuration
+ */
+export interface ConcurrencyConfig {
+    id: string;
+    functionName: string;
+    reservedConcurrency?: number;
+    provisionedConcurrency?: ProvisionedConcurrencyConfig[];
+}
+export interface ProvisionedConcurrencyConfig {
+    id: string;
+    functionName: string;
+    qualifier: string;
+    provisionedConcurrentExecutions: number;
+    status: 'pending' | 'ready' | 'in_progress' | 'failed';
+    allocatedConcurrency?: number;
+    availableConcurrency?: number;
+    lastModified?: Date;
+}
+export interface ConcurrencySchedule {
+    id: string;
+    name: string;
+    functionName: string;
+    qualifier: string;
+    schedule: ScheduleRule[];
+}
+export interface ScheduleRule {
+    name: string;
+    cronExpression: string;
+    targetConcurrency: number;
+    minCapacity?: number;
+    maxCapacity?: number;
+}
+export interface AutoScalingConfig {
+    id: string;
+    functionName: string;
+    qualifier: string;
+    minCapacity: number;
+    maxCapacity: number;
+    targetUtilization: number;
+    scaleInCooldown?: number;
+    scaleOutCooldown?: number;
+}
+/**
+ * Lambda concurrency manager
+ */
+export declare class LambdaConcurrencyManager {
+    private configs;
+    private provisionedConfigs;
+    private schedules;
+    private autoScalingConfigs;
+    private configCounter;
+    private provisionedCounter;
+    private scheduleCounter;
+    private autoScalingCounter;
+    /**
+     * Set reserved concurrency
+     */
+    setReservedConcurrency(options: {
+        functionName: string;
+        reservedConcurrency: number;
+    }): ConcurrencyConfig;
+    /**
+     * Set provisioned concurrency
+     */
+    setProvisionedConcurrency(options: {
+        functionName: string;
+        qualifier: string;
+        provisionedConcurrentExecutions: number;
+    }): ProvisionedConcurrencyConfig;
+    /**
+     * Configure warm pool
+     */
+    configureWarmPool(options: {
+        functionName: string;
+        alias: string;
+        minInstances: number;
+    }): ProvisionedConcurrencyConfig;
+    /**
+     * Create concurrency schedule
+     */
+    createSchedule(schedule: Omit<ConcurrencySchedule, 'id'>): ConcurrencySchedule;
+    /**
+     * Create business hours schedule
+     */
+    createBusinessHoursSchedule(options: {
+        functionName: string;
+        qualifier: string;
+        businessHoursConcurrency: number;
+        offHoursConcurrency: number;
+    }): ConcurrencySchedule;
+    /**
+     * Configure auto-scaling
+     */
+    configureAutoScaling(config: Omit<AutoScalingConfig, 'id'>): AutoScalingConfig;
+    /**
+     * Configure predictive auto-scaling
+     */
+    configurePredictiveScaling(options: {
+        functionName: string;
+        qualifier: string;
+        baselineCapacity: number;
+        peakCapacity: number;
+    }): AutoScalingConfig;
+    /**
+     * Get concurrency config
+     */
+    getConfig(id: string): ConcurrencyConfig | undefined;
+    /**
+     * List concurrency configs
+     */
+    listConfigs(): ConcurrencyConfig[];
+    /**
+     * Get provisioned config
+     */
+    getProvisionedConfig(id: string): ProvisionedConcurrencyConfig | undefined;
+    /**
+     * List provisioned configs
+     */
+    listProvisionedConfigs(): ProvisionedConcurrencyConfig[];
+    /**
+     * Generate CloudFormation for reserved concurrency
+     */
+    generateReservedConcurrencyCF(config: ConcurrencyConfig): any;
+    /**
+     * Generate CloudFormation for provisioned concurrency
+     */
+    generateProvisionedConcurrencyCF(config: ProvisionedConcurrencyConfig): any;
+    /**
+     * Generate CloudFormation for auto-scaling target
+     */
+    generateAutoScalingTargetCF(config: AutoScalingConfig): any;
+    /**
+     * Generate CloudFormation for auto-scaling policy
+     */
+    generateAutoScalingPolicyCF(config: AutoScalingConfig): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda concurrency manager instance
+ */
+export declare const lambdaConcurrencyManager: LambdaConcurrencyManager;

package/dist/lambda/destinations.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Lambda Destinations
+ * Asynchronous invocation destinations for success and failure
+ */
+export interface LambdaDestination {
+    id: string;
+    functionName: string;
+    qualifier?: string;
+    successDestination?: DestinationConfig;
+    failureDestination?: DestinationConfig;
+    maxEventAge?: number;
+    maxRetries?: number;
+}
+export interface DestinationConfig {
+    type: 'sqs' | 'sns' | 'eventbridge' | 'lambda';
+    arn: string;
+}
+export interface DestinationRecord {
+    id: string;
+    timestamp: Date;
+    functionName: string;
+    requestId: string;
+    status: 'success' | 'failure';
+    destinationType: 'sqs' | 'sns' | 'eventbridge' | 'lambda';
+    destinationArn: string;
+    payload?: any;
+    error?: string;
+}
+export interface EventBridgeDestination {
+    id: string;
+    functionName: string;
+    eventBusArn: string;
+    detailType: string;
+    source: string;
+}
+/**
+ * Lambda destinations manager
+ */
+export declare class LambdaDestinationsManager {
+    private destinations;
+    private records;
+    private eventBridgeDestinations;
+    private destinationCounter;
+    private recordCounter;
+    private eventBridgeCounter;
+    /**
+     * Configure destinations
+     */
+    configureDestinations(destination: Omit<LambdaDestination, 'id'>): LambdaDestination;
+    /**
+     * Configure SQS destination
+     */
+    configureSQSDestination(options: {
+        functionName: string;
+        queueArn: string;
+        onSuccess?: boolean;
+        onFailure?: boolean;
+    }): LambdaDestination;
+    /**
+     * Configure SNS destination
+     */
+    configureSNSDestination(options: {
+        functionName: string;
+        topicArn: string;
+        onSuccess?: boolean;
+        onFailure?: boolean;
+    }): LambdaDestination;
+    /**
+     * Configure EventBridge destination
+     */
+    configureEventBridgeDestination(options: {
+        functionName: string;
+        eventBusArn: string;
+        onSuccess?: boolean;
+        onFailure?: boolean;
+    }): LambdaDestination;
+    /**
+     * Configure Lambda destination
+     */
+    configureLambdaDestination(options: {
+        functionName: string;
+        destinationFunctionArn: string;
+        onSuccess?: boolean;
+        onFailure?: boolean;
+    }): LambdaDestination;
+    /**
+     * Configure DLQ with SNS destination
+     */
+    configureDLQWithNotification(options: {
+        functionName: string;
+        dlqArn: string;
+        notificationTopicArn: string;
+    }): LambdaDestination;
+    /**
+     * Create EventBridge integration
+     */
+    createEventBridgeIntegration(options: {
+        functionName: string;
+        eventBusArn: string;
+        detailType?: string;
+        source?: string;
+    }): EventBridgeDestination;
+    /**
+     * Simulate sending to destination
+     */
+    sendToDestination(options: {
+        functionName: string;
+        requestId: string;
+        status: 'success' | 'failure';
+        payload?: any;
+        error?: string;
+    }): DestinationRecord | null;
+    /**
+     * Get destination
+     */
+    getDestination(id: string): LambdaDestination | undefined;
+    /**
+     * List destinations
+     */
+    listDestinations(functionName?: string): LambdaDestination[];
+    /**
+     * Get destination records
+     */
+    getDestinationRecords(functionName?: string): DestinationRecord[];
+    /**
+     * Generate CloudFormation for EventSourceMapping with destination
+     */
+    generateEventInvokeConfigCF(destination: LambdaDestination): any;
+    /**
+     * Generate CloudFormation for EventBridge rule
+     */
+    generateEventBridgeRuleCF(destination: EventBridgeDestination): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda destinations manager instance
+ */
+export declare const lambdaDestinationsManager: LambdaDestinationsManager;

package/dist/lambda/dlq.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Lambda Dead Letter Queue (DLQ)
+ * Error handling and failed event management
+ */
+export interface DLQConfig {
+    id: string;
+    functionName: string;
+    targetArn: string;
+    targetType: 'sqs' | 'sns';
+    maxReceiveCount?: number;
+    retentionPeriod?: number;
+}
+export interface DLQMessage {
+    id: string;
+    functionName: string;
+    requestId: string;
+    timestamp: Date;
+    errorMessage: string;
+    errorType: string;
+    stackTrace?: string;
+    payload: any;
+    attemptCount: number;
+}
+export interface DLQAlarm {
+    id: string;
+    dlqConfigId: string;
+    alarmName: string;
+    threshold: number;
+    evaluationPeriods: number;
+    notificationTopicArn?: string;
+    enabled: boolean;
+}
+export interface DLQReprocessing {
+    id: string;
+    dlqConfigId: string;
+    messageId: string;
+    status: 'pending' | 'processing' | 'success' | 'failed';
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+}
+/**
+ * Lambda DLQ manager
+ */
+export declare class LambdaDLQManager {
+    private dlqConfigs;
+    private messages;
+    private alarms;
+    private reprocessing;
+    private configCounter;
+    private messageCounter;
+    private alarmCounter;
+    private reprocessCounter;
+    /**
+     * Configure DLQ
+     */
+    configureDLQ(config: Omit<DLQConfig, 'id'>): DLQConfig;
+    /**
+     * Configure SQS DLQ
+     */
+    configureSQSDLQ(options: {
+        functionName: string;
+        queueArn: string;
+        maxReceiveCount?: number;
+        retentionPeriod?: number;
+    }): DLQConfig;
+    /**
+     * Configure SNS DLQ
+     */
+    configureSNSDLQ(options: {
+        functionName: string;
+        topicArn: string;
+    }): DLQConfig;
+    /**
+     * Configure DLQ with alarm
+     */
+    configureDLQWithAlarm(options: {
+        functionName: string;
+        queueArn: string;
+        alarmThreshold: number;
+        notificationTopicArn: string;
+    }): DLQConfig;
+    /**
+     * Send message to DLQ
+     */
+    sendToDLQ(options: {
+        functionName: string;
+        requestId: string;
+        errorMessage: string;
+        errorType: string;
+        stackTrace?: string;
+        payload: any;
+        attemptCount: number;
+    }): DLQMessage;
+    /**
+     * Create DLQ alarm
+     */
+    createDLQAlarm(alarm: Omit<DLQAlarm, 'id'>): DLQAlarm;
+    /**
+     * Create age alarm
+     */
+    createAgeAlarm(options: {
+        dlqConfigId: string;
+        maxAgeSeconds: number;
+        notificationTopicArn: string;
+    }): DLQAlarm;
+    /**
+     * Reprocess DLQ message
+     */
+    reprocessMessage(messageId: string): Promise<DLQReprocessing>;
+    /**
+     * Batch reprocess messages
+     */
+    batchReprocess(options: {
+        dlqConfigId: string;
+        maxMessages?: number;
+    }): Promise<DLQReprocessing[]>;
+    /**
+     * Get DLQ statistics
+     */
+    getDLQStats(dlqConfigId: string): {
+        totalMessages: number;
+        oldestMessage?: Date;
+        newestMessage?: Date;
+        averageAttempts: number;
+        errorTypes: Record<string, number>;
+    };
+    /**
+     * Get DLQ config
+     */
+    getDLQConfig(id: string): DLQConfig | undefined;
+    /**
+     * List DLQ configs
+     */
+    listDLQConfigs(): DLQConfig[];
+    /**
+     * Get DLQ messages
+     */
+    getDLQMessages(dlqConfigId: string): DLQMessage[];
+    /**
+     * Generate CloudFormation for DLQ
+     */
+    generateDLQCF(config: DLQConfig): any;
+    /**
+     * Generate CloudFormation for SQS DLQ
+     */
+    generateSQSDLQCF(config: DLQConfig): any;
+    /**
+     * Generate CloudFormation for DLQ alarm
+     */
+    generateDLQAlarmCF(alarm: DLQAlarm): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda DLQ manager instance
+ */
+export declare const lambdaDLQManager: LambdaDLQManager;

package/dist/lambda/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lambda Advanced Features
+ * Layers, versions, concurrency, destinations, VPC, and DLQ
+ */
+export * from './layers';
+export * from './versions';
+export * from './concurrency';
+export * from './destinations';
+export * from './vpc';
+export * from './dlq';

package/dist/lambda/lambda.test.d.ts

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

package/dist/lambda/layers.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Lambda Layers Management
+ * Reusable code and dependencies for Lambda functions
+ */
+export interface LambdaLayer {
+    id: string;
+    layerName: string;
+    layerArn: string;
+    version: number;
+    description?: string;
+    compatibleRuntimes: string[];
+    licenseInfo?: string;
+    content: LayerContent;
+    size: number;
+}
+export interface LayerContent {
+    type: 's3' | 'zip';
+    s3Bucket?: string;
+    s3Key?: string;
+    s3ObjectVersion?: string;
+    zipFile?: string;
+}
+export interface LayerVersion {
+    id: string;
+    layerName: string;
+    version: number;
+    createdAt: Date;
+    compatibleRuntimes: string[];
+    size: number;
+    codeHash: string;
+}
+export interface LayerPermission {
+    id: string;
+    layerName: string;
+    version: number;
+    principal: string;
+    action: 'lambda:GetLayerVersion';
+    organizationId?: string;
+}
+/**
+ * Lambda layers manager
+ */
+export declare class LambdaLayersManager {
+    private layers;
+    private versions;
+    private permissions;
+    private layerCounter;
+    private versionCounter;
+    private permissionCounter;
+    /**
+     * Create Lambda layer
+     */
+    createLayer(layer: Omit<LambdaLayer, 'id' | 'layerArn' | 'version'>): LambdaLayer;
+    /**
+     * Create Node.js dependencies layer
+     */
+    createNodeDependenciesLayer(options: {
+        layerName: string;
+        nodeVersion: string;
+        s3Bucket: string;
+        s3Key: string;
+    }): LambdaLayer;
+    /**
+     * Create shared utilities layer
+     */
+    createUtilitiesLayer(options: {
+        layerName: string;
+        runtimes: string[];
+        s3Bucket: string;
+        s3Key: string;
+    }): LambdaLayer;
+    /**
+     * Publish layer version
+     */
+    publishVersion(layerId: string): LayerVersion;
+    /**
+     * Add layer permission
+     */
+    addPermission(options: {
+        layerName: string;
+        version: number;
+        principal: string;
+        organizationId?: string;
+    }): LayerPermission;
+    /**
+     * Generate hash
+     */
+    private generateHash;
+    /**
+     * Get layer
+     */
+    getLayer(id: string): LambdaLayer | undefined;
+    /**
+     * List layers
+     */
+    listLayers(): LambdaLayer[];
+    /**
+     * Get layer versions
+     */
+    getLayerVersions(layerName: string): LayerVersion[];
+    /**
+     * Generate CloudFormation for layer
+     */
+    generateLayerCF(layer: LambdaLayer): any;
+    /**
+     * Generate CloudFormation for layer permission
+     */
+    generateLayerPermissionCF(permission: LayerPermission): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global Lambda layers manager instance
+ */
+export declare const lambdaLayersManager: LambdaLayersManager;