@ts-cloud/core 0.2.2 → 0.2.4

package/dist/modules/database.d.ts

@@ -0,0 +1,144 @@
+import type { DynamoDBTable, RDSDBInstance, RDSDBParameterGroup, RDSDBSubnetGroup } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+export 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 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 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 {
+    /**
+     * Create a PostgreSQL RDS instance
+     */
+    static createPostgres(options: RDSOptions): {
+        dbInstance: RDSDBInstance;
+        subnetGroup?: RDSDBSubnetGroup;
+        logicalId: string;
+        subnetGroupId?: string;
+    };
+    /**
+     * Create a MySQL RDS instance
+     */
+    static createMysql(options: RDSOptions): {
+        dbInstance: RDSDBInstance;
+        subnetGroup?: RDSDBSubnetGroup;
+        logicalId: string;
+        subnetGroupId?: string;
+    };
+    /**
+     * Create an RDS instance (internal helper)
+     */
+    private static createRDSInstance;
+    /**
+     * Create a read replica
+     */
+    static createReadReplica(sourceDbLogicalId: string, options: Omit<RDSOptions, 'masterUsername' | 'masterPassword' | 'databaseName'>): {
+        replica: RDSDBInstance;
+        logicalId: string;
+    };
+    /**
+     * Create a DB parameter group
+     */
+    static createParameterGroup(engine: 'postgres' | 'mysql', version: string, options: {
+        slug: string;
+        environment: EnvironmentType;
+        parameters?: Record<string, string>;
+    }): {
+        parameterGroup: RDSDBParameterGroup;
+        logicalId: string;
+    };
+    /**
+     * Enable backup for RDS instance
+     */
+    static enableBackup(dbInstance: RDSDBInstance, retentionDays?: number): RDSDBInstance;
+    /**
+     * Create a DynamoDB table
+     */
+    static createTable(options: DynamoDBTableOptions): {
+        table: DynamoDBTable;
+        logicalId: string;
+    };
+    /**
+     * Add a global secondary index to a DynamoDB table
+     */
+    static addGlobalSecondaryIndex(table: DynamoDBTable, index: GlobalSecondaryIndexOptions): DynamoDBTable;
+    /**
+     * Enable streams on a DynamoDB table
+     */
+    static enableStreams(table: DynamoDBTable, viewType?: 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES' | 'KEYS_ONLY'): DynamoDBTable;
+    /**
+     * Common RDS instance classes
+     */
+    static readonly InstanceClasses: {
+        readonly T3_Micro: "db.t3.micro";
+        readonly T3_Small: "db.t3.small";
+        readonly T3_Medium: "db.t3.medium";
+        readonly T3_Large: "db.t3.large";
+        readonly T4g_Micro: "db.t4g.micro";
+        readonly T4g_Small: "db.t4g.small";
+        readonly T4g_Medium: "db.t4g.medium";
+        readonly M5_Large: "db.m5.large";
+        readonly M5_XLarge: "db.m5.xlarge";
+        readonly M5_2XLarge: "db.m5.2xlarge";
+        readonly R5_Large: "db.r5.large";
+        readonly R5_XLarge: "db.r5.xlarge";
+        readonly R5_2XLarge: "db.r5.2xlarge";
+    };
+}

package/dist/modules/deployment.d.ts

@@ -0,0 +1,372 @@
+import type { CodeDeployApplication, CodeDeployDeploymentGroup, CodeDeployDeploymentConfig } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+/**
+ * Asset file with hash information
+ */
+export interface HashedAsset {
+    originalPath: string;
+    hashedPath: string;
+    hash: string;
+    size: number;
+    contentType: string;
+}
+/**
+ * Asset manifest for deployment
+ */
+export interface AssetManifest {
+    version: string;
+    timestamp: string;
+    assets: HashedAsset[];
+    hashMap: Record<string, string>;
+}
+export interface CodeDeployApplicationOptions {
+    slug: string;
+    environment: EnvironmentType;
+    applicationName?: string;
+    computePlatform: 'Server' | 'Lambda' | 'ECS';
+}
+export 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 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 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 {
+    /**
+     * Create a CodeDeploy Application
+     */
+    static createApplication(options: CodeDeployApplicationOptions): {
+        application: CodeDeployApplication;
+        logicalId: string;
+    };
+    /**
+     * Create a CodeDeploy Deployment Group
+     */
+    static createDeploymentGroup(applicationLogicalId: string, options: CodeDeployDeploymentGroupOptions): {
+        deploymentGroup: CodeDeployDeploymentGroup;
+        logicalId: string;
+    };
+    /**
+     * Create a CodeDeploy Deployment Configuration
+     */
+    static createDeploymentConfig(options: CodeDeployDeploymentConfigOptions): {
+        deploymentConfig: CodeDeployDeploymentConfig;
+        logicalId: string;
+    };
+    /**
+     * Common deployment configurations
+     */
+    static readonly DeploymentConfigs: {
+        /**
+         * All at once deployment (fastest, but downtime)
+         */
+        readonly allAtOnce: () => CodeDeployDeploymentConfigOptions["minimumHealthyHosts"];
+        /**
+         * Half at a time deployment
+         */
+        readonly halfAtATime: () => CodeDeployDeploymentConfigOptions["minimumHealthyHosts"];
+        /**
+         * One at a time deployment (slowest, but safest)
+         */
+        readonly oneAtATime: () => CodeDeployDeploymentConfigOptions["minimumHealthyHosts"];
+        /**
+         * Custom deployment configuration
+         */
+        readonly custom: (type: "HOST_COUNT" | "FLEET_PERCENT", value: number) => CodeDeployDeploymentConfigOptions["minimumHealthyHosts"];
+    };
+    /**
+     * Traffic routing configurations
+     */
+    static readonly TrafficRouting: {
+        /**
+         * All traffic at once
+         */
+        readonly allAtOnce: () => CodeDeployDeploymentConfigOptions["trafficRoutingConfig"];
+        /**
+         * Canary deployment (shift traffic in two steps)
+         */
+        readonly canary: (canaryPercentage: number, canaryInterval: number) => CodeDeployDeploymentConfigOptions["trafficRoutingConfig"];
+        /**
+         * Linear deployment (shift traffic gradually)
+         */
+        readonly linear: (linearPercentage: number, linearInterval: number) => CodeDeployDeploymentConfigOptions["trafficRoutingConfig"];
+    };
+    /**
+     * Rollback configurations
+     */
+    static readonly RollbackConfigs: {
+        /**
+         * Auto rollback on deployment failure
+         */
+        readonly onFailure: () => CodeDeployDeploymentGroupOptions["autoRollbackConfiguration"];
+        /**
+         * Auto rollback on alarm or failure
+         */
+        readonly onAlarmOrFailure: () => CodeDeployDeploymentGroupOptions["autoRollbackConfiguration"];
+        /**
+         * Auto rollback on all events
+         */
+        readonly onAllEvents: () => CodeDeployDeploymentGroupOptions["autoRollbackConfiguration"];
+        /**
+         * No auto rollback
+         */
+        readonly disabled: () => CodeDeployDeploymentGroupOptions["autoRollbackConfiguration"];
+    };
+    /**
+     * Blue/Green deployment configurations
+     */
+    static readonly BlueGreenConfigs: {
+        /**
+         * Standard blue/green with immediate termination
+         */
+        readonly standard: () => CodeDeployDeploymentGroupOptions["blueGreenDeploymentConfiguration"];
+        /**
+         * Blue/green with delayed termination
+         */
+        readonly withDelay: (terminationWaitTimeInMinutes: number) => CodeDeployDeploymentGroupOptions["blueGreenDeploymentConfiguration"];
+        /**
+         * Blue/green with manual approval
+         */
+        readonly withManualApproval: (waitTimeInMinutes: number) => CodeDeployDeploymentGroupOptions["blueGreenDeploymentConfiguration"];
+        /**
+         * Blue/green keeping old instances
+         */
+        readonly keepBlue: () => CodeDeployDeploymentGroupOptions["blueGreenDeploymentConfiguration"];
+    };
+    /**
+     * Common use cases
+     */
+    static readonly UseCases: {
+        /**
+         * Create basic EC2 deployment
+         */
+        readonly ec2Deployment: (slug: string, environment: EnvironmentType, serviceRoleArn: string, autoScalingGroups: string[]) => {
+            application: CodeDeployApplication;
+            appId: string;
+            deploymentGroup: CodeDeployDeploymentGroup;
+            groupId: string;
+        };
+        /**
+         * Create Lambda deployment with canary
+         */
+        readonly lambdaCanaryDeployment: (slug: string, environment: EnvironmentType, serviceRoleArn: string, canaryPercentage?: number, canaryInterval?: number) => {
+            application: CodeDeployApplication;
+            appId: string;
+            deploymentConfig: CodeDeployDeploymentConfig;
+            configId: string;
+            deploymentGroup: CodeDeployDeploymentGroup;
+            groupId: string;
+        };
+        /**
+         * Create ECS blue/green deployment
+         */
+        readonly ecsBlueGreenDeployment: (slug: string, environment: EnvironmentType, serviceRoleArn: string, targetGroupName: string) => {
+            application: CodeDeployApplication;
+            appId: string;
+            deploymentGroup: CodeDeployDeploymentGroup;
+            groupId: string;
+        };
+    };
+    /**
+     * Deployment strategy helpers
+     */
+    static readonly Strategies: {
+        /**
+         * Rolling deployment strategy
+         */
+        readonly rolling: (batchPercentage?: number) => DeploymentStrategyOptions;
+        /**
+         * Blue-green deployment strategy
+         */
+        readonly blueGreen: () => DeploymentStrategyOptions;
+        /**
+         * Canary deployment strategy
+         */
+        readonly canary: (canaryPercentage?: number, canaryInterval?: number) => DeploymentStrategyOptions;
+        /**
+         * All at once deployment strategy
+         */
+        readonly allAtOnce: () => DeploymentStrategyOptions;
+    };
+}
+/**
+ * Asset Hashing Utilities
+ * Provides content-based hashing for cache invalidation
+ */
+export declare class AssetHasher {
+    /**
+     * Common content types by file extension
+     */
+    static readonly ContentTypes: Record<string, string>;
+    /**
+     * Files that should NOT be hashed (typically entry points)
+     */
+    static readonly NoHashPatterns: RegExp[];
+    /**
+     * Compute hash for a file's contents
+     */
+    static computeFileHash(filePath: string, algorithm?: 'md5' | 'sha256' | 'sha1'): string;
+    /**
+     * Compute short hash (first 8 characters)
+     */
+    static computeShortHash(filePath: string): string;
+    /**
+     * Get content type for a file
+     */
+    static getContentType(filePath: string): string;
+    /**
+     * Check if a file should be hashed
+     */
+    static shouldHashFile(relativePath: string, customNoHashPatterns?: RegExp[]): boolean;
+    /**
+     * Generate a hashed filename
+     * e.g., "styles.css" -> "styles.a1b2c3d4.css"
+     */
+    static generateHashedFilename(filePath: string, hash: string): string;
+    /**
+     * Collect all files in a directory recursively
+     */
+    static collectFiles(directory: string, relativeTo?: string): string[];
+    /**
+     * Hash all assets in a directory
+     */
+    static hashDirectory(options: {
+        sourceDir: string;
+        outputDir?: string;
+        excludePatterns?: RegExp[];
+        hashAlgorithm?: 'md5' | 'sha256' | 'sha1';
+        copyUnhashed?: boolean;
+    }): AssetManifest;
+    /**
+     * Get paths that need CloudFront invalidation
+     * Compares old and new manifests to find changed files
+     */
+    static getInvalidationPaths(oldManifest: AssetManifest | null, newManifest: AssetManifest): string[];
+    /**
+     * Update HTML files to reference hashed assets
+     */
+    static updateHtmlReferences(options: {
+        htmlDir: string;
+        manifest: AssetManifest;
+        basePath?: string;
+    }): void;
+    /**
+     * Update CSS files to reference hashed assets
+     */
+    static updateCssReferences(options: {
+        cssDir: string;
+        manifest: AssetManifest;
+        basePath?: string;
+    }): void;
+    /**
+     * Escape special regex characters
+     */
+    private static escapeRegExp;
+    /**
+     * Generate a deployment manifest for S3
+     */
+    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;
+    }>;
+    /**
+     * Compare two asset manifests to detect changes
+     */
+    static compareManifests(oldManifest: AssetManifest, newManifest: AssetManifest): {
+        added: string[];
+        removed: string[];
+        changed: string[];
+        unchanged: string[];
+    };
+    /**
+     * Load an existing asset manifest from a file
+     */
+    static loadManifest(manifestPath: string): AssetManifest | null;
+    /**
+     * Save an asset manifest to a file
+     */
+    static saveManifest(manifest: AssetManifest, manifestPath: string): void;
+}

package/dist/modules/dns.d.ts

@@ -0,0 +1,143 @@
+import type { Route53HostedZone, Route53RecordSet } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+export interface HostedZoneOptions {
+    domain: string;
+    slug: string;
+    environment: EnvironmentType;
+    comment?: string;
+}
+export 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 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 {
+    /**
+     * Create a Route53 hosted zone
+     */
+    static createHostedZone(options: HostedZoneOptions): {
+        zone: Route53HostedZone;
+        logicalId: string;
+    };
+    /**
+     * Create a DNS record
+     */
+    static createRecord(options: RecordOptions): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create an A record that points to a CloudFront distribution
+     */
+    static createCloudFrontAlias(domain: string, distributionDomainName: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create an A record that points to an Application Load Balancer
+     */
+    static createAlbAlias(domain: string, albDomainName: string, albHostedZoneId: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create a CNAME record
+     */
+    static createCname(name: string, target: string, hostedZoneId: string, ttl?: number): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create www → non-www redirect using S3 and Route53
+     */
+    static createWwwRedirect(domain: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create MX records for email
+     */
+    static createMxRecords(domain: string, mailServers: Array<{
+        priority: number;
+        server: string;
+    }>, hostedZoneId: string, ttl?: number): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create TXT record (useful for domain verification, SPF, DKIM, etc.)
+     */
+    static createTxtRecord(name: string, value: string, hostedZoneId: string, ttl?: number): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create SPF record for email sending
+     */
+    static createSpfRecord(domain: string, spfValue: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create DMARC record for email authentication
+     */
+    static createDmarcRecord(domain: string, policy: 'none' | 'quarantine' | 'reject', email: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create an A record pointing to an S3 website redirect bucket
+     * Used for www to non-www redirect (or vice versa)
+     */
+    static createS3WebsiteAlias(domain: string, s3WebsiteEndpoint: string, s3HostedZoneId: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * S3 Website Hosted Zone IDs by region
+     * These are required for alias records pointing to S3 website endpoints
+     */
+    static readonly S3WebsiteHostedZoneIds: Record<string, string>;
+    /**
+     * Get S3 website endpoint for a bucket in a specific region
+     */
+    static getS3WebsiteEndpoint(bucketName: string, region: string): string;
+    /**
+     * Create a store subdomain record (e.g., for Lemon Squeezy integration)
+     */
+    static createStoreRecord(domain: string, storeUrl: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create API subdomain record
+     */
+    static createApiRecord(domain: string, apiUrl: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * Create docs subdomain record
+     */
+    static createDocsRecord(domain: string, docsUrl: string, hostedZoneId: string): {
+        record: Route53RecordSet;
+        logicalId: string;
+    };
+    /**
+     * CloudFront Hosted Zone ID (constant for all CloudFront distributions)
+     */
+    static readonly CloudFrontHostedZoneId = "Z2FDTNDATAQYW2";
+}