@ts-cloud/core 0.2.2 → 0.2.4

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

@@ -0,0 +1,68 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface LoadBalancerConfig {
+    type: 'application' | 'network';
+    healthCheck?: {
+        path?: string;
+        interval?: number;
+        timeout?: number;
+        healthyThreshold?: number;
+        unhealthyThreshold?: number;
+    };
+    stickySession?: {
+        enabled: boolean;
+        duration?: number;
+    };
+}
+export interface ServerConfig {
+    instanceType: string;
+    ami?: string;
+    autoScaling?: {
+        min: number;
+        max: number;
+        targetCPU?: number;
+        scaleUpCooldown?: number;
+        scaleDownCooldown?: number;
+    };
+    loadBalancer?: LoadBalancerConfig;
+    userData?: string;
+}
+export 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;
+    }>;
+}
+/**
+ * Add compute resources (EC2, ECS, ALB) to CloudFormation template
+ */
+export declare function addComputeResources(builder: CloudFormationBuilder, config: ComputeConfig): void;

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

@@ -0,0 +1,61 @@
+import type { CloudFormationBuilder } from '../builder';
+export 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 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[];
+    }>;
+}
+/**
+ * Add database resources (RDS, DynamoDB) to CloudFormation template
+ */
+export declare function addDatabaseResources(builder: CloudFormationBuilder, config: DatabaseConfig): void;

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

@@ -0,0 +1,32 @@
+import type { CloudFormationBuilder } from '../builder';
+export 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 interface FunctionItem {
+    name: string;
+    runtime: string;
+    handler: string;
+    memory: number;
+    timeout: number;
+    events?: FunctionEvent[];
+    environment?: Record<string, string>;
+}
+export interface FunctionsConfig {
+    [category: string]: FunctionItem[];
+}
+/**
+ * Add Lambda function resources to CloudFormation template
+ */
+export declare function addFunctionResources(builder: CloudFormationBuilder, config: FunctionsConfig): void;

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

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

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

@@ -0,0 +1,39 @@
+import type { CloudFormationBuilder } from '../builder';
+export 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 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[];
+    };
+}
+/**
+ * Add CloudWatch monitoring resources to CloudFormation template
+ */
+export declare function addMonitoringResources(builder: CloudFormationBuilder, config: MonitoringConfig): void;

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

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

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

@@ -0,0 +1,16 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface QueueConfig {
+    [queueName: string]: {
+        fifo?: boolean;
+        visibilityTimeout?: number;
+        messageRetentionPeriod?: number;
+        receiveMessageWaitTime?: number;
+        deadLetterQueue?: boolean;
+        maxReceiveCount?: number;
+        contentBasedDeduplication?: boolean;
+    };
+}
+/**
+ * Add SQS queue resources to CloudFormation template
+ */
+export declare function addQueueResources(builder: CloudFormationBuilder, config: QueueConfig): void;

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

@@ -0,0 +1,31 @@
+import type { CloudFormationBuilder } from '../builder';
+export 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;
+        }>;
+    }>;
+}
+/**
+ * Add security resources (ACM certificates, WAF, security groups) to CloudFormation template
+ */
+export declare function addSecurityResources(builder: CloudFormationBuilder, config: SecurityConfig): void;

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

@@ -0,0 +1,36 @@
+import type { CloudFormationBuilder } from '../builder';
+export interface StorageConfig {
+    [bucketName: string]: {
+        public?: boolean;
+        versioning?: boolean;
+        website?: boolean;
+        encryption?: boolean;
+        intelligentTiering?: boolean;
+        cors?: Array<{
+            allowedOrigins: string[];
+            allowedMethods: string[];
+            allowedHeaders?: string[];
+            maxAge?: number;
+        }>;
+        lifecycleRules?: Array<{
+            id: string;
+            enabled: boolean;
+            expirationDays?: number;
+            transitions?: Array<{
+                days: number;
+                storageClass: 'STANDARD_IA' | 'ONEZONE_IA' | 'INTELLIGENT_TIERING' | 'GLACIER' | 'DEEP_ARCHIVE';
+            }>;
+        }>;
+        type?: 'efs';
+        performanceMode?: 'generalPurpose' | 'maxIO';
+        throughputMode?: 'bursting' | 'provisioned';
+        lifecyclePolicy?: {
+            transitionToIA?: number;
+            transitionToPrimaryStorageClass?: number;
+        };
+    };
+}
+/**
+ * Add S3 and EFS storage resources to CloudFormation template
+ */
+export declare function addStorageResources(builder: CloudFormationBuilder, config: StorageConfig): void;

package/dist/cloudformation/index.d.ts

@@ -0,0 +1,10 @@
+export { CloudFormationBuilder, buildCloudFormationTemplate, } from './builder';
+export type { CloudFormationTemplate, CloudFormationResource, CloudFormationParameter, CloudFormationOutput, CloudFormationCondition, CloudFormationIntrinsicFunction, } from './types';
+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';
+export type { QueueConfig } from './builders/queue';

package/dist/cloudformation/types.d.ts

@@ -0,0 +1,200 @@
+/**
+ * CloudFormation Template Types
+ * Based on AWS CloudFormation Resource Specification
+ */
+export 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 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 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 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[];
+};
+/**
+ * Helper functions for creating CloudFormation intrinsic functions
+ */
+export declare const Fn: {
+    ref: (logicalId: string) => {
+        Ref: string;
+    };
+    getAtt: (logicalId: string, attribute: string) => {
+        "Fn::GetAtt": [string, string];
+    };
+    join: (delimiter: string, values: any[]) => {
+        "Fn::Join": [string, any[]];
+    };
+    sub: (template: string, variables?: Record<string, any>) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    select: (index: number, list: any[] | CloudFormationIntrinsicFunction) => {
+        "Fn::Select": [number, any[] | CloudFormationIntrinsicFunction];
+    };
+    split: (delimiter: string, source: string) => {
+        "Fn::Split": [string, string];
+    };
+    getAZs: (region?: string) => {
+        "Fn::GetAZs": string;
+    };
+    importValue: (name: any) => {
+        "Fn::ImportValue": any;
+    };
+    findInMap: (mapName: string, topLevelKey: any, secondLevelKey: any) => {
+        "Fn::FindInMap": [string, any, any];
+    };
+    base64: (value: any) => {
+        "Fn::Base64": any;
+    };
+    cidr: (ipBlock: any, count: number, cidrBits: number) => {
+        "Fn::Cidr": [any, number, number];
+    };
+    equals: (value1: any, value2: any) => {
+        "Fn::Equals": [any, any];
+    };
+    if: (conditionName: string, trueValue: any, falseValue: any) => {
+        "Fn::If": [string, any, any];
+    };
+    not: (condition: any) => {
+        "Fn::Not": [any];
+    };
+    and: (...conditions: any[]) => {
+        "Fn::And": any[];
+    };
+    or: (...conditions: any[]) => {
+        "Fn::Or": any[];
+    };
+};
+/**
+ * Common AWS resource ARN patterns
+ */
+export declare const Arn: {
+    s3Bucket: (bucketName: any) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    s3Object: (bucketName: any, key?: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    lambda: (functionName: string, region?: string, account?: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    dynamodb: (tableName: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    sqs: (queueName: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    sns: (topicName: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    kinesis: (streamName: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    iam: (resourceType: "role" | "policy" | "user" | "group", name: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    secretsManager: (secretName: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+    cloudwatch: (logGroup: string) => {
+        "Fn::Sub": string | [string, Record<string, any>];
+    };
+};
+/**
+ * Common CloudFormation pseudo parameters
+ */
+export declare const AWS_PSEUDO_PARAMETERS: {
+    ACCOUNT_ID: {
+        Ref: string;
+    };
+    NOTIFICATION_ARNS: {
+        Ref: string;
+    };
+    NO_VALUE: {
+        Ref: string;
+    };
+    PARTITION: {
+        Ref: string;
+    };
+    REGION: {
+        Ref: string;
+    };
+    STACK_ID: {
+        Ref: string;
+    };
+    STACK_NAME: {
+        Ref: string;
+    };
+    URL_SUFFIX: {
+        Ref: string;
+    };
+};