@stacksjs/ts-cloud-core 0.1.1

package/src/presets/nodejs-server.ts

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,114 @@
+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,
+      },
+    },
+  }
+}

package/src/presets/realtime-app.ts

@@ -0,0 +1,184 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * Real-time App Preset
+ * Perfect for: Chat apps, collaborative tools, live dashboards, gaming backends
+ * Includes: API Gateway WebSocket + Lambda + DynamoDB Streams
+ */
+export function createRealtimeAppPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+}): Partial<CloudConfig> {
+  const { name, slug, domain } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1',
+    },
+    mode: 'serverless',
+    environments: {
+      production: {
+        type: 'production',
+        domain,
+      },
+    },
+    infrastructure: {
+      apiGateway: {
+        type: 'websocket',
+        customDomain: domain ? {
+          domain,
+          certificateArn: 'TO_BE_GENERATED',
+        } : undefined,
+        routes: [
+          {
+            path: '$connect',
+            method: 'WEBSOCKET',
+            integration: 'websocket-connect',
+          },
+          {
+            path: '$disconnect',
+            method: 'WEBSOCKET',
+            integration: 'websocket-disconnect',
+          },
+          {
+            path: '$default',
+            method: 'WEBSOCKET',
+            integration: 'websocket-default',
+          },
+          {
+            path: 'sendMessage',
+            method: 'WEBSOCKET',
+            integration: 'websocket-send-message',
+          },
+          {
+            path: 'joinRoom',
+            method: 'WEBSOCKET',
+            integration: 'websocket-join-room',
+          },
+        ],
+      },
+      functions: {
+        connect: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/websocket/connect.handler',
+          memory: 512,
+          timeout: 30,
+        },
+        disconnect: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/websocket/disconnect.handler',
+          memory: 512,
+          timeout: 30,
+        },
+        default: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/websocket/default.handler',
+          memory: 512,
+          timeout: 30,
+        },
+        'send-message': {
+          runtime: 'nodejs20.x',
+          handler: 'dist/websocket/sendMessage.handler',
+          memory: 512,
+          timeout: 30,
+        },
+        'join-room': {
+          runtime: 'nodejs20.x',
+          handler: 'dist/websocket/joinRoom.handler',
+          memory: 512,
+          timeout: 30,
+        },
+        // Stream processor for broadcasting
+        broadcast: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/streams/broadcast.handler',
+          memory: 1024,
+          timeout: 60,
+          events: [{
+            type: 'dynamodb-stream',
+            tableName: `${slug}-messages`,
+            startingPosition: 'LATEST',
+            batchSize: 100,
+          }],
+        },
+      },
+      databases: {
+        dynamodb: {
+          tables: {
+            [`${slug}-connections`]: {
+              partitionKey: { name: 'connectionId', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+              globalSecondaryIndexes: [{
+                name: 'RoomIndex',
+                partitionKey: { name: 'roomId', type: 'S' },
+                sortKey: { name: 'connectionId', type: 'S' },
+                projection: 'ALL',
+              }],
+            },
+            [`${slug}-messages`]: {
+              partitionKey: { name: 'roomId', type: 'S' },
+              sortKey: { name: 'timestamp', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+              streamEnabled: true,
+              pointInTimeRecovery: true,
+              globalSecondaryIndexes: [{
+                name: 'UserIndex',
+                partitionKey: { name: 'userId', type: 'S' },
+                sortKey: { name: 'timestamp', type: 'S' },
+                projection: 'ALL',
+              }],
+            },
+            [`${slug}-rooms`]: {
+              partitionKey: { name: 'roomId', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+            },
+          },
+        },
+      },
+      cache: {
+        elasticache: {
+          nodeType: 'cache.t3.small',
+          numCacheNodes: 2,
+          engine: 'redis',
+          engineVersion: '7.0',
+          // For connection state and rate limiting
+        },
+      },
+      monitoring: {
+        alarms: [{
+          metric: 'WebSocketConnections',
+          threshold: 10000,
+          evaluationPeriods: 1,
+        }, {
+          metric: 'IntegrationLatency',
+          threshold: 1000, // 1 second
+          evaluationPeriods: 2,
+        }],
+        dashboard: {
+          name: `${slug}-realtime`,
+          widgets: [{
+            type: 'metric',
+            metrics: [
+              'WebSocketConnections',
+              'MessagesSent',
+              'IntegrationLatency',
+            ],
+          }],
+        },
+      },
+      security: {
+        certificate: domain ? {
+          domain,
+          validationMethod: 'DNS',
+        } : undefined,
+        waf: {
+          enabled: true,
+          rules: ['rateLimit', 'connectionLimit'],
+        },
+      },
+    },
+  }
+}

package/src/presets/static-site.ts

@@ -0,0 +1,64 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * Static Site Preset
+ * Perfect for: Static websites, SPAs, documentation sites
+ * Includes: S3 bucket + CloudFront CDN
+ */
+export function createStaticSitePreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  subdomain?: string
+}): Partial<CloudConfig> {
+  const { name, slug, domain, subdomain } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1', // CloudFront requires ACM certs in us-east-1
+    },
+    mode: 'serverless',
+    environments: {
+      production: {
+        type: 'production',
+        domain: subdomain && domain ? `${subdomain}.${domain}` : domain,
+      },
+    },
+    infrastructure: {
+      storage: {
+        assets: {
+          public: true,
+          versioning: false,
+          website: true,
+          encryption: false, // Public bucket doesn't need encryption
+          cors: [{
+            allowedOrigins: ['*'],
+            allowedMethods: ['GET', 'HEAD'],
+            allowedHeaders: ['*'],
+            maxAge: 3600,
+          }],
+        },
+      },
+      cdn: {
+        enabled: true,
+        customDomain: domain ? {
+          domain: subdomain && domain ? `${subdomain}.${domain}` : domain,
+          certificateArn: 'TO_BE_GENERATED', // Will be created automatically
+        } : undefined,
+        cachePolicy: {
+          minTTL: 0,
+          defaultTTL: 86400, // 1 day
+          maxTTL: 31536000, // 1 year
+        },
+        compress: true,
+        http3: true,
+        errorPages: {
+          404: '/index.html', // For SPA routing
+          403: '/index.html',
+        },
+      },
+    },
+  }
+}