@ts-cloud/core 0.2.2 → 0.2.4

package/dist/modules/sms.d.ts

@@ -0,0 +1,130 @@
+/**
+ * SMS Module for CloudFormation
+ *
+ * Provides CloudFormation resources for AWS Pinpoint SMS infrastructure
+ */
+import { handler as sendHandler } from '../sms/handlers/send';
+import { handler as receiveHandler } from '../sms/handlers/receive';
+import { handler as deliveryStatusHandler } from '../sms/handlers/delivery-status';
+export interface SmsConfig {
+    slug: string;
+    environment: string;
+    senderId?: string;
+    originationNumber?: string;
+    messageType?: 'TRANSACTIONAL' | 'PROMOTIONAL';
+    twoWayEnabled?: boolean;
+    webhookUrl?: string;
+}
+export declare class SMS {
+    /**
+     * Lambda code for SMS handlers
+     */
+    static LambdaCode: {
+        send: typeof sendHandler;
+        receive: typeof receiveHandler;
+        deliveryStatus: typeof deliveryStatusHandler;
+    };
+    /**
+     * Create Pinpoint application
+     */
+    static createPinpointApp(config: {
+        slug: string;
+        name?: string;
+    }): Record<string, any>;
+    /**
+     * Create SMS channel for Pinpoint app
+     */
+    static createSmsChannel(config: {
+        slug: string;
+        applicationId: string | {
+            Ref: string;
+        };
+        senderId?: string;
+        shortCode?: string;
+        enabled?: boolean;
+    }): Record<string, any>;
+    /**
+     * Create SMS Lambda role
+     */
+    static createSmsLambdaRole(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create SMS send Lambda function
+     */
+    static createSendLambda(config: {
+        slug: string;
+        roleArn: string | {
+            'Fn::GetAtt': string[];
+        };
+        pinpointAppId: string | {
+            Ref: string;
+        };
+        messageLogTable?: string | {
+            Ref: string;
+        };
+        senderId?: string;
+        originationNumber?: string;
+    }): Record<string, any>;
+    /**
+     * Create SMS receive Lambda function
+     */
+    static createReceiveLambda(config: {
+        slug: string;
+        roleArn: string | {
+            'Fn::GetAtt': string[];
+        };
+        optOutTable?: string | {
+            Ref: string;
+        };
+        messageLogTable?: string | {
+            Ref: string;
+        };
+        notificationTopicArn?: string | {
+            Ref: string;
+        };
+        webhookUrl?: string;
+    }): Record<string, any>;
+    /**
+     * Create delivery status Lambda function
+     */
+    static createDeliveryStatusLambda(config: {
+        slug: string;
+        roleArn: string | {
+            'Fn::GetAtt': string[];
+        };
+        messageLogTable?: string | {
+            Ref: string;
+        };
+        notificationTopicArn?: string | {
+            Ref: string;
+        };
+        webhookUrl?: string;
+    }): Record<string, any>;
+    /**
+     * Create message log DynamoDB table
+     */
+    static createMessageLogTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create opt-out DynamoDB table
+     */
+    static createOptOutTable(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create notification topic for SMS events
+     */
+    static createNotificationTopic(config: {
+        slug: string;
+    }): Record<string, any>;
+    /**
+     * Create complete SMS setup
+     */
+    static createCompleteSetup(config: SmsConfig): {
+        resources: Record<string, any>;
+        outputs: Record<string, any>;
+    };
+}
+export default SMS;

package/dist/modules/storage.d.ts

@@ -0,0 +1,344 @@
+import type { BackupPlan, BackupSelection, BackupVault, S3Bucket, S3BucketPolicy } from '@ts-cloud/aws-types';
+import type { IAMRole } from '@ts-cloud/aws-types';
+import type { EnvironmentType } from '../types';
+export interface BucketOptions {
+    name?: string;
+    bucketName?: string;
+    slug: string;
+    environment: EnvironmentType;
+    public?: boolean;
+    versioning?: boolean;
+    website?: boolean;
+    encryption?: boolean;
+    intelligentTiering?: boolean;
+    cors?: CorsRule[];
+    lifecycleRules?: LifecycleRule[];
+}
+export interface CorsRule {
+    allowedOrigins: string[];
+    allowedMethods: string[];
+    allowedHeaders?: string[];
+    maxAge?: number;
+}
+export interface LifecycleRule {
+    id: string;
+    enabled: boolean;
+    expirationDays?: number;
+    transitions?: Array<{
+        days: number;
+        storageClass: 'GLACIER' | 'DEEP_ARCHIVE' | 'INTELLIGENT_TIERING' | 'STANDARD_IA' | 'ONEZONE_IA';
+    }>;
+}
+export interface S3NotificationConfig {
+    functionArn: string | {
+        'Fn::GetAtt': [string, string];
+    };
+    events: Array<'s3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated'>;
+    filter?: {
+        prefix?: string;
+        suffix?: string;
+    };
+}
+export interface BackupPlanOptions {
+    name: string;
+    slug: string;
+    environment: EnvironmentType;
+    bucketLogicalIds: string[];
+    retentionDays: number;
+    schedule?: string;
+    vaultName?: string;
+    enableContinuousBackup?: boolean;
+    moveToColdStorageAfterDays?: number;
+}
+/**
+ * Storage Module - S3 Bucket Management
+ * Provides clean API for creating and configuring S3 buckets
+ */
+export declare class Storage {
+    /**
+     * Create an S3 bucket with the specified options
+     */
+    static createBucket(options: BucketOptions): {
+        bucket: S3Bucket;
+        bucketPolicy?: S3BucketPolicy;
+        logicalId: string;
+    };
+    /**
+     * Enable versioning on an existing bucket
+     */
+    static enableVersioning(bucket: S3Bucket): S3Bucket;
+    /**
+     * Enable website hosting on an existing bucket
+     */
+    static enableWebsiteHosting(bucket: S3Bucket, indexDocument?: string, errorDocument?: string): S3Bucket;
+    /**
+     * Set lifecycle rules on an existing bucket
+     */
+    static setLifecycleRules(bucket: S3Bucket, rules: LifecycleRule[]): S3Bucket;
+    /**
+     * Enable intelligent tiering on an existing bucket
+     */
+    static enableIntelligentTiering(bucket: S3Bucket): S3Bucket;
+    /**
+     * Add Lambda notification to bucket
+     */
+    static addLambdaNotification(bucket: S3Bucket, config: S3NotificationConfig): S3Bucket;
+    /**
+     * Common notification configurations
+     */
+    static readonly Notifications: {
+        /**
+         * Trigger Lambda on any object creation
+         */
+        onObjectCreated: (functionArn: string | {
+            "Fn::GetAtt": [string, string];
+        }) => {
+            functionArn: string | {
+                "Fn::GetAtt": [string, string];
+            };
+            events: readonly ["s3:ObjectCreated:*"];
+        };
+        /**
+         * Trigger Lambda on object deletion
+         */
+        onObjectRemoved: (functionArn: string | {
+            "Fn::GetAtt": [string, string];
+        }) => {
+            functionArn: string | {
+                "Fn::GetAtt": [string, string];
+            };
+            events: readonly ["s3:ObjectRemoved:*"];
+        };
+        /**
+         * Trigger Lambda on image uploads (jpg, png, gif)
+         */
+        onImageUpload: (functionArn: string | {
+            "Fn::GetAtt": [string, string];
+        }, prefix?: string) => {
+            functionArn: string | {
+                "Fn::GetAtt": [string, string];
+            };
+            events: readonly ["s3:ObjectCreated:*"];
+            filter: {
+                prefix: string | undefined;
+                suffix: string;
+            };
+        };
+        /**
+         * Trigger Lambda on specific file type
+         */
+        onFileType: (functionArn: string | {
+            "Fn::GetAtt": [string, string];
+        }, suffix: string, prefix?: string) => {
+            functionArn: string | {
+                "Fn::GetAtt": [string, string];
+            };
+            events: readonly ["s3:ObjectCreated:*"];
+            filter: {
+                prefix: string | undefined;
+                suffix: string;
+            };
+        };
+        /**
+         * Trigger Lambda on uploads to specific folder
+         */
+        onFolderUpload: (functionArn: string | {
+            "Fn::GetAtt": [string, string];
+        }, folder: string) => {
+            functionArn: string | {
+                "Fn::GetAtt": [string, string];
+            };
+            events: readonly ["s3:ObjectCreated:*"];
+            filter: {
+                prefix: string;
+            };
+        };
+    };
+    /**
+     * Create an AWS Backup plan for S3 buckets
+     */
+    static createBackupPlan(options: BackupPlanOptions): {
+        vault: BackupVault;
+        plan: BackupPlan;
+        selection: BackupSelection;
+        role: IAMRole;
+        vaultLogicalId: string;
+        planLogicalId: string;
+        selectionLogicalId: string;
+        roleLogicalId: string;
+    };
+    /**
+     * Common backup schedule expressions
+     */
+    static readonly BackupSchedules: {
+        HOURLY: string;
+        DAILY_5AM: string;
+        DAILY_MIDNIGHT: string;
+        WEEKLY_SUNDAY: string;
+        WEEKLY_SATURDAY: string;
+        MONTHLY_FIRST: string;
+        EVERY_12_HOURS: string;
+        EVERY_6_HOURS: string;
+    };
+    /**
+     * Common backup retention periods (in days)
+     */
+    static readonly BackupRetention: {
+        ONE_DAY: number;
+        ONE_WEEK: number;
+        TWO_WEEKS: number;
+        ONE_MONTH: number;
+        THREE_MONTHS: number;
+        SIX_MONTHS: number;
+        ONE_YEAR: number;
+        TWO_YEARS: number;
+        FIVE_YEARS: number;
+        SEVEN_YEARS: number;
+    };
+    /**
+     * Create a www redirect bucket
+     * This bucket redirects www.domain.com to domain.com (or vice versa)
+     */
+    static createWwwRedirectBucket(options: {
+        slug: string;
+        environment: EnvironmentType;
+        sourceDomain: string;
+        targetDomain: string;
+        protocol?: 'http' | 'https';
+    }): {
+        bucket: S3Bucket;
+        bucketPolicy: S3BucketPolicy;
+        logicalId: string;
+    };
+    /**
+     * Create a docs bucket (for documentation sites)
+     * Conditional creation based on docs presence
+     */
+    static createDocsBucket(options: {
+        slug: string;
+        environment: EnvironmentType;
+        domain?: string;
+    }): {
+        bucket: S3Bucket;
+        bucketPolicy?: S3BucketPolicy;
+        logicalId: string;
+    };
+    /**
+     * Create an email bucket for storing emails
+     */
+    static createEmailBucket(options: {
+        slug: string;
+        environment: EnvironmentType;
+    }): {
+        bucket: S3Bucket;
+        bucketPolicy: S3BucketPolicy;
+        logicalId: string;
+    };
+    /**
+     * Check if a docs directory exists and has content
+     */
+    static docsExist(options?: {
+        projectRoot?: string;
+        docsPaths?: string[];
+    }): {
+        exists: boolean;
+        path: string | null;
+        hasDistFolder: boolean;
+        distPath: string | null;
+    };
+    /**
+     * Conditionally create docs bucket if docs exist
+     */
+    static createDocsBucketIfExists(options: {
+        slug: string;
+        environment: EnvironmentType;
+        domain?: string;
+        projectRoot?: string;
+        docsPaths?: string[];
+    }): {
+        bucket: S3Bucket | null;
+        bucketPolicy?: S3BucketPolicy;
+        logicalId: string | null;
+        docsInfo: {
+            exists: boolean;
+            path: string | null;
+            hasDistFolder: boolean;
+            distPath: string | null;
+        };
+    };
+    /**
+     * Create private files bucket
+     * For storing private/sensitive files not accessible publicly
+     */
+    static createPrivateBucket(options: {
+        slug: string;
+        environment: EnvironmentType;
+        enableVersioning?: boolean;
+        retentionDays?: number;
+        encryptionKeyArn?: string;
+    }): {
+        bucket: S3Bucket;
+        logicalId: string;
+    };
+    /**
+     * Check if source paths exist for deployment
+     * Common paths: views/web/dist, docs/dist, private
+     */
+    static checkSourcePaths(options?: {
+        projectRoot?: string;
+        paths?: {
+            web?: string;
+            docs?: string;
+            private?: string;
+        };
+    }): {
+        web: {
+            exists: boolean;
+            path: string;
+        };
+        docs: {
+            exists: boolean;
+            path: string;
+        };
+        private: {
+            exists: boolean;
+            path: string;
+        };
+    };
+    /**
+     * Create all deployment buckets based on source paths
+     * Conditionally creates buckets only for source paths that exist
+     */
+    static createDeploymentBuckets(options: {
+        slug: string;
+        environment: EnvironmentType;
+        domain?: string;
+        projectRoot?: string;
+        paths?: {
+            web?: string;
+            docs?: string;
+            private?: string;
+        };
+    }): {
+        resources: Record<string, S3Bucket | S3BucketPolicy>;
+        created: {
+            web: boolean;
+            docs: boolean;
+            private: boolean;
+        };
+        sourcePaths: {
+            web: {
+                exists: boolean;
+                path: string;
+            };
+            docs: {
+                exists: boolean;
+                path: string;
+            };
+            private: {
+                exists: boolean;
+                path: string;
+            };
+        };
+    };
+}