@stacksjs/ts-cloud-core 0.1.3 → 0.1.6

package/src/lambda/concurrency.ts

@@ -1,330 +0,0 @@
-/**
- * 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

@@ -1,345 +0,0 @@
-/**
- * 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()