@stacksjs/ts-cloud-core 0.1.3 → 0.1.6

package/src/lambda/layers.ts

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

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