@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/cloudformation/builder.d.ts

@@ -0,0 +1,59 @@
+import { addApiGatewayResources } from './builders/api-gateway';
+import { addCacheResources } from './builders/cache';
+import { addCDNResources } from './builders/cdn';
+import { addComputeResources } from './builders/compute';
+import { addDatabaseResources } from './builders/database';
+import { addFunctionResources } from './builders/functions';
+import { addMessagingResources } from './builders/messaging';
+import { addMonitoringResources } from './builders/monitoring';
+import { addNetworkResources } from './builders/network';
+import { addQueueResources } from './builders/queue';
+import { addSecurityResources } from './builders/security';
+import { addStorageResources } from './builders/storage';
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+import type { CloudFormationTemplate, CloudFormationResource } from './types';
+/**
+ * Main function to convert CloudConfig to CloudFormation template
+ */
+export declare function buildCloudFormationTemplate(config: CloudConfig): CloudFormationTemplate;
+/**
+ * CloudFormation Template Builder
+ * Converts-cloudConfig to CloudFormation templates
+ */
+export declare class CloudFormationBuilder {
+  protected template: CloudFormationTemplate;
+  private config: CloudConfig;
+  private resourceDependencies: Map<string, Set<string>>;
+  constructor(config: CloudConfig);
+  build(): CloudFormationTemplate;
+  private addParameters(): void;
+  private addMappings(): void;
+  private addConditions(): void;
+  private addResources(): void;
+  private initializeOutputs(): void;
+  addResource(logicalId: string, type: string, properties: Record<string, any>, options?: {
+      dependsOn?: string | string[]
+      condition?: string
+      deletionPolicy?: 'Delete' | 'Retain' | 'Snapshot'
+      updateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot'
+    }): void;
+  addOutputs(outputs: Record<string, any>): void;
+  getOutputs(): Record<string, any>;
+  hasResource(logicalId: string): boolean;
+  getResource(logicalId: string): CloudFormationResource | undefined;
+  private trackDependency(resource: string, dependencies: string | string[]): void;
+  private resolveDependencies(): void;
+  toLogicalId(name: string): string;
+  private addNetworkResources(network: any): void;
+  private addStorageResources(storage: any): void;
+  private addComputeResources(compute: any): void;
+  private addDatabaseResources(database: any): void;
+  private addFunctionResources(functions: any): void;
+  private addCacheResources(cache: any): void;
+  private addQueueResources(queue: any): void;
+  private addMessagingResources(messaging: any): void;
+  private addCDNResources(cdn: any): void;
+  private addApiGatewayResources(apiGateway: any): void;
+  private addMonitoringResources(monitoring: any): void;
+  private addSecurityResources(security: any): void;
+}

package/dist/cloudformation/builders/api-gateway.d.ts

@@ -0,0 +1,30 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add API Gateway resources to CloudFormation template
+ */
+export declare function addApiGatewayResources(builder: CloudFormationBuilder, config: ApiGatewayConfig): void;
+export declare interface ApiGatewayConfig {
+  type: 'http' | 'rest' | 'websocket'
+  customDomain?: {
+    domain: string
+    certificateArn: string
+  }
+  cors?: {
+    allowOrigins: string[]
+    allowMethods: string[]
+    allowHeaders?: string[]
+    maxAge?: number
+  }
+  throttling?: {
+    rateLimit: number
+    burstLimit: number
+  }
+  routes?: any
+  authorizer?: {
+    type: 'jwt' | 'lambda' | 'cognito'
+    identitySource?: string
+    authorizerUri?: string
+    issuer?: string
+    audience?: string[]
+  }
+}

package/dist/cloudformation/builders/cache.d.ts

@@ -0,0 +1,35 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add ElastiCache resources to CloudFormation template
+ */
+export declare function addCacheResources(builder: CloudFormationBuilder, config: CacheConfig): void;
+export declare interface CacheConfig {
+  redis?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: 'redis'
+    engineVersion: string
+    port?: number
+    parameterGroup?: {
+      maxmemoryPolicy?: string
+      timeout?: string
+      [key: string]: string | undefined
+    }
+    snapshotRetentionLimit?: number
+    snapshotWindow?: string
+    automaticFailoverEnabled?: boolean
+  }
+  memcached?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: 'memcached'
+    engineVersion: string
+    port?: number
+  }
+  elasticache?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: string
+    engineVersion: string
+  }
+}

package/dist/cloudformation/builders/cdn.d.ts

@@ -0,0 +1,34 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add CloudFront distribution to CloudFormation template
+ */
+export declare function addCDNResources(builder: CloudFormationBuilder, config: CDNConfig): void;
+export declare interface CDNConfig {
+  enabled: boolean
+  origins?: Array<{
+    id: string
+    domainName: string
+    pathPattern?: string
+    originPath?: string
+  }>
+  customDomain?: {
+    domain: string
+    certificateArn: string
+  }
+  cachePolicy?: {
+    minTTL?: number
+    defaultTTL?: number
+    maxTTL?: number
+  }
+  compress?: boolean
+  http3?: boolean
+  errorPages?: {
+    [code: string]: string
+  }
+  edgeFunctions?: Array<{
+    eventType: 'viewer-request' | 'viewer-response' | 'origin-request' | 'origin-response'
+    functionArn: string
+    name: string
+  }>
+  priceClass?: 'PriceClass_All' | 'PriceClass_200' | 'PriceClass_100'
+}

package/dist/cloudformation/builders/compute.d.ts

@@ -0,0 +1,66 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add compute resources (EC2, ECS, ALB) to CloudFormation template
+ */
+export declare function addComputeResources(builder: CloudFormationBuilder, config: ComputeConfig): void;
+export declare interface LoadBalancerConfig {
+  type: 'application' | 'network'
+  healthCheck?: {
+    path?: string
+    interval?: number
+    timeout?: number
+    healthyThreshold?: number
+    unhealthyThreshold?: number
+  }
+  stickySession?: {
+    enabled: boolean
+    duration?: number
+  }
+}
+export declare interface ServerConfig {
+  instanceType: string
+  ami?: string
+  autoScaling?: {
+    min: number
+    max: number
+    targetCPU?: number
+    scaleUpCooldown?: number
+    scaleDownCooldown?: number
+  }
+  loadBalancer?: LoadBalancerConfig
+  userData?: string
+}
+export declare interface ComputeConfig {
+  server?: ServerConfig
+  fargate?: {
+    taskDefinition: {
+      cpu: string
+      memory: string
+      containerDefinitions?: Array<{
+        name: string
+        image: string
+        portMappings?: Array<{ containerPort: number }>
+        environment?: Record<string, string>
+        healthCheck?: any
+      }>
+    }
+    service: {
+      desiredCount: number
+      serviceDiscovery?: {
+        enabled: boolean
+        namespace?: string
+      }
+      autoScaling?: {
+        min: number
+        max: number
+        targetCPU?: number
+      }
+    }
+  }
+  services?: Array<{
+    name: string
+    type: 'fargate' | 'ec2'
+    taskDefinition: any
+    service: any
+  }>
+}

package/dist/cloudformation/builders/database.d.ts

@@ -0,0 +1,61 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add database resources (RDS, DynamoDB) to CloudFormation template
+ */
+export declare function addDatabaseResources(builder: CloudFormationBuilder, config: DatabaseConfig): void;
+export declare interface DatabaseConfig {
+  postgres?: {
+    engine: 'postgres'
+    version: string
+    instanceClass: string
+    allocatedStorage: number
+    maxAllocatedStorage?: number
+    multiAZ?: boolean
+    backupRetentionDays?: number
+    preferredBackupWindow?: string
+    preferredMaintenanceWindow?: string
+    enablePerformanceInsights?: boolean
+    performanceInsightsRetention?: number
+    deletionProtection?: boolean
+    parameters?: Record<string, string>
+  }
+  mysql?: {
+    engine: 'mysql'
+    version: string
+    instanceClass: string
+    allocatedStorage: number
+    maxAllocatedStorage?: number
+    multiAZ?: boolean
+    backupRetentionDays?: number
+    preferredBackupWindow?: string
+    preferredMaintenanceWindow?: string
+    enablePerformanceInsights?: boolean
+    performanceInsightsRetention?: number
+    deletionProtection?: boolean
+    parameters?: Record<string, string>
+  }
+  dynamodb?: {
+    tables: DynamoDBTableConfig[]
+  }
+}
+export declare interface DynamoDBTableConfig {
+  name: string
+  partitionKey: string
+  sortKey?: string
+  billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST'
+  readCapacity?: number
+  writeCapacity?: number
+  streamEnabled?: boolean
+  pointInTimeRecovery?: boolean
+  ttl?: {
+    enabled: boolean
+    attributeName: string
+  }
+  globalSecondaryIndexes?: Array<{
+    name: string
+    partitionKey: string
+    sortKey?: string
+    projectionType?: 'ALL' | 'KEYS_ONLY' | 'INCLUDE'
+    nonKeyAttributes?: string[]
+  }>
+}

package/dist/cloudformation/builders/functions.d.ts

@@ -0,0 +1,32 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add Lambda function resources to CloudFormation template
+ */
+export declare function addFunctionResources(builder: CloudFormationBuilder, config: FunctionsConfig): void;
+export declare interface FunctionEvent {
+  type: 'http' | 's3' | 'sqs' | 'sns' | 'kinesis' | 'dynamodb-stream' | 'schedule'
+  path?: string
+  method?: string
+  bucket?: string
+  filterPrefix?: string
+  filterSuffix?: string
+  queueName?: string
+  streamName?: string
+  tableName?: string
+  batchSize?: number
+  startingPosition?: 'LATEST' | 'TRIM_HORIZON'
+  parallelizationFactor?: number
+  expression?: string
+}
+export declare interface FunctionItem {
+  name: string
+  runtime: string
+  handler: string
+  memory: number
+  timeout: number
+  events?: FunctionEvent[]
+  environment?: Record<string, string>
+}
+export declare interface FunctionsConfig {
+
+}

package/dist/cloudformation/builders/messaging.d.ts

@@ -0,0 +1,17 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add SNS topic resources to CloudFormation template
+ */
+export declare function addMessagingResources(builder: CloudFormationBuilder, config: MessagingConfig): void;
+export declare interface TopicConfig {
+  name: string
+  displayName?: string
+  subscriptions?: Array<{
+    protocol: 'http' | 'https' | 'email' | 'email-json' | 'sms' | 'sqs' | 'lambda'
+    endpoint: string
+    filterPolicy?: Record<string, any>
+  }>
+}
+export declare interface MessagingConfig {
+  topics?: TopicConfig[]
+}

package/dist/cloudformation/builders/monitoring.d.ts

@@ -0,0 +1,36 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add CloudWatch monitoring resources to CloudFormation template
+ */
+export declare function addMonitoringResources(builder: CloudFormationBuilder, config: MonitoringConfig): void;
+export declare interface AlarmConfig {
+  name?: string
+  metric: string
+  threshold: number
+  evaluationPeriods?: number
+  comparisonOperator?: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold'
+  statistic?: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount'
+  period?: number
+  treatMissingData?: 'breaching' | 'notBreaching' | 'ignore' | 'missing'
+  service?: string
+  namespace?: string
+  dimensions?: Record<string, string>
+}
+export declare interface MonitoringConfig {
+  dashboard?: {
+    name: string
+    widgets?: Array<{
+      type: 'metric' | 'log' | 'text'
+      metrics?: string[] | Array<{ service?: string, metric: string }>
+      logGroup?: string
+      text?: string
+      width?: number
+      height?: number
+    }>
+  }
+  alarms?: AlarmConfig[]
+  logs?: {
+    retention?: number
+    groups?: string[]
+  }
+}

package/dist/cloudformation/builders/network.d.ts

@@ -0,0 +1,14 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add VPC and networking resources to CloudFormation template
+ */
+export declare function addNetworkResources(builder: CloudFormationBuilder, config: NetworkConfig): void;
+export declare interface NetworkConfig {
+  vpc?: {
+    cidr?: string
+    availabilityZones?: number
+    natGateways?: number
+    enableDnsHostnames?: boolean
+    enableDnsSupport?: boolean
+  }
+}

package/dist/cloudformation/builders/queue.d.ts

@@ -0,0 +1,8 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add SQS queue resources to CloudFormation template
+ */
+export declare function addQueueResources(builder: CloudFormationBuilder, config: QueueConfig): void;
+export declare interface QueueConfig {
+
+}

package/dist/cloudformation/builders/security.d.ts

@@ -0,0 +1,31 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add security resources (ACM certificates, WAF, security groups) to CloudFormation template
+ */
+export declare function addSecurityResources(builder: CloudFormationBuilder, config: SecurityConfig): void;
+export declare interface SecurityConfig {
+  certificate?: {
+    domain: string
+    subdomains?: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }
+  waf?: {
+    enabled: boolean
+    rules?: string[]
+    rateLimit?: number
+    scope?: 'REGIONAL' | 'CLOUDFRONT'
+  }
+  securityGroups?: Record<string, {
+    ingress?: Array<{
+      port: number
+      protocol: string
+      cidr?: string
+      source?: string
+    }>
+    egress?: Array<{
+      port: number
+      protocol: string
+      cidr?: string
+    }>
+  }>
+}

package/dist/cloudformation/builders/storage.d.ts

@@ -0,0 +1,8 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add S3 and EFS storage resources to CloudFormation template
+ */
+export declare function addStorageResources(builder: CloudFormationBuilder, config: StorageConfig): void;
+export declare interface StorageConfig {
+
+}

package/dist/cloudformation/index.d.ts

@@ -0,0 +1,24 @@
+export type {
+  CloudFormationTemplate,
+  CloudFormationResource,
+  CloudFormationParameter,
+  CloudFormationOutput,
+  CloudFormationCondition,
+  CloudFormationIntrinsicFunction,
+} from './types';
+export type { QueueConfig } from './builders/queue';
+export {
+  CloudFormationBuilder,
+  buildCloudFormationTemplate,
+} from './builder';
+export {
+  Fn,
+  Arn,
+  AWS_PSEUDO_PARAMETERS,
+} from './types';
+export { addNetworkResources } from './builders/network';
+export { addStorageResources } from './builders/storage';
+export { addComputeResources } from './builders/compute';
+export { addDatabaseResources } from './builders/database';
+export { addFunctionResources } from './builders/functions';
+export { addQueueResources } from './builders/queue';

package/dist/cloudformation/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Helper functions for creating CloudFormation intrinsic functions
+ */
+export declare const Fn: {
+  ref: (logicalId: string) => unknown;
+  getAtt: (logicalId: string, attribute: string) => unknown;
+  join: (delimiter: string, values: any[]) => unknown;
+  sub: (template: string, variables?: Record<string, any>) => unknown;
+  select: (index: number, list: any[] | CloudFormationIntrinsicFunction) => unknown;
+  split: (delimiter: string, source: string) => unknown;
+  getAZs: (region: string?) => unknown;
+  importValue: (name: any) => unknown;
+  findInMap: (mapName: string, topLevelKey: any, secondLevelKey: any) => unknown;
+  base64: (value: any) => unknown;
+  cidr: (ipBlock: any, count: number, cidrBits: number) => unknown;
+  equals: (value1: any, value2: any) => unknown;
+  if: (conditionName: string, trueValue: any, falseValue: any) => unknown;
+  not: (condition: any) => unknown;
+  and: (...conditions: any[]) => unknown;
+  or: (...conditions: any[]) => unknown
+};
+/**
+ * Common AWS resource ARN patterns
+ */
+export declare const Arn: {
+  s3Bucket: (bucketName: any) => unknown;
+  s3Object: (bucketName: any, key: string?) => unknown;
+  lambda: (functionName: string, region?: string, account?: string) => unknown;
+  dynamodb: (tableName: string) => unknown;
+  sqs: (queueName: string) => unknown;
+  sns: (topicName: string) => unknown;
+  kinesis: (streamName: string) => unknown;
+  iam: (resourceType: 'role' | 'policy' | 'user' | 'group', name: string) => unknown;
+  secretsManager: (secretName: string) => unknown;
+  cloudwatch: (logGroup: string) => unknown
+};
+/**
+ * Common CloudFormation pseudo parameters
+ */
+export declare const AWS_PSEUDO_PARAMETERS: {
+  ACCOUNT_ID: {
+  Ref: 'AWS::AccountId'
+};
+  NOTIFICATION_ARNS: {
+  Ref: 'AWS::NotificationARNs'
+};
+  NO_VALUE: {
+  Ref: 'AWS::NoValue'
+};
+  PARTITION: {
+  Ref: 'AWS::Partition'
+};
+  REGION: {
+  Ref: 'AWS::Region'
+};
+  STACK_ID: {
+  Ref: 'AWS::StackId'
+};
+  STACK_NAME: {
+  Ref: 'AWS::StackName'
+};
+  URL_SUFFIX: {
+  Ref: 'AWS::URLSuffix'
+}
+};
+/**
+ * CloudFormation Template Types
+ * Based on AWS CloudFormation Resource Specification
+ */
+export declare interface CloudFormationTemplate {
+  AWSTemplateFormatVersion: '2010-09-09'
+  Description?: string
+  Metadata?: Record<string, any>
+  Parameters?: Record<string, CloudFormationParameter>
+  Mappings?: Record<string, Record<string, Record<string, string>>>
+  Conditions?: Record<string, CloudFormationCondition>
+  Resources: Record<string, CloudFormationResource>
+  Outputs?: Record<string, CloudFormationOutput>
+}
+export declare interface CloudFormationParameter {
+  Type: 'String' | 'Number' | 'List<Number>' | 'CommaDelimitedList' | 'AWS::EC2::AvailabilityZone::Name' | 'AWS::EC2::Image::Id' | 'AWS::EC2::Instance::Id' | 'AWS::EC2::KeyPair::KeyName' | 'AWS::EC2::SecurityGroup::GroupName' | 'AWS::EC2::SecurityGroup::Id' | 'AWS::EC2::Subnet::Id' | 'AWS::EC2::Volume::Id' | 'AWS::EC2::VPC::Id' | 'AWS::Route53::HostedZone::Id' | 'List<AWS::EC2::AvailabilityZone::Name>' | 'List<AWS::EC2::Image::Id>' | 'List<AWS::EC2::Instance::Id>' | 'List<AWS::EC2::SecurityGroup::GroupName>' | 'List<AWS::EC2::SecurityGroup::Id>' | 'List<AWS::EC2::Subnet::Id>' | 'List<AWS::EC2::Volume::Id>' | 'List<AWS::EC2::VPC::Id>' | 'List<AWS::Route53::HostedZone::Id>'
+  Default?: string | number
+  Description?: string
+  AllowedValues?: string[]
+  AllowedPattern?: string
+  MinLength?: number
+  MaxLength?: number
+  MinValue?: number
+  MaxValue?: number
+  ConstraintDescription?: string
+  NoEcho?: boolean
+}
+export declare interface CloudFormationResource {
+  Type: string
+  Properties?: Record<string, any>
+  DependsOn?: string | string[]
+  Condition?: string
+  Metadata?: Record<string, any>
+  CreationPolicy?: Record<string, any>
+  UpdatePolicy?: Record<string, any>
+  DeletionPolicy?: 'Delete' | 'Retain' | 'Snapshot'
+  UpdateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot'
+}
+export declare interface CloudFormationOutput {
+  Value: any
+  Description?: string
+  Export?: {
+    Name: any
+  }
+  Condition?: string
+}
+export type CloudFormationCondition = | CloudFormationIntrinsicFunction
+  | boolean
+/**
+ * CloudFormation Intrinsic Functions
+ */
+export type CloudFormationIntrinsicFunction = | { Ref: string }
+  | { 'Fn::GetAtt': [string, string] }
+  | { 'Fn::Join': [string, any[]] }
+  | { 'Fn::Sub': string | [string, Record<string, any>] }
+  | { 'Fn::Select': [number, any[] | CloudFormationIntrinsicFunction] }
+  | { 'Fn::Split': [string, string] }
+  | { 'Fn::GetAZs': string }
+  | { 'Fn::ImportValue': any }
+  | { 'Fn::FindInMap': [string, any, any] }
+  | { 'Fn::Base64': any }
+  | { 'Fn::Cidr': [any, number, number] }
+  | { 'Fn::Equals': [any, any] }
+  | { 'Fn::If': [string, any, any] }
+  | { 'Fn::Not': [any] }
+  | { 'Fn::And': any[] }
+  | { 'Fn::Or': any[] }