@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/presets/extend.d.ts

@@ -0,0 +1,194 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * Extend a base preset with custom configuration
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createNodeJsServerPreset({ name: 'My App', slug: 'my-app' }),
+ *   {
+ *     infrastructure: {
+ *       compute: {
+ *         server: {
+ *           instanceType: 't3.large', // Override instance type
+ *           autoScaling: {
+ *             max: 20, // Increase max instances
+ *           },
+ *         },
+ *       },
+ *       database: {
+ *         postgres: {
+ *           instanceClass: 'db.r6g.xlarge', // Upgrade database
+ *         },
+ *       },
+ *     },
+ *   }
+ * )
+ * ```
+ */
+export declare function extendPreset(basePreset: Partial<CloudConfig>, extensions: Partial<CloudConfig>): Partial<CloudConfig>;
+/**
+ * Compose multiple presets together
+ * Later presets override earlier ones
+ *
+ * @example
+ * ```typescript
+ * const composedPreset = composePresets(
+ *   createStaticSitePreset({ name: 'Site', slug: 'site', domain: 'example.com' }),
+ *   createApiBackendPreset({ name: 'API', slug: 'api' }),
+ *   {
+ *     // Custom overrides
+ *     infrastructure: {
+ *       monitoring: {
+ *         alarms: [{ metric: 'CustomMetric', threshold: 100 }],
+ *       },
+ *     },
+ *   }
+ * )
+ * ```
+ */
+export declare function composePresets(...presets: Partial<CloudConfig>[]): Partial<CloudConfig>;
+/**
+ * Create a custom preset by extending an existing one
+ *
+ * @example
+ * ```typescript
+ * const createMyCustomPreset = createPreset(
+ *   (options) => createNodeJsServerPreset(options),
+ *   {
+ *     infrastructure: {
+ *       monitoring: {
+ *         dashboard: {
+ *           name: 'custom-dashboard',
+ *           widgets: [{ type: 'metric', metrics: ['CustomMetric'] }],
+ *         },
+ *       },
+ *     },
+ *   }
+ * )
+ *
+ * // Use it
+ * const myPreset = createMyCustomPreset({ name: 'App', slug: 'app' })
+ * ```
+ */
+export declare function createPreset<TOptions extends Record<string, any>>(basePresetFn: (options: TOptions) => Partial<CloudConfig>, extensions: Partial<CloudConfig> | ((config: Partial<CloudConfig>, options: TOptions) => Partial<CloudConfig>)): (options: TOptions) => Partial<CloudConfig>;
+/**
+ * Merge infrastructure configurations selectively
+ * Useful for adding specific infrastructure to existing presets
+ *
+ * @example
+ * ```typescript
+ * const withRedis = mergeInfrastructure({
+ *   cache: {
+ *     redis: {
+ *       nodeType: 'cache.t3.small',
+ *       numCacheNodes: 2,
+ *     },
+ *   },
+ * })
+ *
+ * const myPreset = extendPreset(
+ *   createApiBackendPreset({ name: 'API', slug: 'api' }),
+ *   withRedis
+ * )
+ * ```
+ */
+export declare function mergeInfrastructure(infrastructure: Partial<CloudConfig['infrastructure']>): Partial<CloudConfig>;
+/**
+ * Add monitoring configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createStaticSitePreset({ name: 'Site', slug: 'site' }),
+ *   withMonitoring({
+ *     dashboard: { name: 'my-dashboard' },
+ *     alarms: [{ metric: 'Errors', threshold: 10 }],
+ *   })
+ * )
+ * ```
+ */
+export declare function withMonitoring(monitoring: NonNullable<CloudConfig['infrastructure']>['monitoring']): Partial<CloudConfig>;
+/**
+ * Add security configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createApiBackendPreset({ name: 'API', slug: 'api' }),
+ *   withSecurity({
+ *     waf: { enabled: true, rules: ['rateLimit', 'sqlInjection'] },
+ *   })
+ * )
+ * ```
+ */
+export declare function withSecurity(security: NonNullable<CloudConfig['infrastructure']>['security']): Partial<CloudConfig>;
+/**
+ * Add database configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createNodeJsServerlessPreset({ name: 'App', slug: 'app' }),
+ *   withDatabase({
+ *     postgres: {
+ *       engine: 'postgres',
+ *       version: '15',
+ *       instanceClass: 'db.t3.medium',
+ *       multiAZ: true,
+ *     },
+ *   })
+ * )
+ * ```
+ */
+export declare function withDatabase(databases: NonNullable<CloudConfig['infrastructure']>['databases']): Partial<CloudConfig>;
+/**
+ * Add cache configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createApiBackendPreset({ name: 'API', slug: 'api' }),
+ *   withCache({
+ *     redis: {
+ *       nodeType: 'cache.t3.small',
+ *       numCacheNodes: 2,
+ *     },
+ *   })
+ * )
+ * ```
+ */
+export declare function withCache(cache: NonNullable<CloudConfig['infrastructure']>['cache']): Partial<CloudConfig>;
+/**
+ * Add CDN configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createNodeJsServerPreset({ name: 'App', slug: 'app' }),
+ *   withCDN({
+ *     enabled: true,
+ *     compress: true,
+ *     http3: true,
+ *   })
+ * )
+ * ```
+ */
+export declare function withCDN(cdn: NonNullable<CloudConfig['infrastructure']>['cdn']): Partial<CloudConfig>;
+/**
+ * Add queue configuration to any preset
+ *
+ * @example
+ * ```typescript
+ * const myPreset = extendPreset(
+ *   createNodeJsServerlessPreset({ name: 'App', slug: 'app' }),
+ *   withQueue({
+ *     jobs: {
+ *       fifo: false,
+ *       deadLetterQueue: true,
+ *     },
+ *   })
+ * )
+ * ```
+ */
+export declare function withQueue(queues: NonNullable<CloudConfig['infrastructure']>['queues']): Partial<CloudConfig>;

package/dist/presets/fullstack-app.d.ts

@@ -0,0 +1,12 @@
+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 declare function createFullStackAppPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  apiSubdomain?: string
+}): Partial<CloudConfig>;

package/dist/presets/index.d.ts

@@ -0,0 +1,24 @@
+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';
+export {
+  extendPreset,
+  composePresets,
+  createPreset,
+  mergeInfrastructure,
+  withMonitoring,
+  withSecurity,
+  withDatabase,
+  withCache,
+  withCDN,
+  withQueue,
+} from './extend';

package/dist/presets/jamstack.d.ts

@@ -0,0 +1,12 @@
+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 declare function createJamstackPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  apiDomain?: string
+}): Partial<CloudConfig>;

package/dist/presets/microservices.d.ts

@@ -0,0 +1,18 @@
+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 declare function createMicroservicesPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  services: Array<{
+    name: string
+    port: number
+    cpu?: string
+    memory?: string
+    desiredCount?: number
+  }>
+}): Partial<CloudConfig>;

package/dist/presets/ml-api.d.ts

@@ -0,0 +1,13 @@
+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 declare function createMLApiPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  modelS3Path?: string
+  instanceType?: string
+}): Partial<CloudConfig>;

package/dist/presets/nodejs-server.d.ts

@@ -0,0 +1,14 @@
+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 declare function createNodeJsServerPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  instanceType?: string
+  minInstances?: number
+  maxInstances?: number
+}): Partial<CloudConfig>;

package/dist/presets/nodejs-serverless.d.ts

@@ -0,0 +1,14 @@
+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 declare function createNodeJsServerlessPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  taskCpu?: string
+  taskMemory?: string
+  desiredCount?: number
+}): Partial<CloudConfig>;

package/dist/presets/realtime-app.d.ts

@@ -0,0 +1,11 @@
+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 declare function createRealtimeAppPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+}): Partial<CloudConfig>;

package/dist/presets/static-site.d.ts

@@ -0,0 +1,12 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * Static Site Preset
+ * Perfect for: Static websites, SPAs, documentation sites
+ * Includes: S3 bucket + CloudFront CDN
+ */
+export declare function createStaticSitePreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  subdomain?: string
+}): Partial<CloudConfig>;

package/dist/presets/traditional-web-app.d.ts

@@ -0,0 +1,16 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * Traditional Web App Preset
+ * Perfect for: Server-rendered web apps, CMS platforms, admin panels
+ * Includes: EC2 + ALB + RDS + Redis + EFS (for session storage and uploads)
+ */
+export declare function createTraditionalWebAppPreset(options: {
+  name: string
+  slug: string
+  domain?: string
+  instanceType?: string
+  minInstances?: number
+  maxInstances?: number
+  databaseEngine?: 'mysql' | 'postgres'
+  sessionStore?: 'redis' | 'database'
+}): Partial<CloudConfig>;

package/dist/presets/wordpress.d.ts

@@ -0,0 +1,12 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * WordPress Preset
+ * Perfect for: WordPress sites, blogs, CMS-based sites
+ * Includes: EC2 + RDS MySQL + EFS + CloudFront
+ */
+export declare function createWordPressPreset(options: {
+  name: string
+  slug: string
+  domain: string
+  instanceType?: string
+}): Partial<CloudConfig>;

package/dist/preview/github.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generate GitHub Actions workflow for preview environments
+ */
+export declare function generatePreviewWorkflow(options?: GitHubWorkflowOptions): string;
+/**
+ * Generate scheduled cleanup workflow
+ */
+export declare function generateCleanupWorkflow(options?: {
+  schedule?: string
+  maxAge?: number
+  keepCount?: number
+}): string;
+/**
+ * Generate cost report workflow
+ */
+export declare function generateCostReportWorkflow(options?: {
+  schedule?: string
+  webhookUrl?: string
+}): string;
+/**
+ * GitHub integration for preview environments
+ * Generates GitHub Actions workflows for automated preview deployments
+ */
+export declare interface GitHubWorkflowOptions {
+  workflowName?: string
+  trigger?: 'pull_request' | 'push' | 'workflow_dispatch'
+  branches?: string[]
+  awsRegion?: string
+  awsRole?: string
+  configFile?: string
+  ttl?: number
+}

package/dist/preview/index.d.ts

@@ -0,0 +1,27 @@
+export type {
+  PreviewEnvironment,
+  PreviewEnvironmentOptions,
+  PreviewCleanupOptions,
+} from './manager';
+export type { GitHubWorkflowOptions } from './github';
+export type {
+  NotificationChannel,
+  SlackConfig,
+  DiscordConfig,
+  EmailConfig,
+  WebhookConfig,
+  NotificationEvent,
+} from './notifications';
+export {
+  PreviewEnvironmentManager,
+  previewManager,
+} from './manager';
+export {
+  generatePreviewWorkflow,
+  generateCleanupWorkflow,
+  generateCostReportWorkflow,
+} from './github';
+export {
+  PreviewNotificationService,
+  previewNotifications,
+} from './notifications';

package/dist/preview/manager.d.ts

@@ -0,0 +1,58 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * Global preview environment manager instance
+ */
+export declare const previewManager: PreviewEnvironmentManager;
+export declare interface PreviewEnvironment {
+  id: string
+  name: string
+  branch: string
+  pr?: number
+  commitSha: string
+  createdAt: Date
+  expiresAt: Date
+  url?: string
+  status: 'creating' | 'active' | 'failed' | 'destroying' | 'destroyed'
+  stackName: string
+  region: string
+  resources: string[]
+  cost?: number
+}
+export declare interface PreviewEnvironmentOptions {
+  branch: string
+  pr?: number
+  commitSha: string
+  ttl?: number
+  baseConfig: CloudConfig
+  region?: string
+}
+export declare interface PreviewCleanupOptions {
+  maxAge?: number
+  keepCount?: number
+  dryRun?: boolean
+}
+/**
+ * Preview Environment Manager
+ */
+export declare class PreviewEnvironmentManager {
+  private environments: Map<string, PreviewEnvironment>;
+  createPreviewEnvironment(options: PreviewEnvironmentOptions): Promise<PreviewEnvironment>;
+  destroyPreviewEnvironment(id: string): Promise<void>;
+  getPreviewEnvironment(id: string): PreviewEnvironment | undefined;
+  getPreviewEnvironmentByBranch(branch: string): PreviewEnvironment | undefined;
+  getPreviewEnvironmentByPR(pr: number): PreviewEnvironment | undefined;
+  listPreviewEnvironments(): PreviewEnvironment[];
+  listActivePreviewEnvironments(): PreviewEnvironment[];
+  cleanupExpiredEnvironments(options?: PreviewCleanupOptions): Promise<{
+    destroyed: string[]
+    failed: string[]
+  }>;
+  updatePreviewEnvironment(id: string, commitSha: string): Promise<PreviewEnvironment>;
+  getPreviewEnvironmentsCost(): Promise<{
+    total: number
+    byEnvironment: Record<string, number>
+  }>;
+  private generatePreviewId(branch: string, pr?: number, commitSha?: string): string;
+  private generatePreviewName(branch: string, pr?: number): string;
+  private createPreviewConfig(baseConfig: CloudConfig, name: string): CloudConfig;
+}

package/dist/preview/notifications.d.ts

@@ -0,0 +1,55 @@
+import type { PreviewEnvironment } from './manager';
+/**
+ * Global notification service instance
+ */
+export declare const previewNotifications: PreviewNotificationService;
+export declare interface NotificationChannel {
+  type: 'slack' | 'discord' | 'email' | 'webhook'
+  config: SlackConfig | DiscordConfig | EmailConfig | WebhookConfig
+}
+export declare interface SlackConfig {
+  webhookUrl: string
+  channel?: string
+  username?: string
+  iconEmoji?: string
+}
+export declare interface DiscordConfig {
+  webhookUrl: string
+  username?: string
+  avatarUrl?: string
+}
+export declare interface EmailConfig {
+  from: string
+  to: string[]
+  smtpHost: string
+  smtpPort: number
+  smtpUser?: string
+  smtpPassword?: string
+}
+export declare interface WebhookConfig {
+  url: string
+  method?: 'POST' | 'GET'
+  headers?: Record<string, string>
+}
+export declare interface NotificationEvent {
+  type: 'created' | 'updated' | 'destroyed' | 'failed' | 'expired'
+  environment: PreviewEnvironment
+  timestamp: Date
+  metadata?: Record<string, any>
+}
+/**
+ * Preview environment notification service
+ */
+export declare class PreviewNotificationService {
+  private channels: NotificationChannel[];
+  addChannel(channel: NotificationChannel): void;
+  removeChannel(type: NotificationChannel['type']): void;
+  notify(event: NotificationEvent): Promise<void>;
+  private sendToChannel(channel: NotificationChannel, event: NotificationEvent): Promise<void>;
+  private sendToSlack(config: SlackConfig, event: NotificationEvent): Promise<void>;
+  private formatSlackMessage(event: NotificationEvent, config: SlackConfig): any;
+  private sendToDiscord(config: DiscordConfig, event: NotificationEvent): Promise<void>;
+  private formatDiscordMessage(event: NotificationEvent, config: DiscordConfig): any;
+  private sendToEmail(config: EmailConfig, event: NotificationEvent): Promise<void>;
+  private sendToWebhook(config: WebhookConfig, event: NotificationEvent): Promise<void>;
+}

package/dist/queue/batch-processing.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Global batch processing manager instance
+ */
+export declare const batchProcessingManager: BatchProcessingManager;
+/**
+ * SQS Batch Processing
+ * Batch operations, parallel processing, and throughput optimization
+ */
+export declare interface BatchConfig {
+  id: string
+  queueUrl: string
+  batchSize: number
+  maxWaitTime: number
+  parallelProcessors: number
+  retryAttempts: number
+  visibilityTimeout: number
+}
+export declare interface BatchJob {
+  id: string
+  configId: string
+  messages: BatchMessage[]
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+  startedAt?: Date
+  completedAt?: Date
+  processedCount: number
+  failedCount: number
+}
+export declare interface BatchMessage {
+  id: string
+  messageId: string
+  body: string
+  receiptHandle: string
+  attributes: Record<string, any>
+  status: 'pending' | 'processing' | 'success' | 'failed'
+  processingTime?: number
+  error?: string
+}
+export declare interface ProcessorMetrics {
+  id: string
+  configId: string
+  timestamp: Date
+  messagesProcessed: number
+  averageProcessingTime: number
+  throughput: number
+  errorRate: number
+}
+/**
+ * Batch processing manager
+ */
+export declare class BatchProcessingManager {
+  private configs: Map<string, BatchConfig>;
+  private jobs: Map<string, BatchJob>;
+  private metrics: Map<string, ProcessorMetrics[]>;
+  private configCounter: any;
+  private jobCounter: any;
+  private metricsCounter: any;
+  createBatchConfig(config: Omit<BatchConfig, 'id'>): BatchConfig;
+  createHighThroughputConfig(options: {
+    queueUrl: string
+  }): BatchConfig;
+  createLowLatencyConfig(options: {
+    queueUrl: string
+  }): BatchConfig;
+  createBatchJob(options: {
+    configId: string
+    messageCount: number
+  }): BatchJob;
+  processBatchJob(jobId: string): Promise<BatchJob>;
+  private processBatch(messages: BatchMessage[], config: BatchConfig): Promise<void>;
+  private processMessage(message: BatchMessage, config: BatchConfig): Promise<void>;
+  private chunkArray<T>(array: T[], chunkSize: number): T[][];
+  private collectProcessorMetrics(configId: string, job: BatchJob): void;
+  getBatchStatistics(configId: string): {
+    totalJobsProcessed: number
+    totalMessagesProcessed: number
+    averageThroughput: number
+    averageErrorRate: number
+    averageProcessingTime: number
+  };
+  optimizeBatchConfig(configId: string): BatchConfig;
+  getConfig(id: string): BatchConfig | undefined;
+  listConfigs(): BatchConfig[];
+  getJob(id: string): BatchJob | undefined;
+  listJobs(configId?: string): BatchJob[];
+  generateBatchProcessorCF(config: BatchConfig): any;
+  clear(): void;
+}