@ts-cloud/core 0.2.3 → 0.2.4

package/dist/presets/extend.d.ts

@@ -0,0 +1,194 @@
+import type { CloudConfig } from '../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/extend.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Preset Extension and Composition Tests
+ */
+export {};

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

@@ -0,0 +1,12 @@
+import type { CloudConfig } from '../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,13 @@
+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 '../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 '../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 '../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 '../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 '../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 '../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 '../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 '../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 '../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 @@
+/**
+ * GitHub integration for preview environments
+ * Generates GitHub Actions workflows for automated preview deployments
+ */
+export interface GitHubWorkflowOptions {
+    workflowName?: string;
+    trigger?: 'pull_request' | 'push' | 'workflow_dispatch';
+    branches?: string[];
+    awsRegion?: string;
+    awsRole?: string;
+    configFile?: string;
+    ttl?: number;
+}
+/**
+ * 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;

package/dist/preview/github.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/preview/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Preview Environments
+ * Ephemeral environments for PR/branch previews
+ */
+export { PreviewEnvironmentManager, previewManager, } from './manager';
+export type { PreviewEnvironment, PreviewEnvironmentOptions, PreviewCleanupOptions, } from './manager';
+export { generatePreviewWorkflow, generateCleanupWorkflow, generateCostReportWorkflow, } from './github';
+export type { GitHubWorkflowOptions } from './github';
+export { PreviewNotificationService, previewNotifications, } from './notifications';
+export type { NotificationChannel, SlackConfig, DiscordConfig, EmailConfig, WebhookConfig, NotificationEvent, } from './notifications';

package/dist/preview/manager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Preview Environment Manager
+ * Manages ephemeral environments for PR previews
+ */
+import type { CloudConfig } from '../types';
+export 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 interface PreviewEnvironmentOptions {
+    branch: string;
+    pr?: number;
+    commitSha: string;
+    ttl?: number;
+    baseConfig: CloudConfig;
+    region?: string;
+}
+export interface PreviewCleanupOptions {
+    maxAge?: number;
+    keepCount?: number;
+    dryRun?: boolean;
+}
+/**
+ * Preview Environment Manager
+ */
+export declare class PreviewEnvironmentManager {
+    private environments;
+    /**
+     * Create a new preview environment
+     */
+    createPreviewEnvironment(options: PreviewEnvironmentOptions): Promise<PreviewEnvironment>;
+    /**
+     * Destroy a preview environment
+     */
+    destroyPreviewEnvironment(id: string): Promise<void>;
+    /**
+     * Get preview environment by ID
+     */
+    getPreviewEnvironment(id: string): PreviewEnvironment | undefined;
+    /**
+     * Get preview environment by branch
+     */
+    getPreviewEnvironmentByBranch(branch: string): PreviewEnvironment | undefined;
+    /**
+     * Get preview environment by PR number
+     */
+    getPreviewEnvironmentByPR(pr: number): PreviewEnvironment | undefined;
+    /**
+     * List all preview environments
+     */
+    listPreviewEnvironments(): PreviewEnvironment[];
+    /**
+     * List active preview environments
+     */
+    listActivePreviewEnvironments(): PreviewEnvironment[];
+    /**
+     * Clean up expired preview environments
+     */
+    cleanupExpiredEnvironments(options?: PreviewCleanupOptions): Promise<{
+        destroyed: string[];
+        failed: string[];
+    }>;
+    /**
+     * Update preview environment from new commit
+     */
+    updatePreviewEnvironment(id: string, commitSha: string): Promise<PreviewEnvironment>;
+    /**
+     * Get cost estimate for preview environments
+     */
+    getPreviewEnvironmentsCost(): Promise<{
+        total: number;
+        byEnvironment: Record<string, number>;
+    }>;
+    /**
+     * Generate preview environment ID
+     */
+    private generatePreviewId;
+    /**
+     * Generate preview environment name
+     */
+    private generatePreviewName;
+    /**
+     * Create modified config for preview environment
+     */
+    private createPreviewConfig;
+}
+/**
+ * Global preview environment manager instance
+ */
+export declare const previewManager: PreviewEnvironmentManager;

package/dist/preview/manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/preview/notifications.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Preview environment notifications
+ * Send notifications to Slack, Discord, email, etc. when preview environments are created/destroyed
+ */
+import type { PreviewEnvironment } from './manager';
+export interface NotificationChannel {
+    type: 'slack' | 'discord' | 'email' | 'webhook';
+    config: SlackConfig | DiscordConfig | EmailConfig | WebhookConfig;
+}
+export interface SlackConfig {
+    webhookUrl: string;
+    channel?: string;
+    username?: string;
+    iconEmoji?: string;
+}
+export interface DiscordConfig {
+    webhookUrl: string;
+    username?: string;
+    avatarUrl?: string;
+}
+export interface EmailConfig {
+    from: string;
+    to: string[];
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser?: string;
+    smtpPassword?: string;
+}
+export interface WebhookConfig {
+    url: string;
+    method?: 'POST' | 'GET';
+    headers?: Record<string, string>;
+}
+export 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;
+    /**
+     * Add notification channel
+     */
+    addChannel(channel: NotificationChannel): void;
+    /**
+     * Remove notification channel
+     */
+    removeChannel(type: NotificationChannel['type']): void;
+    /**
+     * Send notification to all channels
+     */
+    notify(event: NotificationEvent): Promise<void>;
+    /**
+     * Send notification to specific channel
+     */
+    private sendToChannel;
+    /**
+     * Send notification to Slack
+     */
+    private sendToSlack;
+    /**
+     * Format Slack message
+     */
+    private formatSlackMessage;
+    /**
+     * Send notification to Discord
+     */
+    private sendToDiscord;
+    /**
+     * Format Discord message
+     */
+    private formatDiscordMessage;
+    /**
+     * Send notification via email
+     */
+    private sendToEmail;
+    /**
+     * Send notification to custom webhook
+     */
+    private sendToWebhook;
+}
+/**
+ * Global notification service instance
+ */
+export declare const previewNotifications: PreviewNotificationService;

package/dist/preview/notifications.test.d.ts

@@ -0,0 +1 @@
+export {};