@stacksjs/ts-cloud-core 0.1.1

package/src/presets/fullstack-app.ts

@@ -0,0 +1,144 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * Full Stack App Preset
+ * Perfect for: Complete web applications with frontend and API
+ * Includes: S3 + CloudFront (frontend) + ECS Fargate (API) + RDS + Redis
+ */
+export function createFullStackAppPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  apiSubdomain?: string
+}): Partial<CloudConfig> {
+  const {
+    name,
+    slug,
+    domain,
+    apiSubdomain = 'api',
+  } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1',
+    },
+    mode: 'hybrid',
+    environments: {
+      production: {
+        type: 'production',
+        domain,
+      },
+    },
+    infrastructure: {
+      network: {
+        vpc: {
+          cidr: '10.0.0.0/16',
+          availabilityZones: 2,
+          natGateways: 1,
+        },
+      },
+      // Frontend: S3 + CloudFront
+      storage: {
+        frontend: {
+          public: true,
+          versioning: true,
+          website: true,
+          encryption: false,
+        },
+      },
+      cdn: {
+        enabled: true,
+        customDomain: {
+          domain,
+          certificateArn: 'TO_BE_GENERATED',
+        },
+        cachePolicy: {
+          minTTL: 0,
+          defaultTTL: 86400,
+          maxTTL: 31536000,
+        },
+        compress: true,
+        http3: true,
+        errorPages: {
+          404: '/index.html',
+        },
+      },
+      // Backend: ECS Fargate
+      compute: {
+        fargate: {
+          taskDefinition: {
+            cpu: '512',
+            memory: '1024',
+            containerDefinitions: [{
+              name: 'api',
+              image: `${slug}-api:latest`,
+              portMappings: [{ containerPort: 3000 }],
+            }],
+          },
+          service: {
+            desiredCount: 2,
+            healthCheck: {
+              path: '/api/health',
+              interval: 30,
+            },
+            autoScaling: {
+              min: 2,
+              max: 10,
+              targetCPU: 70,
+            },
+          },
+          loadBalancer: {
+            type: 'application',
+            customDomain: {
+              domain: `${apiSubdomain}.${domain}`,
+              certificateArn: 'TO_BE_GENERATED',
+            },
+          },
+        },
+      },
+      // Database: PostgreSQL
+      databases: {
+        postgres: {
+          engine: 'postgres',
+          version: '15',
+          instanceClass: 'db.t3.small',
+          allocatedStorage: 50,
+          multiAZ: true,
+          backupRetentionDays: 14,
+          deletionProtection: true,
+        },
+      },
+      // Cache: Redis
+      cache: {
+        redis: {
+          nodeType: 'cache.t3.small',
+          numCacheNodes: 2,
+          engine: 'redis',
+          engineVersion: '7.0',
+        },
+      },
+      // Queue for async jobs
+      queues: {
+        jobs: {
+          fifo: false,
+          visibilityTimeout: 300,
+          messageRetentionPeriod: 345600, // 4 days
+          deadLetterQueue: true,
+        },
+      },
+      security: {
+        certificate: {
+          domain,
+          subdomains: [`*.${domain}`],
+          validationMethod: 'DNS',
+        },
+        waf: {
+          enabled: true,
+          rules: ['rateLimit', 'sqlInjection', 'xss'],
+        },
+      },
+    },
+  }
+}

package/src/presets/index.ts

@@ -0,0 +1,27 @@
+// Preset creators
+export { createStaticSitePreset } from './static-site'
+export { createNodeJsServerPreset } from './nodejs-server'
+export { createNodeJsServerlessPreset } from './nodejs-serverless'
+export { createFullStackAppPreset } from './fullstack-app'
+export { createApiBackendPreset } from './api-backend'
+export { createWordPressPreset } from './wordpress'
+export { createJamstackPreset } from './jamstack'
+export { createMicroservicesPreset } from './microservices'
+export { createRealtimeAppPreset } from './realtime-app'
+export { createDataPipelinePreset } from './data-pipeline'
+export { createMLApiPreset } from './ml-api'
+export { createTraditionalWebAppPreset } from './traditional-web-app'
+
+// Preset extension utilities
+export {
+  extendPreset,
+  composePresets,
+  createPreset,
+  mergeInfrastructure,
+  withMonitoring,
+  withSecurity,
+  withDatabase,
+  withCache,
+  withCDN,
+  withQueue,
+} from './extend'

package/src/presets/jamstack.ts

@@ -0,0 +1,135 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+
+/**
+ * Jamstack Site Preset
+ * Perfect for: Modern static sites with API routes, Next.js, Astro, SvelteKit
+ * Includes: S3 + CloudFront + Lambda@Edge for SSR/ISR
+ */
+export function createJamstackPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  apiDomain?: string
+}): Partial<CloudConfig> {
+  const {
+    name,
+    slug,
+    domain,
+    apiDomain,
+  } = options
+
+  return {
+    project: {
+      name,
+      slug,
+      region: 'us-east-1', // Lambda@Edge requires us-east-1
+    },
+    mode: 'serverless',
+    environments: {
+      production: {
+        type: 'production',
+        domain,
+      },
+    },
+    infrastructure: {
+      storage: {
+        static: {
+          public: true,
+          versioning: true,
+          website: true,
+          encryption: false,
+          cors: [{
+            allowedOrigins: ['*'],
+            allowedMethods: ['GET', 'HEAD'],
+          }],
+          lifecycleRules: [{
+            id: 'DeleteOldVersions',
+            enabled: true,
+            expirationDays: 90, // Clean up old versions after 90 days
+          }],
+        },
+      },
+      cdn: {
+        enabled: true,
+        customDomain: {
+          domain,
+          certificateArn: 'TO_BE_GENERATED',
+        },
+        cachePolicy: {
+          minTTL: 0,
+          defaultTTL: 0, // Let Next.js/framework control caching
+          maxTTL: 31536000,
+        },
+        compress: true,
+        http3: true,
+        errorPages: {
+          404: '/404.html',
+          500: '/500.html',
+        },
+        // Lambda@Edge for SSR/ISR
+        edgeFunctions: [{
+          eventType: 'origin-request',
+          functionArn: 'TO_BE_CREATED',
+          name: 'ssr-handler',
+        }],
+      },
+      functions: {
+        ssr: {
+          runtime: 'nodejs20.x',
+          handler: 'dist/edge/ssr.handler',
+          memory: 512,
+          timeout: 5, // Edge functions have strict limits
+        },
+        // API routes as Lambda functions
+        ...(apiDomain ? {
+          api: {
+            runtime: 'nodejs20.x',
+            handler: 'dist/api/index.handler',
+            memory: 1024,
+            timeout: 30,
+            events: [{
+              type: 'http',
+              path: '/{proxy+}',
+              method: 'ANY',
+            }],
+          },
+        } : {}),
+      },
+      apiGateway: apiDomain ? {
+        type: 'HTTP',
+        customDomain: {
+          domain: apiDomain,
+          certificateArn: 'TO_BE_GENERATED',
+        },
+        cors: {
+          allowOrigins: [domain],
+          allowMethods: ['GET', 'POST', 'PUT', 'DELETE'],
+          allowHeaders: ['Content-Type', 'Authorization'],
+        },
+      } : undefined,
+      databases: {
+        dynamodb: {
+          tables: {
+            content: {
+              partitionKey: { name: 'id', type: 'S' },
+              sortKey: { name: 'type', type: 'S' },
+              billingMode: 'PAY_PER_REQUEST',
+              streamEnabled: false,
+            },
+          },
+        },
+      },
+      security: {
+        certificate: {
+          domain,
+          subdomains: apiDomain ? [apiDomain] : [],
+          validationMethod: 'DNS',
+        },
+        waf: {
+          enabled: true,
+          rules: ['rateLimit', 'geoBlock'],
+        },
+      },
+    },
+  }
+}

package/src/presets/microservices.ts

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

@@ -0,0 +1,208 @@
+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'],
+        },
+      },
+    },
+  }
+}