@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/presets/fullstack-app.ts

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

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

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

@@ -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'],
-        },
-      },
-    },
-  }
-}