@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/intrinsic-functions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CloudFormation Intrinsic Functions Helpers
+ */
+export declare const Fn: ({
+  /**
+   * Ref - Returns the value of the specified parameter or resource
+   */
+  Ref: (logicalName: string)) => { Ref: string };
+/**
+ * Pseudo Parameters - AWS CloudFormation provides several built-in parameters
+ */
+export declare const Pseudo: {
+  AccountId: {
+  Ref: 'AWS::AccountId'
+};
+  Region: {
+  Ref: 'AWS::Region'
+};
+  StackId: {
+  Ref: 'AWS::StackId'
+};
+  StackName: {
+  Ref: 'AWS::StackName'
+};
+  NotificationARNs: {
+  Ref: 'AWS::NotificationARNs'
+};
+  Partition: {
+  Ref: 'AWS::Partition'
+};
+  URLSuffix: {
+  Ref: 'AWS::URLSuffix'
+};
+  NoValue: {
+  Ref: 'AWS::NoValue'
+}
+};

package/dist/lambda/concurrency.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Global Lambda concurrency manager instance
+ */
+export declare const lambdaConcurrencyManager: LambdaConcurrencyManager;
+/**
+ * Lambda Concurrency Management
+ * Reserved and provisioned concurrency configuration
+ */
+export declare interface ConcurrencyConfig {
+  id: string
+  functionName: string
+  reservedConcurrency?: number
+  provisionedConcurrency?: ProvisionedConcurrencyConfig[]
+}
+export declare interface ProvisionedConcurrencyConfig {
+  id: string
+  functionName: string
+  qualifier: string
+  provisionedConcurrentExecutions: number
+  status: 'pending' | 'ready' | 'in_progress' | 'failed'
+  allocatedConcurrency?: number
+  availableConcurrency?: number
+  lastModified?: Date
+}
+export declare interface ConcurrencySchedule {
+  id: string
+  name: string
+  functionName: string
+  qualifier: string
+  schedule: ScheduleRule[]
+}
+export declare interface ScheduleRule {
+  name: string
+  cronExpression: string
+  targetConcurrency: number
+  minCapacity?: number
+  maxCapacity?: number
+}
+export declare 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: Map<string, ConcurrencyConfig>;
+  private provisionedConfigs: Map<string, ProvisionedConcurrencyConfig>;
+  private schedules: Map<string, ConcurrencySchedule>;
+  private autoScalingConfigs: Map<string, AutoScalingConfig>;
+  private configCounter: any;
+  private provisionedCounter: any;
+  private scheduleCounter: any;
+  private autoScalingCounter: any;
+  setReservedConcurrency(options: {
+    functionName: string
+    reservedConcurrency: number
+  }): ConcurrencyConfig;
+  setProvisionedConcurrency(options: {
+    functionName: string
+    qualifier: string
+    provisionedConcurrentExecutions: number
+  }): ProvisionedConcurrencyConfig;
+  configureWarmPool(options: {
+    functionName: string
+    alias: string
+    minInstances: number
+  }): ProvisionedConcurrencyConfig;
+  createSchedule(schedule: Omit<ConcurrencySchedule, 'id'>): ConcurrencySchedule;
+  createBusinessHoursSchedule(options: {
+    functionName: string
+    qualifier: string
+    businessHoursConcurrency: number
+    offHoursConcurrency: number
+  }): ConcurrencySchedule;
+  configureAutoScaling(config: Omit<AutoScalingConfig, 'id'>): AutoScalingConfig;
+  configurePredictiveScaling(options: {
+    functionName: string
+    qualifier: string
+    baselineCapacity: number
+    peakCapacity: number
+  }): AutoScalingConfig;
+  getConfig(id: string): ConcurrencyConfig | undefined;
+  listConfigs(): ConcurrencyConfig[];
+  getProvisionedConfig(id: string): ProvisionedConcurrencyConfig | undefined;
+  listProvisionedConfigs(): ProvisionedConcurrencyConfig[];
+  generateReservedConcurrencyCF(config: ConcurrencyConfig): any;
+  generateProvisionedConcurrencyCF(config: ProvisionedConcurrencyConfig): any;
+  generateAutoScalingTargetCF(config: AutoScalingConfig): any;
+  generateAutoScalingPolicyCF(config: AutoScalingConfig): any;
+  clear(): void;
+}

package/dist/lambda/destinations.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Global Lambda destinations manager instance
+ */
+export declare const lambdaDestinationsManager: LambdaDestinationsManager;
+/**
+ * Lambda Destinations
+ * Asynchronous invocation destinations for success and failure
+ */
+export declare interface LambdaDestination {
+  id: string
+  functionName: string
+  qualifier?: string
+  successDestination?: DestinationConfig
+  failureDestination?: DestinationConfig
+  maxEventAge?: number
+  maxRetries?: number
+}
+export declare interface DestinationConfig {
+  type: 'sqs' | 'sns' | 'eventbridge' | 'lambda'
+  arn: string
+}
+export declare 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 declare interface EventBridgeDestination {
+  id: string
+  functionName: string
+  eventBusArn: string
+  detailType: string
+  source: string
+}
+/**
+ * Lambda destinations manager
+ */
+export declare class LambdaDestinationsManager {
+  private destinations: Map<string, LambdaDestination>;
+  private records: Map<string, DestinationRecord>;
+  private eventBridgeDestinations: Map<string, EventBridgeDestination>;
+  private destinationCounter: any;
+  private recordCounter: any;
+  private eventBridgeCounter: any;
+  configureDestinations(destination: Omit<LambdaDestination, 'id'>): LambdaDestination;
+  configureSQSDestination(options: {
+    functionName: string
+    queueArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination;
+  configureSNSDestination(options: {
+    functionName: string
+    topicArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination;
+  configureEventBridgeDestination(options: {
+    functionName: string
+    eventBusArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination;
+  configureLambdaDestination(options: {
+    functionName: string
+    destinationFunctionArn: string
+    onSuccess?: boolean
+    onFailure?: boolean
+  }): LambdaDestination;
+  configureDLQWithNotification(options: {
+    functionName: string
+    dlqArn: string
+    notificationTopicArn: string
+  }): LambdaDestination;
+  createEventBridgeIntegration(options: {
+    functionName: string
+    eventBusArn: string
+    detailType?: string
+    source?: string
+  }): EventBridgeDestination;
+  sendToDestination(options: {
+    functionName: string
+    requestId: string
+    status: 'success' | 'failure'
+    payload?: any
+    error?: string
+  }): DestinationRecord | null;
+  getDestination(id: string): LambdaDestination | undefined;
+  listDestinations(functionName?: string): LambdaDestination[];
+  getDestinationRecords(functionName?: string): DestinationRecord[];
+  generateEventInvokeConfigCF(destination: LambdaDestination): any;
+  generateEventBridgeRuleCF(destination: EventBridgeDestination): any;
+  clear(): void;
+}

package/dist/lambda/dlq.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Global Lambda DLQ manager instance
+ */
+export declare const lambdaDLQManager: LambdaDLQManager;
+/**
+ * Lambda Dead Letter Queue (DLQ)
+ * Error handling and failed event management
+ */
+export declare interface DLQConfig {
+  id: string
+  functionName: string
+  targetArn: string
+  targetType: 'sqs' | 'sns'
+  maxReceiveCount?: number
+  retentionPeriod?: number
+}
+export declare interface DLQMessage {
+  id: string
+  functionName: string
+  requestId: string
+  timestamp: Date
+  errorMessage: string
+  errorType: string
+  stackTrace?: string
+  payload: any
+  attemptCount: number
+}
+export declare interface DLQAlarm {
+  id: string
+  dlqConfigId: string
+  alarmName: string
+  threshold: number
+  evaluationPeriods: number
+  notificationTopicArn?: string
+  enabled: boolean
+}
+export declare 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: Map<string, DLQConfig>;
+  private messages: Map<string, DLQMessage>;
+  private alarms: Map<string, DLQAlarm>;
+  private reprocessing: Map<string, DLQReprocessing>;
+  private configCounter: any;
+  private messageCounter: any;
+  private alarmCounter: any;
+  private reprocessCounter: any;
+  configureDLQ(config: Omit<DLQConfig, 'id'>): DLQConfig;
+  configureSQSDLQ(options: {
+    functionName: string
+    queueArn: string
+    maxReceiveCount?: number
+    retentionPeriod?: number
+  }): DLQConfig;
+  configureSNSDLQ(options: {
+    functionName: string
+    topicArn: string
+  }): DLQConfig;
+  configureDLQWithAlarm(options: {
+    functionName: string
+    queueArn: string
+    alarmThreshold: number
+    notificationTopicArn: string
+  }): DLQConfig;
+  sendToDLQ(options: {
+    functionName: string
+    requestId: string
+    errorMessage: string
+    errorType: string
+    stackTrace?: string
+    payload: any
+    attemptCount: number
+  }): DLQMessage;
+  createDLQAlarm(alarm: Omit<DLQAlarm, 'id'>): DLQAlarm;
+  createAgeAlarm(options: {
+    dlqConfigId: string
+    maxAgeSeconds: number
+    notificationTopicArn: string
+  }): DLQAlarm;
+  reprocessMessage(messageId: string): Promise<DLQReprocessing>;
+  batchReprocess(options: {
+    dlqConfigId: string
+    maxMessages?: number
+  }): Promise<DLQReprocessing[]>;
+  getDLQStats(dlqConfigId: string): {
+    totalMessages: number
+    oldestMessage?: Date
+    newestMessage?: Date
+    averageAttempts: number
+    errorTypes: Record<string, number>
+  };
+  getDLQConfig(id: string): DLQConfig | undefined;
+  listDLQConfigs(): DLQConfig[];
+  getDLQMessages(dlqConfigId: string): DLQMessage[];
+  generateDLQCF(config: DLQConfig): any;
+  generateSQSDLQCF(config: DLQConfig): any;
+  generateDLQAlarmCF(alarm: DLQAlarm): any;
+  clear(): void;
+}

package/dist/lambda/index.d.ts

@@ -0,0 +1,6 @@
+export * from './layers';
+export * from './versions';
+export * from './concurrency';
+export * from './destinations';
+export * from './vpc';
+export * from './dlq';

package/dist/lambda/layers.d.ts

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

package/dist/lambda/versions.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Global Lambda versions manager instance
+ */
+export declare const lambdaVersionsManager: LambdaVersionsManager;
+/**
+ * Lambda Versions and Aliases
+ * Immutable versions and mutable aliases for Lambda functions
+ */
+export declare interface LambdaVersion {
+  id: string
+  functionName: string
+  version: string
+  functionArn: string
+  codeHash: string
+  description?: string
+  runtime: string
+  memorySize: number
+  timeout: number
+  publishedAt: Date
+}
+export declare interface LambdaAlias {
+  id: string
+  functionName: string
+  aliasName: string
+  aliasArn: string
+  functionVersion: string
+  description?: string
+  routingConfig?: RoutingConfig
+  revisionId?: string
+}
+export declare interface RoutingConfig {
+  additionalVersionWeights?: Record<string, number>
+}
+export declare 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 declare class LambdaVersionsManager {
+  private versions: Map<string, LambdaVersion>;
+  private aliases: Map<string, LambdaAlias>;
+  private deployments: Map<string, VersionDeployment>;
+  private versionCounter: any;
+  private aliasCounter: any;
+  private deploymentCounter: any;
+  publishVersion(options: {
+    functionName: string
+    description?: string
+    runtime: string
+    memorySize: number
+    timeout: number
+  }): LambdaVersion;
+  private getNextVersionNumber(functionName: string): number;
+  createAlias(alias: Omit<LambdaAlias, 'id' | 'aliasArn' | 'revisionId'>): LambdaAlias;
+  createProductionAlias(options: {
+    functionName: string
+    version: string
+  }): LambdaAlias;
+  createStagingAlias(options: {
+    functionName: string
+    version: string
+  }): LambdaAlias;
+  updateAlias(aliasId: string, newVersion: string): LambdaAlias;
+  configureWeightedRouting(aliasId: string, weights: Record<string, number>): LambdaAlias;
+  createCanaryDeployment(options: {
+    functionName: string
+    fromVersion: string
+    toVersion: string
+    aliasName: string
+    canaryWeight: number
+  }): VersionDeployment;
+  completeDeployment(deploymentId: string): VersionDeployment;
+  rollbackDeployment(deploymentId: string): VersionDeployment;
+  private generateHash(): string;
+  getVersion(id: string): LambdaVersion | undefined;
+  listVersions(functionName?: string): LambdaVersion[];
+  getAlias(id: string): LambdaAlias | undefined;
+  listAliases(functionName?: string): LambdaAlias[];
+  generateVersionCF(version: LambdaVersion): any;
+  generateAliasCF(alias: LambdaAlias): any;
+  clear(): void;
+}

package/dist/lambda/vpc.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Global Lambda VPC manager instance
+ */
+export declare const lambdaVPCManager: LambdaVPCManager;
+/**
+ * Lambda VPC Configuration
+ * VPC networking for Lambda functions
+ */
+export declare interface LambdaVPCConfig {
+  id: string
+  functionName: string
+  vpcId: string
+  subnetIds: string[]
+  securityGroupIds: string[]
+  ipv6Allowed?: boolean
+}
+export declare interface VPCEndpoint {
+  id: string
+  vpcId: string
+  serviceName: string
+  endpointType: 'Interface' | 'Gateway'
+  subnetIds?: string[]
+  securityGroupIds?: string[]
+  privateDnsEnabled?: boolean
+}
+export declare interface NetworkInterface {
+  id: string
+  functionName: string
+  networkInterfaceId: string
+  subnetId: string
+  privateIpAddress: string
+  status: 'creating' | 'available' | 'in-use' | 'deleting'
+  attachedAt?: Date
+}
+export declare interface VPCConnectivity {
+  id: string
+  functionName: string
+  hasInternetAccess: boolean
+  hasNATGateway: boolean
+  hasVPCEndpoints: boolean
+  endpoints: string[]
+  recommendations: string[]
+}
+/**
+ * Lambda VPC manager
+ */
+export declare class LambdaVPCManager {
+  private vpcConfigs: Map<string, LambdaVPCConfig>;
+  private endpoints: Map<string, VPCEndpoint>;
+  private networkInterfaces: Map<string, NetworkInterface>;
+  private connectivity: Map<string, VPCConnectivity>;
+  private configCounter: any;
+  private endpointCounter: any;
+  private eniCounter: any;
+  private connectivityCounter: any;
+  configureVPC(config: Omit<LambdaVPCConfig, 'id'>): LambdaVPCConfig;
+  configurePrivateVPC(options: {
+    functionName: string
+    vpcId: string
+    privateSubnetIds: string[]
+    securityGroupId: string
+  }): LambdaVPCConfig;
+  configureMultiAZVPC(options: {
+    functionName: string
+    vpcId: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): LambdaVPCConfig;
+  createVPCEndpoint(endpoint: Omit<VPCEndpoint, 'id'>): VPCEndpoint;
+  createS3Endpoint(options: {
+    vpcId: string
+    routeTableIds: string[]
+  }): VPCEndpoint;
+  createDynamoDBEndpoint(options: {
+    vpcId: string
+    routeTableIds: string[]
+  }): VPCEndpoint;
+  createSecretsManagerEndpoint(options: {
+    vpcId: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): VPCEndpoint;
+  private createNetworkInterface(options: {
+    functionName: string
+    subnetId: string
+  }): NetworkInterface;
+  analyzeConnectivity(options: {
+    functionName: string
+    hasNATGateway?: boolean
+    hasInternetGateway?: boolean
+  }): VPCConnectivity;
+  getVPCConfig(id: string): LambdaVPCConfig | undefined;
+  listVPCConfigs(functionName?: string): LambdaVPCConfig[];
+  getNetworkInterfaces(functionName: string): NetworkInterface[];
+  listVPCEndpoints(vpcId?: string): VPCEndpoint[];
+  generateVPCConfigCF(config: LambdaVPCConfig): any;
+  generateVPCEndpointCF(endpoint: VPCEndpoint): any;
+  generateSecurityGroupCF(options: {
+    groupName: string
+    vpcId: string
+    ingressRules?: Array<{
+      protocol: string
+      fromPort: number
+      toPort: number
+      cidrIp?: string
+      sourceSecurityGroupId?: string
+    }>
+    egressRules?: Array<{
+      protocol: string
+      fromPort: number
+      toPort: number
+      cidrIp?: string
+    }>
+  }): any;
+  clear(): void;
+}

package/dist/local/config.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Get local configuration
+ */
+export declare function getLocalConfig(): LocalConfig;
+/**
+ * Check if running in local development mode
+ */
+export declare function isLocalDevelopment(): boolean;
+/**
+ * Get AWS endpoint for service in local mode
+ */
+export declare function getLocalEndpoint(service: string): string;
+/**
+ * Get local credentials
+ */
+export declare function getLocalCredentials(): {
+  accessKeyId: string
+  secretAccessKey: string
+  region: string
+};
+/**
+ * Create local environment variables for AWS CLI
+ */
+export declare function getLocalEnvVars(): Record<string, string>;
+/**
+ * Default local development configuration
+ */
+export declare const defaultLocalConfig: LocalConfig;
+/**
+ * Local development configuration
+ * Configures ts-cloud to use LocalStack and local services
+ */
+export declare interface LocalConfig {
+  enabled: boolean
+  localstackEndpoint: string
+  postgresUrl: string
+  redisUrl: string
+  dynamodbEndpoint: string
+  s3Endpoint: string
+  emailEndpoint: string
+  awsRegion: string
+  awsAccessKeyId: string
+  awsSecretAccessKey: string
+}

package/dist/local/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config';
+export * from './mock-aws';