@stacksjs/ts-cloud-core 0.1.1

package/src/lambda/concurrency.ts

@@ -0,0 +1,330 @@
+/**
+ * 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 // version or alias
+  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 // 0-1
+  scaleInCooldown?: number // seconds
+  scaleOutCooldown?: number // seconds
+}
+
+/**
+ * Lambda concurrency manager
+ */
+export class LambdaConcurrencyManager {
+  private configs: Map<string, ConcurrencyConfig> = new Map()
+  private provisionedConfigs: Map<string, ProvisionedConcurrencyConfig> = new Map()
+  private schedules: Map<string, ConcurrencySchedule> = new Map()
+  private autoScalingConfigs: Map<string, AutoScalingConfig> = new Map()
+  private configCounter = 0
+  private provisionedCounter = 0
+  private scheduleCounter = 0
+  private autoScalingCounter = 0
+
+  /**
+   * Set reserved concurrency
+   */
+  setReservedConcurrency(options: {
+    functionName: string
+    reservedConcurrency: number
+  }): ConcurrencyConfig {
+    const id = `concurrency-${Date.now()}-${this.configCounter++}`
+
+    const config: ConcurrencyConfig = {
+      id,
+      functionName: options.functionName,
+      reservedConcurrency: options.reservedConcurrency,
+    }
+
+    this.configs.set(id, config)
+
+    return config
+  }
+
+  /**
+   * Set provisioned concurrency
+   */
+  setProvisionedConcurrency(options: {
+    functionName: string
+    qualifier: string
+    provisionedConcurrentExecutions: number
+  }): ProvisionedConcurrencyConfig {
+    const id = `provisioned-${Date.now()}-${this.provisionedCounter++}`
+
+    const config: ProvisionedConcurrencyConfig = {
+      id,
+      functionName: options.functionName,
+      qualifier: options.qualifier,
+      provisionedConcurrentExecutions: options.provisionedConcurrentExecutions,
+      status: 'pending',
+      lastModified: new Date(),
+    }
+
+    this.provisionedConfigs.set(id, config)
+
+    // Simulate provisioning
+    setTimeout(() => {
+      config.status = 'ready'
+      config.allocatedConcurrency = options.provisionedConcurrentExecutions
+      config.availableConcurrency = options.provisionedConcurrentExecutions
+    }, 100)
+
+    return config
+  }
+
+  /**
+   * Configure warm pool
+   */
+  configureWarmPool(options: {
+    functionName: string
+    alias: string
+    minInstances: number
+  }): ProvisionedConcurrencyConfig {
+    return this.setProvisionedConcurrency({
+      functionName: options.functionName,
+      qualifier: options.alias,
+      provisionedConcurrentExecutions: options.minInstances,
+    })
+  }
+
+  /**
+   * Create concurrency schedule
+   */
+  createSchedule(schedule: Omit<ConcurrencySchedule, 'id'>): ConcurrencySchedule {
+    const id = `schedule-${Date.now()}-${this.scheduleCounter++}`
+
+    const concurrencySchedule: ConcurrencySchedule = {
+      id,
+      ...schedule,
+    }
+
+    this.schedules.set(id, concurrencySchedule)
+
+    return concurrencySchedule
+  }
+
+  /**
+   * Create business hours schedule
+   */
+  createBusinessHoursSchedule(options: {
+    functionName: string
+    qualifier: string
+    businessHoursConcurrency: number
+    offHoursConcurrency: number
+  }): ConcurrencySchedule {
+    return this.createSchedule({
+      name: `${options.functionName}-business-hours`,
+      functionName: options.functionName,
+      qualifier: options.qualifier,
+      schedule: [
+        {
+          name: 'business-hours',
+          cronExpression: '0 8 * * MON-FRI', // 8 AM weekdays
+          targetConcurrency: options.businessHoursConcurrency,
+        },
+        {
+          name: 'off-hours',
+          cronExpression: '0 18 * * MON-FRI', // 6 PM weekdays
+          targetConcurrency: options.offHoursConcurrency,
+        },
+        {
+          name: 'weekend',
+          cronExpression: '0 0 * * SAT', // Midnight Saturday
+          targetConcurrency: options.offHoursConcurrency,
+        },
+      ],
+    })
+  }
+
+  /**
+   * Configure auto-scaling
+   */
+  configureAutoScaling(config: Omit<AutoScalingConfig, 'id'>): AutoScalingConfig {
+    const id = `autoscaling-${Date.now()}-${this.autoScalingCounter++}`
+
+    const autoScalingConfig: AutoScalingConfig = {
+      id,
+      ...config,
+    }
+
+    this.autoScalingConfigs.set(id, autoScalingConfig)
+
+    return autoScalingConfig
+  }
+
+  /**
+   * Configure predictive auto-scaling
+   */
+  configurePredictiveScaling(options: {
+    functionName: string
+    qualifier: string
+    baselineCapacity: number
+    peakCapacity: number
+  }): AutoScalingConfig {
+    return this.configureAutoScaling({
+      functionName: options.functionName,
+      qualifier: options.qualifier,
+      minCapacity: options.baselineCapacity,
+      maxCapacity: options.peakCapacity,
+      targetUtilization: 0.7,
+      scaleInCooldown: 300,
+      scaleOutCooldown: 60,
+    })
+  }
+
+  /**
+   * Get concurrency config
+   */
+  getConfig(id: string): ConcurrencyConfig | undefined {
+    return this.configs.get(id)
+  }
+
+  /**
+   * List concurrency configs
+   */
+  listConfigs(): ConcurrencyConfig[] {
+    return Array.from(this.configs.values())
+  }
+
+  /**
+   * Get provisioned config
+   */
+  getProvisionedConfig(id: string): ProvisionedConcurrencyConfig | undefined {
+    return this.provisionedConfigs.get(id)
+  }
+
+  /**
+   * List provisioned configs
+   */
+  listProvisionedConfigs(): ProvisionedConcurrencyConfig[] {
+    return Array.from(this.provisionedConfigs.values())
+  }
+
+  /**
+   * Generate CloudFormation for reserved concurrency
+   */
+  generateReservedConcurrencyCF(config: ConcurrencyConfig): any {
+    return {
+      Type: 'AWS::Lambda::Function',
+      Properties: {
+        FunctionName: config.functionName,
+        ReservedConcurrentExecutions: config.reservedConcurrency,
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for provisioned concurrency
+   */
+  generateProvisionedConcurrencyCF(config: ProvisionedConcurrencyConfig): any {
+    return {
+      Type: 'AWS::Lambda::Alias',
+      Properties: {
+        FunctionName: config.functionName,
+        Name: config.qualifier,
+        ProvisionedConcurrencyConfig: {
+          ProvisionedConcurrentExecutions: config.provisionedConcurrentExecutions,
+        },
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for auto-scaling target
+   */
+  generateAutoScalingTargetCF(config: AutoScalingConfig): any {
+    return {
+      Type: 'AWS::ApplicationAutoScaling::ScalableTarget',
+      Properties: {
+        ServiceNamespace: 'lambda',
+        ResourceId: `function:${config.functionName}:${config.qualifier}`,
+        ScalableDimension: 'lambda:function:ProvisionedConcurrentExecutions',
+        MinCapacity: config.minCapacity,
+        MaxCapacity: config.maxCapacity,
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for auto-scaling policy
+   */
+  generateAutoScalingPolicyCF(config: AutoScalingConfig): any {
+    return {
+      Type: 'AWS::ApplicationAutoScaling::ScalingPolicy',
+      Properties: {
+        PolicyName: `${config.functionName}-autoscaling`,
+        PolicyType: 'TargetTrackingScaling',
+        ScalingTargetId: {
+          Ref: `${config.functionName}AutoScalingTarget`,
+        },
+        TargetTrackingScalingPolicyConfiguration: {
+          TargetValue: config.targetUtilization * 100,
+          PredefinedMetricSpecification: {
+            PredefinedMetricType: 'LambdaProvisionedConcurrencyUtilization',
+          },
+          ScaleInCooldown: config.scaleInCooldown || 300,
+          ScaleOutCooldown: config.scaleOutCooldown || 60,
+        },
+      },
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.configs.clear()
+    this.provisionedConfigs.clear()
+    this.schedules.clear()
+    this.autoScalingConfigs.clear()
+    this.configCounter = 0
+    this.provisionedCounter = 0
+    this.scheduleCounter = 0
+    this.autoScalingCounter = 0
+  }
+}
+
+/**
+ * Global Lambda concurrency manager instance
+ */
+export const lambdaConcurrencyManager: LambdaConcurrencyManager = new LambdaConcurrencyManager()

package/src/lambda/destinations.ts

@@ -0,0 +1,345 @@
+/**
+ * Lambda Destinations
+ * Asynchronous invocation destinations for success and failure
+ */
+
+export interface LambdaDestination {
+  id: string
+  functionName: string
+  qualifier?: string
+  successDestination?: DestinationConfig
+  failureDestination?: DestinationConfig
+  maxEventAge?: number // seconds
+  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 class LambdaDestinationsManager {
+  private destinations: Map<string, LambdaDestination> = new Map()
+  private records: Map<string, DestinationRecord> = new Map()
+  private eventBridgeDestinations: Map<string, EventBridgeDestination> = new Map()
+  private destinationCounter = 0
+  private recordCounter = 0
+  private eventBridgeCounter = 0
+
+  /**
+   * Configure destinations
+   */
+  configureDestinations(destination: Omit<LambdaDestination, 'id'>): LambdaDestination {
+    const id = `destination-${Date.now()}-${this.destinationCounter++}`
+
+    const lambdaDestination: LambdaDestination = {
+      id,
+      ...destination,
+    }
+
+    this.destinations.set(id, lambdaDestination)
+
+    return lambdaDestination
+  }
+
+  /**
+   * Configure SQS destination
+   */
+  configureSQSDestination(options: {
+    functionName: string
+    queueArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination {
+    const destinationConfig: DestinationConfig = {
+      type: 'sqs',
+      arn: options.queueArn,
+    }
+
+    return this.configureDestinations({
+      functionName: options.functionName,
+      successDestination: options.onSuccess ? destinationConfig : undefined,
+      failureDestination: options.onFailure ? destinationConfig : undefined,
+      maxEventAge: 21600, // 6 hours
+      maxRetries: 2,
+    })
+  }
+
+  /**
+   * Configure SNS destination
+   */
+  configureSNSDestination(options: {
+    functionName: string
+    topicArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination {
+    const destinationConfig: DestinationConfig = {
+      type: 'sns',
+      arn: options.topicArn,
+    }
+
+    return this.configureDestinations({
+      functionName: options.functionName,
+      successDestination: options.onSuccess ? destinationConfig : undefined,
+      failureDestination: options.onFailure ? destinationConfig : undefined,
+      maxEventAge: 21600,
+      maxRetries: 2,
+    })
+  }
+
+  /**
+   * Configure EventBridge destination
+   */
+  configureEventBridgeDestination(options: {
+    functionName: string
+    eventBusArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination {
+    const destinationConfig: DestinationConfig = {
+      type: 'eventbridge',
+      arn: options.eventBusArn,
+    }
+
+    return this.configureDestinations({
+      functionName: options.functionName,
+      successDestination: options.onSuccess ? destinationConfig : undefined,
+      failureDestination: options.onFailure ? destinationConfig : undefined,
+      maxEventAge: 21600,
+      maxRetries: 2,
+    })
+  }
+
+  /**
+   * Configure Lambda destination
+   */
+  configureLambdaDestination(options: {
+    functionName: string
+    destinationFunctionArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination {
+    const destinationConfig: DestinationConfig = {
+      type: 'lambda',
+      arn: options.destinationFunctionArn,
+    }
+
+    return this.configureDestinations({
+      functionName: options.functionName,
+      successDestination: options.onSuccess ? destinationConfig : undefined,
+      failureDestination: options.onFailure ? destinationConfig : undefined,
+      maxEventAge: 21600,
+      maxRetries: 2,
+    })
+  }
+
+  /**
+   * Configure DLQ with SNS destination
+   */
+  configureDLQWithNotification(options: {
+    functionName: string
+    dlqArn: string
+    notificationTopicArn: string
+  }): LambdaDestination {
+    return this.configureDestinations({
+      functionName: options.functionName,
+      failureDestination: {
+        type: 'sqs',
+        arn: options.dlqArn,
+      },
+      maxEventAge: 3600, // 1 hour for DLQ
+      maxRetries: 0, // No retries, go straight to DLQ
+    })
+  }
+
+  /**
+   * Create EventBridge integration
+   */
+  createEventBridgeIntegration(options: {
+    functionName: string
+    eventBusArn: string
+    detailType?: string
+    source?: string
+  }): EventBridgeDestination {
+    const id = `eventbridge-${Date.now()}-${this.eventBridgeCounter++}`
+
+    const destination: EventBridgeDestination = {
+      id,
+      functionName: options.functionName,
+      eventBusArn: options.eventBusArn,
+      detailType: options.detailType || 'Lambda Function Invocation Result',
+      source: options.source || `lambda.${options.functionName}`,
+    }
+
+    this.eventBridgeDestinations.set(id, destination)
+
+    return destination
+  }
+
+  /**
+   * Simulate sending to destination
+   */
+  sendToDestination(options: {
+    functionName: string
+    requestId: string
+    status: 'success' | 'failure'
+    payload?: any
+    error?: string
+  }): DestinationRecord | null {
+    // Find destination config
+    const destination = Array.from(this.destinations.values()).find(
+      d => d.functionName === options.functionName
+    )
+
+    if (!destination) {
+      return null
+    }
+
+    const destinationConfig =
+      options.status === 'success'
+        ? destination.successDestination
+        : destination.failureDestination
+
+    if (!destinationConfig) {
+      return null
+    }
+
+    const id = `record-${Date.now()}-${this.recordCounter++}`
+
+    const record: DestinationRecord = {
+      id,
+      timestamp: new Date(),
+      functionName: options.functionName,
+      requestId: options.requestId,
+      status: options.status,
+      destinationType: destinationConfig.type,
+      destinationArn: destinationConfig.arn,
+      payload: options.payload,
+      error: options.error,
+    }
+
+    this.records.set(id, record)
+
+    return record
+  }
+
+  /**
+   * Get destination
+   */
+  getDestination(id: string): LambdaDestination | undefined {
+    return this.destinations.get(id)
+  }
+
+  /**
+   * List destinations
+   */
+  listDestinations(functionName?: string): LambdaDestination[] {
+    const destinations = Array.from(this.destinations.values())
+    return functionName
+      ? destinations.filter(d => d.functionName === functionName)
+      : destinations
+  }
+
+  /**
+   * Get destination records
+   */
+  getDestinationRecords(functionName?: string): DestinationRecord[] {
+    const records = Array.from(this.records.values())
+    return functionName
+      ? records.filter(r => r.functionName === functionName)
+      : records
+  }
+
+  /**
+   * Generate CloudFormation for EventSourceMapping with destination
+   */
+  generateEventInvokeConfigCF(destination: LambdaDestination): any {
+    return {
+      Type: 'AWS::Lambda::EventInvokeConfig',
+      Properties: {
+        FunctionName: destination.functionName,
+        Qualifier: destination.qualifier || '$LATEST',
+        MaximumEventAgeInSeconds: destination.maxEventAge || 21600,
+        MaximumRetryAttempts: destination.maxRetries ?? 2,
+        ...(destination.successDestination && {
+          DestinationConfig: {
+            OnSuccess: {
+              Destination: destination.successDestination.arn,
+            },
+          },
+        }),
+        ...(destination.failureDestination && {
+          DestinationConfig: {
+            OnFailure: {
+              Destination: destination.failureDestination.arn,
+            },
+          },
+        }),
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for EventBridge rule
+   */
+  generateEventBridgeRuleCF(destination: EventBridgeDestination): any {
+    return {
+      Type: 'AWS::Events::Rule',
+      Properties: {
+        EventBusName: destination.eventBusArn.split('/').pop(),
+        EventPattern: {
+          source: [destination.source],
+          'detail-type': [destination.detailType],
+        },
+        State: 'ENABLED',
+        Targets: [
+          {
+            Arn: `arn:aws:lambda:us-east-1:123456789012:function:${destination.functionName}`,
+            Id: destination.id,
+          },
+        ],
+      },
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.destinations.clear()
+    this.records.clear()
+    this.eventBridgeDestinations.clear()
+    this.destinationCounter = 0
+    this.recordCounter = 0
+    this.eventBridgeCounter = 0
+  }
+}
+
+/**
+ * Global Lambda destinations manager instance
+ */
+export const lambdaDestinationsManager: LambdaDestinationsManager = new LambdaDestinationsManager()