@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/src/presets/microservices.ts

@@ -1,167 +0,0 @@
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-/**
- * Microservices Preset
- * Perfect for: Service-oriented architectures, distributed systems
- * Includes: Multiple ECS services + API Gateway + Service Discovery + DynamoDB
- */
-export function createMicroservicesPreset(options: {
-  name: string
-  slug: string
-  domain: string
-  services: Array<{
-    name: string
-    port: number
-    cpu?: string
-    memory?: string
-    desiredCount?: number
-  }>
-}): Partial<CloudConfig> {
-  const { name, slug, domain, services } = options
-
-  return {
-    project: {
-      name,
-      slug,
-      region: 'us-east-1',
-    },
-    mode: 'serverless',
-    environments: {
-      production: {
-        type: 'production',
-        domain,
-      },
-    },
-    infrastructure: {
-      network: {
-        vpc: {
-          cidr: '10.0.0.0/16',
-          availabilityZones: 3, // Higher availability for microservices
-          natGateways: 2,
-        },
-      },
-      compute: {
-        services: services.map(service => ({
-          name: service.name,
-          type: 'fargate',
-          taskDefinition: {
-            cpu: service.cpu || '256',
-            memory: service.memory || '512',
-            containerDefinitions: [{
-              name: service.name,
-              image: `${slug}-${service.name}:latest`,
-              portMappings: [{ containerPort: service.port }],
-              healthCheck: {
-                command: ['CMD-SHELL', `curl -f http://localhost:${service.port}/health || exit 1`],
-                interval: 30,
-                timeout: 5,
-                retries: 3,
-              },
-            }],
-          },
-          service: {
-            desiredCount: service.desiredCount || 2,
-            serviceDiscovery: {
-              enabled: true,
-              namespace: `${slug}.local`,
-            },
-            autoScaling: {
-              min: 2,
-              max: 10,
-              targetCPU: 70,
-            },
-          },
-        })),
-      },
-      apiGateway: {
-        type: 'HTTP',
-        customDomain: {
-          domain,
-          certificateArn: 'TO_BE_GENERATED',
-        },
-        cors: {
-          allowOrigins: ['*'],
-          allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
-        },
-        routes: services.map(service => ({
-          path: `/${service.name}/{proxy+}`,
-          integration: {
-            type: 'vpc-link',
-            service: service.name,
-          },
-        })),
-      },
-      databases: {
-        dynamodb: {
-          tables: Object.fromEntries(
-            services.map(service => [
-              `${slug}-${service.name}`,
-              {
-                partitionKey: { name: 'id', type: 'S' },
-                billingMode: 'PAY_PER_REQUEST',
-                streamEnabled: true,
-                pointInTimeRecovery: true,
-              },
-            ]),
-          ),
-        },
-      },
-      queues: {
-        events: {
-          fifo: false,
-          visibilityTimeout: 300,
-          messageRetentionPeriod: 345600,
-          deadLetterQueue: true,
-        },
-      },
-      messaging: {
-        topics: {
-          events: {
-            name: `${slug}-events`,
-            subscriptions: services.map(service => ({
-              protocol: 'sqs' as const,
-              endpoint: `${slug}-${service.name}-queue`,
-              filterPolicy: {
-                service: [service.name],
-              },
-            })),
-          },
-        },
-      },
-      monitoring: {
-        dashboard: {
-          name: `${slug}-microservices`,
-          widgets: services.map(service => ({
-            type: 'metric',
-            metrics: [
-              { service: service.name, metric: 'CPUUtilization' },
-              { service: service.name, metric: 'MemoryUtilization' },
-              { service: service.name, metric: 'RequestCount' },
-            ],
-          })),
-        },
-        alarms: services.flatMap(service => [{
-          name: `${service.name}-high-cpu`,
-          metric: 'CPUUtilization',
-          threshold: 80,
-          service: service.name,
-        }, {
-          name: `${service.name}-errors`,
-          metric: 'Errors',
-          threshold: 10,
-          service: service.name,
-        }]),
-      },
-      security: {
-        certificate: {
-          domain,
-          validationMethod: 'DNS',
-        },
-        waf: {
-          enabled: true,
-          rules: ['rateLimit', 'sqlInjection'],
-        },
-      },
-    },
-  }
-}

package/src/presets/ml-api.ts

@@ -1,208 +0,0 @@
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-/**
- * Machine Learning API Preset
- * Perfect for: ML inference APIs, AI-powered applications
- * Includes: SageMaker + API Gateway + Lambda + S3
- */
-export function createMLApiPreset(options: {
-  name: string
-  slug: string
-  domain?: string
-  modelS3Path?: string
-  instanceType?: string
-}): Partial<CloudConfig> {
-  const {
-    name,
-    slug,
-    domain,
-    modelS3Path = `s3://${slug}-models/`,
-    instanceType = 'ml.t3.medium',
-  } = options
-
-  return {
-    project: {
-      name,
-      slug,
-      region: 'us-east-1',
-    },
-    mode: 'serverless',
-    environments: {
-      production: {
-        type: 'production',
-        domain,
-      },
-    },
-    infrastructure: {
-      storage: {
-        models: {
-          public: false,
-          versioning: true,
-          encryption: true,
-          intelligentTiering: true,
-        },
-        datasets: {
-          public: false,
-          versioning: true,
-          encryption: true,
-          lifecycleRules: [{
-            id: 'ArchiveOldDatasets',
-            enabled: true,
-            transitions: [{
-              days: 90,
-              storageClass: 'GLACIER',
-            }],
-          }],
-        },
-        predictions: {
-          public: false,
-          versioning: false,
-          encryption: true,
-          lifecycleRules: [{
-            id: 'DeleteOldPredictions',
-            enabled: true,
-            expirationDays: 30,
-          }],
-        },
-      },
-      machineLearning: {
-        sagemaker: {
-          endpoints: [{
-            name: `${slug}-inference`,
-            modelS3Path,
-            instanceType,
-            initialInstanceCount: 1,
-            autoScaling: {
-              minInstances: 1,
-              maxInstances: 5,
-              targetInvocationsPerInstance: 1000,
-            },
-          }],
-          trainingJobs: [{
-            name: `${slug}-training`,
-            algorithmSpecification: {
-              trainingImage: 'TO_BE_SPECIFIED',
-              trainingInputMode: 'File',
-            },
-            instanceType: 'ml.p3.2xlarge',
-            instanceCount: 1,
-            volumeSizeInGB: 50,
-            maxRuntimeInSeconds: 86400, // 24 hours
-          }],
-        },
-      },
-      apiGateway: {
-        type: 'HTTP',
-        customDomain: domain ? {
-          domain,
-          certificateArn: 'TO_BE_GENERATED',
-        } : undefined,
-        cors: {
-          allowOrigins: ['*'],
-          allowMethods: ['POST'],
-          allowHeaders: ['Content-Type', 'Authorization'],
-        },
-        throttling: {
-          rateLimit: 1000,
-          burstLimit: 500,
-        },
-      },
-      functions: {
-        predict: {
-          runtime: 'python3.11',
-          handler: 'handlers/predict.handler',
-          memory: 2048,
-          timeout: 60,
-          events: [{
-            type: 'http',
-            path: '/predict',
-            method: 'POST',
-          }],
-          environment: {
-            SAGEMAKER_ENDPOINT: `${slug}-inference`,
-            MODEL_BUCKET: `${slug}-models`,
-          },
-        },
-        'batch-predict': {
-          runtime: 'python3.11',
-          handler: 'handlers/batchPredict.handler',
-          memory: 3008,
-          timeout: 900, // 15 minutes
-          events: [{
-            type: 's3',
-            bucket: `${slug}-datasets`,
-            suffix: '.csv',
-          }],
-        },
-        'trigger-training': {
-          runtime: 'python3.11',
-          handler: 'handlers/training.handler',
-          memory: 1024,
-          timeout: 300,
-          events: [{
-            type: 'schedule',
-            expression: 'cron(0 2 * * ? *)', // Daily at 2 AM
-          }],
-        },
-      },
-      databases: {
-        dynamodb: {
-          tables: {
-            [`${slug}-predictions`]: {
-              partitionKey: { name: 'requestId', type: 'S' },
-              sortKey: { name: 'timestamp', type: 'S' },
-              billingMode: 'PAY_PER_REQUEST',
-              streamEnabled: true,
-            },
-            [`${slug}-models`]: {
-              partitionKey: { name: 'modelId', type: 'S' },
-              sortKey: { name: 'version', type: 'S' },
-              billingMode: 'PAY_PER_REQUEST',
-            },
-          },
-        },
-      },
-      queues: {
-        predictions: {
-          fifo: false,
-          visibilityTimeout: 300,
-          messageRetentionPeriod: 86400, // 1 day
-          deadLetterQueue: true,
-        },
-      },
-      monitoring: {
-        dashboard: {
-          name: `${slug}-ml`,
-          widgets: [{
-            type: 'metric',
-            metrics: [
-              'SageMakerInvocations',
-              'SageMakerModelLatency',
-              'APIGatewayRequests',
-              'LambdaErrors',
-            ],
-          }],
-        },
-        alarms: [{
-          metric: 'SageMakerModelLatency',
-          threshold: 1000, // 1 second
-          evaluationPeriods: 2,
-        }, {
-          metric: 'SageMakerInvocationErrors',
-          threshold: 10,
-          evaluationPeriods: 1,
-        }],
-      },
-      security: {
-        certificate: domain ? {
-          domain,
-          validationMethod: 'DNS',
-        } : undefined,
-        waf: {
-          enabled: true,
-          rules: ['rateLimit', 'apiProtection'],
-        },
-      },
-    },
-  }
-}

package/src/presets/nodejs-server.ts

@@ -1,104 +0,0 @@
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-/**
- * Node.js Server Preset
- * Perfect for: Traditional Node.js applications, API servers
- * Includes: EC2 instances + ALB + Auto Scaling + RDS + Redis
- */
-export function createNodeJsServerPreset(options: {
-  name: string
-  slug: string
-  domain?: string
-  instanceType?: string
-  minInstances?: number
-  maxInstances?: number
-}): Partial<CloudConfig> {
-  const {
-    name,
-    slug,
-    domain,
-    instanceType = 't3.small',
-    minInstances = 2,
-    maxInstances = 10,
-  } = options
-
-  return {
-    project: {
-      name,
-      slug,
-      region: 'us-east-1',
-    },
-    mode: 'server',
-    environments: {
-      production: {
-        type: 'production',
-        domain,
-      },
-    },
-    infrastructure: {
-      network: {
-        vpc: {
-          cidr: '10.0.0.0/16',
-          availabilityZones: 2,
-          natGateways: 1, // Cost-effective: 1 NAT for both AZs
-        },
-      },
-      compute: {
-        server: {
-          instanceType,
-          ami: 'ubuntu-22.04',
-          keyPair: `${slug}-key`,
-          autoScaling: {
-            min: minInstances,
-            max: maxInstances,
-            desired: minInstances,
-            targetCPU: 70,
-          },
-          loadBalancer: {
-            type: 'application',
-            healthCheck: {
-              path: '/health',
-              interval: 30,
-              timeout: 5,
-              healthyThreshold: 2,
-              unhealthyThreshold: 3,
-            },
-          },
-          userData: {
-            packages: ['nodejs', 'npm', 'nginx'],
-            commands: [
-              'curl -fsSL https://bun.sh/install | bash',
-              'npm install -g pm2',
-            ],
-          },
-        },
-      },
-      databases: {
-        postgres: {
-          engine: 'postgres',
-          version: '15',
-          instanceClass: 'db.t3.micro',
-          allocatedStorage: 20,
-          multiAZ: true,
-          backupRetentionDays: 7,
-          deletionProtection: true,
-        },
-      },
-      cache: {
-        redis: {
-          nodeType: 'cache.t3.micro',
-          numCacheNodes: 1,
-          engine: 'redis',
-          engineVersion: '7.0',
-        },
-      },
-      security: {
-        certificate: domain ? {
-          domain,
-          subdomains: [`*.${domain}`],
-          validationMethod: 'DNS',
-        } : undefined,
-      },
-    },
-  }
-}

package/src/presets/nodejs-serverless.ts

@@ -1,114 +0,0 @@
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-/**
- * Node.js Serverless Preset
- * Perfect for: Serverless APIs, microservices
- * Includes: ECS Fargate + ALB + DynamoDB + Lambda functions
- */
-export function createNodeJsServerlessPreset(options: {
-  name: string
-  slug: string
-  domain?: string
-  taskCpu?: string
-  taskMemory?: string
-  desiredCount?: number
-}): Partial<CloudConfig> {
-  const {
-    name,
-    slug,
-    domain,
-    taskCpu = '256', // 0.25 vCPU
-    taskMemory = '512', // 512 MB
-    desiredCount = 2,
-  } = options
-
-  return {
-    project: {
-      name,
-      slug,
-      region: 'us-east-1',
-    },
-    mode: 'serverless',
-    environments: {
-      production: {
-        type: 'production',
-        domain,
-      },
-    },
-    infrastructure: {
-      network: {
-        vpc: {
-          cidr: '10.0.0.0/16',
-          availabilityZones: 2,
-          natGateways: 0, // Fargate can use public subnets or VPC endpoints
-        },
-      },
-      compute: {
-        fargate: {
-          taskDefinition: {
-            cpu: taskCpu,
-            memory: taskMemory,
-            containerDefinitions: [{
-              name: 'app',
-              image: `${slug}-app:latest`,
-              portMappings: [{ containerPort: 3000 }],
-              environment: [],
-              secrets: [],
-            }],
-          },
-          service: {
-            desiredCount,
-            healthCheck: {
-              path: '/health',
-              interval: 30,
-              timeout: 5,
-              healthyThreshold: 2,
-              unhealthyThreshold: 3,
-            },
-            autoScaling: {
-              min: desiredCount,
-              max: desiredCount * 5,
-              targetCPU: 70,
-              targetMemory: 80,
-            },
-          },
-          loadBalancer: {
-            type: 'application',
-          },
-        },
-      },
-      databases: {
-        dynamodb: {
-          tables: {
-            [`${slug}-main`]: {
-              partitionKey: { name: 'id', type: 'S' },
-              sortKey: { name: 'createdAt', type: 'S' },
-              billingMode: 'PAY_PER_REQUEST',
-              streamEnabled: true,
-              pointInTimeRecovery: true,
-            },
-          },
-        },
-      },
-      functions: {
-        'process-queue': {
-          runtime: 'nodejs20.x',
-          handler: 'dist/workers/queue.handler',
-          memory: 512,
-          timeout: 60,
-          events: [{
-            type: 'sqs',
-            queueName: `${slug}-queue`,
-          }],
-        },
-      },
-      security: {
-        certificate: domain ? {
-          domain,
-          subdomains: [`*.${domain}`],
-          validationMethod: 'DNS',
-        } : undefined,
-      },
-    },
-  }
-}