@stacksjs/ts-cloud-core 0.1.1

package/src/lambda/layers.ts

@@ -0,0 +1,263 @@
+/**
+ * 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 // bytes
+}
+
+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 class LambdaLayersManager {
+  private layers: Map<string, LambdaLayer> = new Map()
+  private versions: Map<string, LayerVersion> = new Map()
+  private permissions: Map<string, LayerPermission> = new Map()
+  private layerCounter = 0
+  private versionCounter = 0
+  private permissionCounter = 0
+
+  /**
+   * Create Lambda layer
+   */
+  createLayer(layer: Omit<LambdaLayer, 'id' | 'layerArn' | 'version'>): LambdaLayer {
+    const id = `layer-${Date.now()}-${this.layerCounter++}`
+    const version = 1
+
+    const lambdaLayer: LambdaLayer = {
+      id,
+      layerArn: `arn:aws:lambda:us-east-1:123456789012:layer:${layer.layerName}:${version}`,
+      version,
+      ...layer,
+    }
+
+    this.layers.set(id, lambdaLayer)
+
+    return lambdaLayer
+  }
+
+  /**
+   * Create Node.js dependencies layer
+   */
+  createNodeDependenciesLayer(options: {
+    layerName: string
+    nodeVersion: string
+    s3Bucket: string
+    s3Key: string
+  }): LambdaLayer {
+    return this.createLayer({
+      layerName: options.layerName,
+      description: 'Node.js dependencies layer',
+      compatibleRuntimes: [`nodejs${options.nodeVersion}`],
+      content: {
+        type: 's3',
+        s3Bucket: options.s3Bucket,
+        s3Key: options.s3Key,
+      },
+      size: 5 * 1024 * 1024, // 5MB
+    })
+  }
+
+  /**
+   * Create shared utilities layer
+   */
+  createUtilitiesLayer(options: {
+    layerName: string
+    runtimes: string[]
+    s3Bucket: string
+    s3Key: string
+  }): LambdaLayer {
+    return this.createLayer({
+      layerName: options.layerName,
+      description: 'Shared utilities and helpers',
+      compatibleRuntimes: options.runtimes,
+      content: {
+        type: 's3',
+        s3Bucket: options.s3Bucket,
+        s3Key: options.s3Key,
+      },
+      size: 1 * 1024 * 1024, // 1MB
+    })
+  }
+
+  /**
+   * Publish layer version
+   */
+  publishVersion(layerId: string): LayerVersion {
+    const layer = this.layers.get(layerId)
+
+    if (!layer) {
+      throw new Error(`Layer not found: ${layerId}`)
+    }
+
+    const id = `version-${Date.now()}-${this.versionCounter++}`
+    const version = layer.version + 1
+
+    const layerVersion: LayerVersion = {
+      id,
+      layerName: layer.layerName,
+      version,
+      createdAt: new Date(),
+      compatibleRuntimes: layer.compatibleRuntimes,
+      size: layer.size,
+      codeHash: this.generateHash(),
+    }
+
+    this.versions.set(id, layerVersion)
+
+    // Update layer version
+    layer.version = version
+    layer.layerArn = `arn:aws:lambda:us-east-1:123456789012:layer:${layer.layerName}:${version}`
+
+    return layerVersion
+  }
+
+  /**
+   * Add layer permission
+   */
+  addPermission(options: {
+    layerName: string
+    version: number
+    principal: string
+    organizationId?: string
+  }): LayerPermission {
+    const id = `permission-${Date.now()}-${this.permissionCounter++}`
+
+    const permission: LayerPermission = {
+      id,
+      layerName: options.layerName,
+      version: options.version,
+      principal: options.principal,
+      action: 'lambda:GetLayerVersion',
+      organizationId: options.organizationId,
+    }
+
+    this.permissions.set(id, permission)
+
+    return permission
+  }
+
+  /**
+   * Generate hash
+   */
+  private generateHash(): string {
+    return Math.random().toString(36).substring(2, 15)
+  }
+
+  /**
+   * Get layer
+   */
+  getLayer(id: string): LambdaLayer | undefined {
+    return this.layers.get(id)
+  }
+
+  /**
+   * List layers
+   */
+  listLayers(): LambdaLayer[] {
+    return Array.from(this.layers.values())
+  }
+
+  /**
+   * Get layer versions
+   */
+  getLayerVersions(layerName: string): LayerVersion[] {
+    return Array.from(this.versions.values()).filter(v => v.layerName === layerName)
+  }
+
+  /**
+   * Generate CloudFormation for layer
+   */
+  generateLayerCF(layer: LambdaLayer): any {
+    return {
+      Type: 'AWS::Lambda::LayerVersion',
+      Properties: {
+        LayerName: layer.layerName,
+        Description: layer.description,
+        Content: layer.content.type === 's3'
+          ? {
+              S3Bucket: layer.content.s3Bucket,
+              S3Key: layer.content.s3Key,
+              ...(layer.content.s3ObjectVersion && {
+                S3ObjectVersion: layer.content.s3ObjectVersion,
+              }),
+            }
+          : {
+              ZipFile: layer.content.zipFile,
+            },
+        CompatibleRuntimes: layer.compatibleRuntimes,
+        ...(layer.licenseInfo && { LicenseInfo: layer.licenseInfo }),
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for layer permission
+   */
+  generateLayerPermissionCF(permission: LayerPermission): any {
+    return {
+      Type: 'AWS::Lambda::LayerVersionPermission',
+      Properties: {
+        LayerVersionArn: `arn:aws:lambda:us-east-1:123456789012:layer:${permission.layerName}:${permission.version}`,
+        Action: permission.action,
+        Principal: permission.principal,
+        ...(permission.organizationId && {
+          OrganizationId: permission.organizationId,
+        }),
+      },
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.layers.clear()
+    this.versions.clear()
+    this.permissions.clear()
+    this.layerCounter = 0
+    this.versionCounter = 0
+    this.permissionCounter = 0
+  }
+}
+
+/**
+ * Global Lambda layers manager instance
+ */
+export const lambdaLayersManager: LambdaLayersManager = new LambdaLayersManager()

package/src/lambda/versions.ts

@@ -0,0 +1,376 @@
+/**
+ * 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 class LambdaVersionsManager {
+  private versions: Map<string, LambdaVersion> = new Map()
+  private aliases: Map<string, LambdaAlias> = new Map()
+  private deployments: Map<string, VersionDeployment> = new Map()
+  private versionCounter = 0
+  private aliasCounter = 0
+  private deploymentCounter = 0
+
+  /**
+   * Publish function version
+   */
+  publishVersion(options: {
+    functionName: string
+    description?: string
+    runtime: string
+    memorySize: number
+    timeout: number
+  }): LambdaVersion {
+    const id = `version-${Date.now()}-${this.versionCounter++}`
+    const versionNumber = this.getNextVersionNumber(options.functionName)
+
+    const version: LambdaVersion = {
+      id,
+      functionName: options.functionName,
+      version: versionNumber.toString(),
+      functionArn: `arn:aws:lambda:us-east-1:123456789012:function:${options.functionName}:${versionNumber}`,
+      codeHash: this.generateHash(),
+      description: options.description,
+      runtime: options.runtime,
+      memorySize: options.memorySize,
+      timeout: options.timeout,
+      publishedAt: new Date(),
+    }
+
+    this.versions.set(id, version)
+
+    return version
+  }
+
+  /**
+   * Get next version number
+   */
+  private getNextVersionNumber(functionName: string): number {
+    const existingVersions = Array.from(this.versions.values())
+      .filter(v => v.functionName === functionName)
+      .map(v => parseInt(v.version))
+
+    return existingVersions.length > 0 ? Math.max(...existingVersions) + 1 : 1
+  }
+
+  /**
+   * Create alias
+   */
+  createAlias(alias: Omit<LambdaAlias, 'id' | 'aliasArn' | 'revisionId'>): LambdaAlias {
+    const id = `alias-${Date.now()}-${this.aliasCounter++}`
+
+    const lambdaAlias: LambdaAlias = {
+      id,
+      aliasArn: `arn:aws:lambda:us-east-1:123456789012:function:${alias.functionName}:${alias.aliasName}`,
+      revisionId: this.generateHash(),
+      ...alias,
+    }
+
+    this.aliases.set(id, lambdaAlias)
+
+    return lambdaAlias
+  }
+
+  /**
+   * Create production alias
+   */
+  createProductionAlias(options: {
+    functionName: string
+    version: string
+  }): LambdaAlias {
+    return this.createAlias({
+      functionName: options.functionName,
+      aliasName: 'production',
+      functionVersion: options.version,
+      description: 'Production alias',
+    })
+  }
+
+  /**
+   * Create staging alias
+   */
+  createStagingAlias(options: {
+    functionName: string
+    version: string
+  }): LambdaAlias {
+    return this.createAlias({
+      functionName: options.functionName,
+      aliasName: 'staging',
+      functionVersion: options.version,
+      description: 'Staging alias',
+    })
+  }
+
+  /**
+   * Update alias
+   */
+  updateAlias(aliasId: string, newVersion: string): LambdaAlias {
+    const alias = this.aliases.get(aliasId)
+
+    if (!alias) {
+      throw new Error(`Alias not found: ${aliasId}`)
+    }
+
+    alias.functionVersion = newVersion
+    alias.revisionId = this.generateHash()
+
+    return alias
+  }
+
+  /**
+   * Configure weighted routing
+   */
+  configureWeightedRouting(
+    aliasId: string,
+    weights: Record<string, number>
+  ): LambdaAlias {
+    const alias = this.aliases.get(aliasId)
+
+    if (!alias) {
+      throw new Error(`Alias not found: ${aliasId}`)
+    }
+
+    alias.routingConfig = {
+      additionalVersionWeights: weights,
+    }
+
+    return alias
+  }
+
+  /**
+   * Create canary deployment
+   */
+  createCanaryDeployment(options: {
+    functionName: string
+    fromVersion: string
+    toVersion: string
+    aliasName: string
+    canaryWeight: number
+  }): VersionDeployment {
+    const id = `deployment-${Date.now()}-${this.deploymentCounter++}`
+
+    // Find or create alias
+    let alias = Array.from(this.aliases.values()).find(
+      a => a.functionName === options.functionName && a.aliasName === options.aliasName
+    )
+
+    if (!alias) {
+      alias = this.createAlias({
+        functionName: options.functionName,
+        aliasName: options.aliasName,
+        functionVersion: options.fromVersion,
+      })
+    }
+
+    // Configure weighted routing
+    this.configureWeightedRouting(alias.id, {
+      [options.toVersion]: options.canaryWeight,
+    })
+
+    const deployment: VersionDeployment = {
+      id,
+      functionName: options.functionName,
+      fromVersion: options.fromVersion,
+      toVersion: options.toVersion,
+      aliasName: options.aliasName,
+      strategy: 'canary',
+      status: 'in_progress',
+      startedAt: new Date(),
+    }
+
+    this.deployments.set(id, deployment)
+
+    return deployment
+  }
+
+  /**
+   * Complete deployment
+   */
+  completeDeployment(deploymentId: string): VersionDeployment {
+    const deployment = this.deployments.get(deploymentId)
+
+    if (!deployment) {
+      throw new Error(`Deployment not found: ${deploymentId}`)
+    }
+
+    // Update alias to point to new version
+    const alias = Array.from(this.aliases.values()).find(
+      a =>
+        a.functionName === deployment.functionName &&
+        a.aliasName === deployment.aliasName
+    )
+
+    if (alias) {
+      alias.functionVersion = deployment.toVersion
+      alias.routingConfig = undefined // Remove weighted routing
+    }
+
+    deployment.status = 'completed'
+    deployment.completedAt = new Date()
+
+    return deployment
+  }
+
+  /**
+   * Rollback deployment
+   */
+  rollbackDeployment(deploymentId: string): VersionDeployment {
+    const deployment = this.deployments.get(deploymentId)
+
+    if (!deployment) {
+      throw new Error(`Deployment not found: ${deploymentId}`)
+    }
+
+    // Revert alias to previous version
+    const alias = Array.from(this.aliases.values()).find(
+      a =>
+        a.functionName === deployment.functionName &&
+        a.aliasName === deployment.aliasName
+    )
+
+    if (alias) {
+      alias.functionVersion = deployment.fromVersion
+      alias.routingConfig = undefined
+    }
+
+    deployment.status = 'failed'
+    deployment.completedAt = new Date()
+
+    return deployment
+  }
+
+  /**
+   * Generate hash
+   */
+  private generateHash(): string {
+    return Math.random().toString(36).substring(2, 15)
+  }
+
+  /**
+   * Get version
+   */
+  getVersion(id: string): LambdaVersion | undefined {
+    return this.versions.get(id)
+  }
+
+  /**
+   * List versions
+   */
+  listVersions(functionName?: string): LambdaVersion[] {
+    const versions = Array.from(this.versions.values())
+    return functionName ? versions.filter(v => v.functionName === functionName) : versions
+  }
+
+  /**
+   * Get alias
+   */
+  getAlias(id: string): LambdaAlias | undefined {
+    return this.aliases.get(id)
+  }
+
+  /**
+   * List aliases
+   */
+  listAliases(functionName?: string): LambdaAlias[] {
+    const aliases = Array.from(this.aliases.values())
+    return functionName ? aliases.filter(a => a.functionName === functionName) : aliases
+  }
+
+  /**
+   * Generate CloudFormation for version
+   */
+  generateVersionCF(version: LambdaVersion): any {
+    return {
+      Type: 'AWS::Lambda::Version',
+      Properties: {
+        FunctionName: version.functionName,
+        Description: version.description,
+      },
+    }
+  }
+
+  /**
+   * Generate CloudFormation for alias
+   */
+  generateAliasCF(alias: LambdaAlias): any {
+    return {
+      Type: 'AWS::Lambda::Alias',
+      Properties: {
+        FunctionName: alias.functionName,
+        Name: alias.aliasName,
+        FunctionVersion: alias.functionVersion,
+        Description: alias.description,
+        ...(alias.routingConfig && {
+          RoutingConfig: {
+            AdditionalVersionWeights: Object.entries(
+              alias.routingConfig.additionalVersionWeights || {}
+            ).map(([version, weight]) => ({
+              FunctionVersion: version,
+              FunctionWeight: weight,
+            })),
+          },
+        }),
+      },
+    }
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.versions.clear()
+    this.aliases.clear()
+    this.deployments.clear()
+    this.versionCounter = 0
+    this.aliasCounter = 0
+    this.deploymentCounter = 0
+  }
+}
+
+/**
+ * Global Lambda versions manager instance
+ */
+export const lambdaVersionsManager: LambdaVersionsManager = new LambdaVersionsManager()