@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/modules/compute.d.ts

@@ -0,0 +1,309 @@
+import type { ApplicationLoadBalancer, AutoScalingGroup, AutoScalingLaunchConfiguration, AutoScalingScalingPolicy, EC2Instance, EC2SecurityGroup, ECSCluster, ECSService, ECSTaskDefinition, IAMRole, LambdaFunction, Listener, TargetGroup,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface ServerOptions {
+  slug: string
+  environment: EnvironmentType
+  instanceType?: string
+  imageId?: string
+  keyName?: string
+  securityGroupIds?: string[]
+  subnetId?: string
+  userData?: string
+  volumeSize?: number
+  volumeType?: 'gp2' | 'gp3' | 'io1' | 'io2'
+  encrypted?: boolean
+}
+export declare interface SecurityGroupOptions {
+  slug: string
+  environment: EnvironmentType
+  vpcId?: string
+  description?: string
+  ingress?: SecurityGroupRule[]
+  egress?: SecurityGroupRule[]
+}
+export declare interface SecurityGroupRule {
+  protocol: string
+  fromPort?: number
+  toPort?: number
+  cidr?: string
+  sourceSecurityGroupId?: string
+}
+export declare interface LoadBalancerOptions {
+  slug: string
+  environment: EnvironmentType
+  scheme?: 'internet-facing' | 'internal'
+  subnets: string[]
+  securityGroups?: string[]
+  type?: 'application' | 'network'
+}
+export declare interface TargetGroupOptions {
+  slug: string
+  environment: EnvironmentType
+  port: number
+  protocol?: 'HTTP' | 'HTTPS' | 'TCP'
+  vpcId: string
+  targetType?: 'instance' | 'ip' | 'lambda'
+  healthCheckPath?: string
+  healthCheckInterval?: number
+  healthCheckTimeout?: number
+  healthyThreshold?: number
+  unhealthyThreshold?: number
+}
+export declare interface ListenerOptions {
+  port: number
+  protocol?: 'HTTP' | 'HTTPS'
+  certificateArn?: string
+  defaultTargetGroupArn: string
+}
+export declare interface FargateServiceOptions {
+  slug: string
+  environment: EnvironmentType
+  image: string
+  cpu?: string
+  memory?: string
+  desiredCount?: number
+  containerPort?: number
+  environmentVariables?: Record<string, string>
+  secrets?: Array<{ name: string, valueFrom: string }>
+  healthCheck?: {
+    command: string[]
+    interval?: number
+    timeout?: number
+    retries?: number
+  }
+  logGroup?: string
+  subnets: string[]
+  securityGroups: string[]
+  targetGroupArn?: string
+}
+export declare interface LambdaFunctionOptions {
+  slug: string
+  environment: EnvironmentType
+  functionName?: string
+  runtime: string
+  handler: string
+  code: {
+    s3Bucket?: string
+    s3Key?: string
+    zipFile?: string
+  }
+  role?: string
+  timeout?: number
+  memorySize?: number
+  environmentVariables?: Record<string, string>
+  vpcConfig?: {
+    securityGroupIds: string[]
+    subnetIds: string[]
+  }
+}
+export declare interface LaunchConfigurationOptions {
+  slug: string
+  environment: EnvironmentType
+  imageId: string
+  instanceType: string
+  keyName?: string
+  securityGroups?: Array<string | { Ref: string }>
+  userData?: string
+  volumeSize?: number
+  volumeType?: 'gp2' | 'gp3' | 'io1' | 'io2'
+  encrypted?: boolean
+  iamInstanceProfile?: string | { Ref: string }
+}
+export declare interface AutoScalingGroupOptions {
+  slug: string
+  environment: EnvironmentType
+  launchConfigurationName: string | { Ref: string }
+  minSize: number
+  maxSize: number
+  desiredCapacity?: number
+  vpcZoneIdentifier?: string[] | { Ref: string }
+  targetGroupArns?: Array<string | { Ref: string }>
+  healthCheckType?: 'EC2' | 'ELB'
+  healthCheckGracePeriod?: number
+  cooldown?: number
+  tags?: Record<string, string>
+}
+export declare interface ScalingPolicyOptions {
+  slug: string
+  environment: EnvironmentType
+  autoScalingGroupName: string | { Ref: string }
+  policyType?: 'TargetTrackingScaling' | 'StepScaling' | 'SimpleScaling'
+  targetValue?: number
+  predefinedMetricType?: 'ASGAverageCPUUtilization' | 'ASGAverageNetworkIn' | 'ASGAverageNetworkOut' | 'ALBRequestCountPerTarget'
+  scaleInCooldown?: number
+  scaleOutCooldown?: number
+}
+/**
+ * Compute Module - EC2, ECS, Lambda Management
+ * Provides clean API for both server (Forge-style) and serverless (Vapor-style) deployments
+ */
+export declare class Compute {
+  static createServer(options: ServerOptions): {
+    instance: EC2Instance
+    logicalId: string
+  };
+  static createSecurityGroup(options: SecurityGroupOptions): {
+    securityGroup: EC2SecurityGroup
+    logicalId: string
+  };
+  static createWebServerSecurityGroup(slug: string, environment: EnvironmentType, vpcId?: string): {
+      securityGroup: EC2SecurityGroup
+      logicalId: string
+    };
+  static createLoadBalancer(options: LoadBalancerOptions): {
+    loadBalancer: ApplicationLoadBalancer
+    logicalId: string
+  };
+  static createTargetGroup(options: TargetGroupOptions): {
+    targetGroup: TargetGroup
+    logicalId: string
+  };
+  static createListener(loadBalancerLogicalId: string, options: ListenerOptions): {
+      listener: Listener
+      logicalId: string
+    };
+  static createEcsCluster(slug: string, environment: EnvironmentType): {
+      cluster: ECSCluster
+      logicalId: string
+    };
+  static createFargateService(options: FargateServiceOptions): {
+    cluster: ECSCluster
+    taskDefinition: ECSTaskDefinition
+    service: ECSService
+    taskRole: IAMRole
+    executionRole: IAMRole
+    clusterLogicalId: string
+    taskDefinitionLogicalId: string
+    serviceLogicalId: string
+    taskRoleLogicalId: string
+    executionRoleLogicalId: string
+  };
+  static createLambdaFunction(options: LambdaFunctionOptions): {
+    lambdaFunction: LambdaFunction
+    role: IAMRole
+    logicalId: string
+    roleLogicalId: string
+  };
+  static generateNodeServerUserData(options?: {
+    nodeVersion?: string
+    appRepo?: string
+    environment?: Record<string, string>
+  }): string;
+  static generateBunServerUserData(options?: {
+    appRepo?: string
+    environment?: Record<string, string>
+  }): string;
+  static createLaunchConfiguration(options: LaunchConfigurationOptions): {
+    launchConfiguration: AutoScalingLaunchConfiguration
+    logicalId: string
+  };
+  static createAutoScalingGroup(options: AutoScalingGroupOptions): {
+    autoScalingGroup: AutoScalingGroup
+    logicalId: string
+  };
+  static createScalingPolicy(options: ScalingPolicyOptions): {
+    scalingPolicy: AutoScalingScalingPolicy
+    logicalId: string
+  };
+  static readonly AutoScaling: any;
+  static readonly Secrets: any;
+  static createFargateServiceWithSecrets(options: FargateServiceOptions & {
+    secretArns?: string[]
+    kmsKeyArns?: string[]
+  }): {
+    cluster: ECSCluster
+    taskDefinition: ECSTaskDefinition
+    service: ECSService
+    taskRole: IAMRole
+    executionRole: IAMRole
+    clusterLogicalId: string
+    taskDefinitionLogicalId: string
+    serviceLogicalId: string
+    taskRoleLogicalId: string
+    executionRoleLogicalId: string
+  };
+  static generateSecretReferences(params: {
+    region: string
+    accountId: string
+    secretPrefix: string
+    secrets: string[]
+  }): Array<{ name: string, valueFrom: string }>;
+  static readonly EnvSecrets: any;
+  static createJumpBox(options: {
+    slug: string
+    environment: EnvironmentType
+    vpcId: string
+    subnetId: string
+    keyName: string
+    instanceType?: string
+    imageId?: string
+    allowedCidrs?: string[]
+    mountEfs?: {
+      fileSystemId: string
+      mountPath?: string
+    }
+  }): {
+    instance: EC2Instance
+    securityGroup: EC2SecurityGroup
+    instanceProfile: any
+    instanceRole: IAMRole
+    instanceLogicalId: string
+    securityGroupLogicalId: string
+    instanceProfileLogicalId: string
+    instanceRoleLogicalId: string
+    resources: Record<string, any>
+  };
+  static readonly JumpBox: any;
+  static readonly InstanceSize: any;
+  static readonly DiskConfig: any;
+  static readonly SpotConfig: any;
+  static readonly MixedInstances: any;
+  static readonly AutoScalingConfig: any;
+  static readonly LoadBalancerConfig: any;
+  static readonly SslConfig: any;
+  static readonly FunctionConfig: any;
+  static readonly UserData: any;
+  static createElasticIp(options: {
+    slug: string
+    environment: EnvironmentType
+    domain?: string
+    instanceLogicalId?: string
+  }): {
+    eip: any
+    eipAssociation?: any
+    eipLogicalId: string
+    associationLogicalId?: string
+    resources: Record<string, any>
+  };
+  static createServerModeStack(options: {
+    slug: string
+    environment: EnvironmentType
+    vpcId: string
+    subnetId: string
+    instanceType?: string
+    imageId?: string
+    keyName: string
+    domain?: string
+    userData?: string
+    allowedPorts?: number[]
+    volumeSize?: number
+    volumeType?: 'gp2' | 'gp3' | 'io1' | 'io2'
+  }): {
+    instance: EC2Instance
+    securityGroup: EC2SecurityGroup
+    eip: any
+    eipAssociation: any
+    instanceRole: IAMRole
+    instanceProfile: any
+    resources: Record<string, any>
+    outputs: {
+      instanceLogicalId: string
+      securityGroupLogicalId: string
+      eipLogicalId: string
+      associationLogicalId: string
+      roleLogicalId: string
+      profileLogicalId: string
+    }
+  };
+  static readonly ServerMode: any;
+}

package/dist/modules/database.d.ts

@@ -0,0 +1,105 @@
+import type { DynamoDBTable, RDSDBInstance, RDSDBParameterGroup, RDSDBSubnetGroup,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface RDSOptions {
+  slug: string
+  environment: EnvironmentType
+  dbInstanceIdentifier?: string
+  dbInstanceClass?: string
+  instanceClass?: string
+  allocatedStorage?: number
+  storageType?: 'gp2' | 'gp3' | 'io1' | 'io2'
+  masterUsername?: string
+  masterUserPassword?: string
+  masterPassword?: string
+  databaseName?: string
+  subnetIds?: string[]
+  securityGroupIds?: string[]
+  encrypted?: boolean
+  kmsKeyId?: string
+  multiAz?: boolean
+  backupRetentionDays?: number
+  publiclyAccessible?: boolean
+  enableCloudwatchLogs?: boolean
+  deletionProtection?: boolean
+}
+export declare interface DynamoDBTableOptions {
+  slug: string
+  environment: EnvironmentType
+  tableName?: string
+  partitionKey: {
+    name: string
+    type: 'S' | 'N' | 'B'
+  }
+  sortKey?: {
+    name: string
+    type: 'S' | 'N' | 'B'
+  }
+  billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST'
+  readCapacity?: number
+  writeCapacity?: number
+  streamEnabled?: boolean
+  streamViewType?: 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES' | 'KEYS_ONLY'
+  encrypted?: boolean
+  kmsKeyId?: string
+  pointInTimeRecovery?: boolean
+  ttlAttribute?: string
+}
+export declare interface GlobalSecondaryIndexOptions {
+  indexName: string
+  partitionKey: {
+    name: string
+    type: 'S' | 'N' | 'B'
+  }
+  sortKey?: {
+    name: string
+    type: 'S' | 'N' | 'B'
+  }
+  projectionType?: 'ALL' | 'KEYS_ONLY' | 'INCLUDE'
+  nonKeyAttributes?: string[]
+  readCapacity?: number
+  writeCapacity?: number
+}
+/**
+ * Database Module - RDS + DynamoDB
+ * Provides clean API for relational (RDS) and NoSQL (DynamoDB) databases
+ */
+export declare class Database {
+  static createPostgres(options: RDSOptions): {
+    dbInstance: RDSDBInstance
+    subnetGroup?: RDSDBSubnetGroup
+    logicalId: string
+    subnetGroupId?: string
+  };
+  static createMysql(options: RDSOptions): {
+    dbInstance: RDSDBInstance
+    subnetGroup?: RDSDBSubnetGroup
+    logicalId: string
+    subnetGroupId?: string
+  };
+  static private createRDSInstance(engine: 'postgres' | 'mysql', engineVersion: string, options: RDSOptions): {
+      dbInstance: RDSDBInstance
+      subnetGroup?: RDSDBSubnetGroup
+      logicalId: string
+      subnetGroupId?: string
+    };
+  static createReadReplica(sourceDbLogicalId: string, options: Omit<RDSOptions, 'masterUsername' | 'masterPassword' | 'databaseName'>): {
+      replica: RDSDBInstance
+      logicalId: string
+    };
+  static createParameterGroup(engine: 'postgres' | 'mysql', version: string, options: {
+      slug: string
+      environment: EnvironmentType
+      parameters?: Record<string, string>
+    }): {
+      parameterGroup: RDSDBParameterGroup
+      logicalId: string
+    };
+  static enableBackup(dbInstance: RDSDBInstance, retentionDays?: number): RDSDBInstance;
+  static createTable(options: DynamoDBTableOptions): {
+    table: DynamoDBTable
+    logicalId: string
+  };
+  static addGlobalSecondaryIndex(table: DynamoDBTable, index: GlobalSecondaryIndexOptions): DynamoDBTable;
+  static enableStreams(table: DynamoDBTable, viewType?: 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES' | 'KEYS_ONLY'): DynamoDBTable;
+  static readonly InstanceClasses: any;
+}

package/dist/modules/deployment.d.ts

@@ -0,0 +1,181 @@
+import type { CodeDeployApplication, CodeDeployDeploymentGroup, CodeDeployDeploymentConfig,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+/**
+ * Asset file with hash information
+ */
+export declare interface HashedAsset {
+  originalPath: string
+  hashedPath: string
+  hash: string
+  size: number
+  contentType: string
+}
+/**
+ * Asset manifest for deployment
+ */
+export declare interface AssetManifest {
+  version: string
+  timestamp: string
+  assets: HashedAsset[]
+  hashMap: Record<string, string>
+}
+export declare interface CodeDeployApplicationOptions {
+  slug: string
+  environment: EnvironmentType
+  applicationName?: string
+  computePlatform: 'Server' | 'Lambda' | 'ECS'
+}
+export declare interface CodeDeployDeploymentGroupOptions {
+  slug: string
+  environment: EnvironmentType
+  deploymentGroupName?: string
+  serviceRoleArn: string
+  autoScalingGroups?: string[]
+  ec2TagFilters?: Array<{
+    key?: string
+    value?: string
+    type?: 'KEY_ONLY' | 'VALUE_ONLY' | 'KEY_AND_VALUE'
+  }>
+  deploymentConfigName?: string
+  autoRollbackConfiguration?: {
+    enabled: boolean
+    events?: ('DEPLOYMENT_FAILURE' | 'DEPLOYMENT_STOP_ON_ALARM' | 'DEPLOYMENT_STOP_ON_REQUEST')[]
+  }
+  alarmConfiguration?: {
+    enabled: boolean
+    alarms?: Array<{
+      name: string
+    }>
+    ignorePollAlarmFailure?: boolean
+  }
+  loadBalancerInfo?: {
+    targetGroupInfoList?: Array<{
+      name: string
+    }>
+    elbInfoList?: Array<{
+      name: string
+    }>
+  }
+  blueGreenDeploymentConfiguration?: {
+    terminateBlueInstancesOnDeploymentSuccess?: {
+      action?: 'TERMINATE' | 'KEEP_ALIVE'
+      terminationWaitTimeInMinutes?: number
+    }
+    deploymentReadyOption?: {
+      actionOnTimeout?: 'CONTINUE_DEPLOYMENT' | 'STOP_DEPLOYMENT'
+      waitTimeInMinutes?: number
+    }
+    greenFleetProvisioningOption?: {
+      action?: 'DISCOVER_EXISTING' | 'COPY_AUTO_SCALING_GROUP'
+    }
+  }
+}
+export declare interface CodeDeployDeploymentConfigOptions {
+  slug: string
+  environment: EnvironmentType
+  deploymentConfigName?: string
+  minimumHealthyHosts?: {
+    type: 'HOST_COUNT' | 'FLEET_PERCENT'
+    value: number
+  }
+  trafficRoutingConfig?: {
+    type: 'TimeBasedCanary' | 'TimeBasedLinear' | 'AllAtOnce'
+    timeBasedCanary?: {
+      canaryPercentage: number
+      canaryInterval: number
+    }
+    timeBasedLinear?: {
+      linearPercentage: number
+      linearInterval: number
+    }
+  }
+}
+export declare interface DeploymentStrategyOptions {
+  type: 'rolling' | 'blue-green' | 'canary' | 'all-at-once'
+  batchSize?: number
+  batchPercentage?: number
+  canaryPercentage?: number
+  canaryInterval?: number
+}
+/**
+ * Deployment Module - CodeDeploy and Deployment Utilities
+ * Provides clean API for deployment infrastructure and strategies
+ */
+export declare class Deployment {
+  static createApplication(options: CodeDeployApplicationOptions): {
+    application: CodeDeployApplication
+    logicalId: string
+  };
+  static createDeploymentGroup(applicationLogicalId: string, options: CodeDeployDeploymentGroupOptions): {
+      deploymentGroup: CodeDeployDeploymentGroup
+      logicalId: string
+    };
+  static createDeploymentConfig(options: CodeDeployDeploymentConfigOptions): {
+    deploymentConfig: CodeDeployDeploymentConfig
+    logicalId: string
+  };
+  static readonly DeploymentConfigs: any;
+  static readonly TrafficRouting: any;
+  static readonly RollbackConfigs: any;
+  static readonly BlueGreenConfigs: any;
+  static readonly UseCases: any;
+  static readonly Strategies: any;
+}
+/**
+ * Asset Hashing Utilities
+ * Provides content-based hashing for cache invalidation
+ */
+export declare class AssetHasher {
+  static readonly ContentTypes: Record<string, string>;
+  static readonly NoHashPatterns: RegExp[];
+  static computeFileHash(filePath: string, algorithm?: 'md5' | 'sha256' | 'sha1'): string;
+  static computeShortHash(filePath: string): string;
+  static getContentType(filePath: string): string;
+  static shouldHashFile(relativePath: string, customNoHashPatterns?: RegExp[]): boolean;
+  static generateHashedFilename(filePath: string, hash: string): string;
+  static collectFiles(directory: string, relativeTo?: string): string[];
+  static hashDirectory(options: {
+    sourceDir: string
+    outputDir?: string
+    excludePatterns?: RegExp[]
+    hashAlgorithm?: 'md5' | 'sha256' | 'sha1'
+    copyUnhashed?: boolean
+  }): AssetManifest;
+  static getInvalidationPaths(oldManifest: AssetManifest | null, newManifest: AssetManifest): string[];
+  static updateHtmlReferences(options: {
+    htmlDir: string
+    manifest: AssetManifest
+    basePath?: string
+  }): void;
+  static updateCssReferences(options: {
+    cssDir: string
+    manifest: AssetManifest
+    basePath?: string
+  }): void;
+  static private escapeRegExp(string: string): string;
+  static generateS3DeploymentManifest(options: {
+    sourceDir: string
+    bucketName: string
+    keyPrefix?: string
+    excludePatterns?: RegExp[]
+    cacheControl?: {
+      hashed?: string
+      unhashed?: string
+      html?: string
+    }
+  }): Array<{
+    localPath: string
+    s3Key: string
+    contentType: string
+    cacheControl: string
+    hash: string
+  }>;
+  static compareManifests(oldManifest: AssetManifest, newManifest: AssetManifest): {
+    added: string[]
+    removed: string[]
+    changed: string[]
+    unchanged: string[]
+  };
+  static loadManifest(manifestPath: string): AssetManifest | null;
+  static saveManifest(manifest: AssetManifest, manifestPath: string): void;
+}

package/dist/modules/dns.d.ts

@@ -0,0 +1,45 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { Route53HostedZone, Route53RecordSet } from '@stacksjs/ts-cloud-aws-types';
+export declare interface HostedZoneOptions {
+  domain: string
+  slug: string
+  environment: EnvironmentType
+  comment?: string
+}
+export declare interface RecordOptions {
+  hostedZoneId?: string
+  hostedZoneName?: string
+  name: string
+  type: 'A' | 'AAAA' | 'CNAME' | 'MX' | 'NS' | 'PTR' | 'SOA' | 'SPF' | 'SRV' | 'TXT'
+  ttl?: number
+  values?: string[]
+  aliasTarget?: AliasTarget
+}
+export declare interface AliasTarget {
+  dnsName: string
+  hostedZoneId: string
+  evaluateTargetHealth?: boolean
+}
+/**
+ * DNS Module - Route53 Management
+ * Provides clean API for creating and configuring Route53 resources
+ */
+export declare class DNS {
+  static createHostedZone(options: HostedZoneOptions): { zone: Route53HostedZone, logicalId: string };
+  static createRecord(options: RecordOptions): { record: Route53RecordSet, logicalId: string };
+  static createCloudFrontAlias(domain: string, distributionDomainName: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createAlbAlias(domain: string, albDomainName: string, albHostedZoneId: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createCname(name: string, target: string, hostedZoneId: string, ttl?: any): { record: Route53RecordSet, logicalId: string };
+  static createWwwRedirect(domain: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createMxRecords(domain: string, mailServers: Array<{ priority: number, server: string }>, hostedZoneId: string, ttl?: any): { record: Route53RecordSet, logicalId: string };
+  static createTxtRecord(name: string, value: string, hostedZoneId: string, ttl?: any): { record: Route53RecordSet, logicalId: string };
+  static createSpfRecord(domain: string, spfValue: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createDmarcRecord(domain: string, policy: 'none' | 'quarantine' | 'reject', email: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createS3WebsiteAlias(domain: string, s3WebsiteEndpoint: string, s3HostedZoneId: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static readonly S3WebsiteHostedZoneIds: Record<string, string>;
+  static getS3WebsiteEndpoint(bucketName: string, region: string): string;
+  static createStoreRecord(domain: string, storeUrl: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createApiRecord(domain: string, apiUrl: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static createDocsRecord(domain: string, docsUrl: string, hostedZoneId: string): { record: Route53RecordSet, logicalId: string };
+  static readonly CloudFrontHostedZoneId: any;
+}