@worktif/runtime 0.3.0-edge.0

package/out/dist/lib/lib/runtime-web/types/infra.types.d.ts

@@ -0,0 +1,225 @@
+/**
+ * AWS environment configuration.
+ */
+export interface AwsEnvironment {
+    /** AWS account ID (12-digit string) */
+    account: string;
+    /** AWS region identifier (e.g., 'us-east-1', 'eu-west-1') */
+    region: string;
+}
+/**
+ * Custom domain configuration for API Gateway.
+ */
+export interface DomainConfig {
+    /** Root domain name (e.g., 'myapp.com') */
+    rootDomain: string;
+    /** Optional subdomain (e.g., 'api' for 'api.myapp.com') */
+    subdomain?: string;
+    /** ARN of the SSL certificate in AWS Certificate Manager */
+    certificateArn?: string;
+    /** Route 53 hosted zone ID for the domain */
+    hostedZoneId?: string;
+}
+/**
+ * VPC configuration for Lambda functions.
+ */
+export interface VpcConfig {
+    /** VPC ID where Lambda functions will be deployed */
+    vpcId: string;
+    /** Subnet IDs for Lambda function placement */
+    subnetIds: string[];
+    /** Security group IDs for Lambda functions */
+    securityGroupIds: string[];
+}
+/**
+ * Infrastructure configuration for CDK deployment.
+ *
+ * Contains only infrastructure-specific settings (AWS resources, networking, etc.).
+ * Does NOT contain runtime configuration like microservices - that belongs in PurenowConfig.register.
+ *
+ * This separation ensures:
+ * - Clean architecture boundaries (infra vs runtime)
+ * - Single source of truth (register is at runtime level)
+ * - Proper context isolation (infra only needed in CDK context)
+ */
+export interface InfraOptions {
+    /**
+     * AWS environment (account and region).
+     *
+     * **Required**: Must specify target AWS account and region for deployment.
+     * **Security**: Account ID prevents accidental cross-account deployments.
+     *
+     * @example
+     * ```typescript
+     * env: {
+     *   account: '123456789012',
+     *   region: 'us-east-1'
+     * }
+     * ```
+     */
+    env: AwsEnvironment;
+    /**
+     * Deployment stage for infrastructure resources.
+     *
+     * **Must match**: Should match the stage in PurenowConfig for consistency.
+     * **Resource naming**: Used in CloudFormation stack names and resource tags.
+     *
+     * @example
+     * ```typescript
+     * stage: 'prod'
+     * ```
+     */
+    stage: 'dev' | 'staging' | 'prod';
+    /**
+     * Enable SEO metadata support.
+     *
+     * **Creates**: DynamoDB table for SEO metadata storage
+     * **Lambda**: Enables SEO Lambda function for metadata management
+     *
+     * @default true
+     */
+    enableSeo?: boolean;
+    /**
+     * Path to React application entry point.
+     *
+     * **Purpose**: Used to create the SSR Lambda that serves all React routes
+     * **Bundling**: Framework bundles this file with esbuild for Lambda deployment
+     * **Automatic**: SSR Lambda is created automatically, not in microservice register
+     *
+     * @example
+     * ```typescript
+     * reactEntry: './src/index.tsx'
+     * reactEntry: './app/main.tsx'
+     * ```
+     */
+    reactEntry: string;
+    /**
+     * API exposure mode.
+     *
+     * **apiGateway**: Use API Gateway with CloudFront integration (recommended)
+     * **lambdaUrl**: Use Lambda Function URLs (simpler, but less features)
+     *
+     * @default 'apiGateway'
+     *
+     * @example
+     * ```typescript
+     * apiMode: 'apiGateway'  // Full API Gateway features
+     * apiMode: 'lambdaUrl'   // Simple Lambda URLs
+     * ```
+     */
+    apiMode?: 'apiGateway' | 'lambdaUrl';
+    /**
+     * Custom domain configuration.
+     *
+     * **Optional**: If provided, sets up custom domain for API Gateway
+     * **Requirements**: SSL certificate must exist in ACM
+     * **DNS**: Route 53 hosted zone must be configured
+     *
+     * @example
+     * ```typescript
+     * domain: {
+     *   rootDomain: 'myapp.com',
+     *   subdomain: 'api',  // Results in api.myapp.com
+     *   certificateArn: 'arn:aws:acm:us-east-1:123456789012:certificate/...',
+     *   hostedZoneId: 'Z1D633PJN98FT9'
+     * }
+     * ```
+     */
+    domain?: DomainConfig;
+    /**
+     * Default memory allocation for Lambda functions (MB).
+     *
+     * **Range**: 128 - 10240 MB
+     * **Override**: Individual Lambdas can override via LambdaDefinition.config
+     * **Performance**: More memory = more CPU power and faster execution
+     *
+     * @default 512
+     *
+     * @example
+     * ```typescript
+     * lambdaMemorySize: 1024  // 1GB default memory
+     * ```
+     */
+    lambdaMemorySize?: number;
+    /**
+     * Default timeout for Lambda functions (seconds).
+     *
+     * **Range**: 1 - 900 seconds (15 minutes)
+     * **Override**: Individual Lambdas can override via LambdaDefinition.config
+     * **API Gateway**: Limited to 29 seconds for HTTP endpoints
+     *
+     * @default 30
+     *
+     * @example
+     * ```typescript
+     * lambdaTimeout: 60  // 1 minute default timeout
+     * ```
+     */
+    lambdaTimeout?: number;
+    /**
+     * Enable Lambda warmup to prevent cold starts.
+     *
+     * **Creates**: EventBridge rule that invokes Lambdas periodically
+     * **Cost**: Small additional cost for scheduled invocations
+     * **Performance**: Reduces cold start latency for critical functions
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * enableWarmup: true  // Enable for production workloads
+     * ```
+     */
+    enableWarmup?: boolean;
+    /**
+     * Clear CloudFront cache on deployment.
+     *
+     * **Purpose**: Ensures users get updated static assets immediately
+     * **Cost**: Small charge per invalidation request
+     * **Recommended**: Enable for production deployments
+     *
+     * @default true
+     *
+     * @example
+     * ```typescript
+     * clearCacheOnDeploy: true  // Invalidate cache after deploy
+     * ```
+     */
+    clearCacheOnDeploy?: boolean;
+    /**
+     * Global environment variables for all Lambda functions.
+     *
+     * **Merged**: Combined with Lambda-specific environment variables
+     * **Precedence**: Lambda-specific variables override global ones
+     * **Security**: Avoid sensitive values, use AWS Secrets Manager instead
+     *
+     * @example
+     * ```typescript
+     * environment: {
+     *   NODE_ENV: 'production',
+     *   LOG_LEVEL: 'info',
+     *   REGION: 'us-east-1'
+     * }
+     * ```
+     */
+    environment?: Record<string, string>;
+    /**
+     * VPC configuration for Lambda functions.
+     *
+     * **Optional**: If provided, deploys Lambdas inside VPC
+     * **Use cases**: Access to private RDS, ElastiCache, or internal services
+     * **Performance**: Adds cold start latency (~1-2 seconds)
+     * **NAT Gateway**: Required for internet access from private subnets
+     *
+     * @example
+     * ```typescript
+     * vpc: {
+     *   vpcId: 'vpc-12345678',
+     *   subnetIds: ['subnet-12345678', 'subnet-87654321'],
+     *   securityGroupIds: ['sg-12345678']
+     * }
+     * ```
+     */
+    vpc?: VpcConfig;
+}
+//# sourceMappingURL=infra.types.d.ts.map

package/out/dist/lib/lib/runtime-web/types/lambda.types.d.ts

@@ -0,0 +1,175 @@
+import type { HttpIntegration } from './http.types';
+/**
+ * Lambda handler factory function type.
+ *
+ * Receives injected dependencies and returns a Lambda handler function.
+ * Dependencies are automatically resolved from the microservice's PureContainer
+ * based on the class references in the ties array.
+ *
+ * @param deps - Object containing injected dependencies (camelCase keys)
+ * @returns Lambda handler function
+ *
+ * @example
+ * ```typescript
+ * const chargeHandler: LambdaHandlerFactory = (deps) => {
+ *   return async (event, context) => {
+ *     // deps.paymentsService is automatically injected
+ *     return await deps.paymentsService.processCharge(event.body);
+ *   };
+ * };
+ * ```
+ */
+export type LambdaHandlerFactory = (deps: Record<string, unknown>) => (event: unknown, context: unknown) => Promise<unknown>;
+/**
+ * Lambda-specific configuration overrides.
+ *
+ * Allows overriding global Lambda settings for specific functions.
+ * All properties are optional and will fall back to global defaults.
+ */
+export interface LambdaConfig {
+    /**
+     * Memory allocation for this Lambda function (MB).
+     *
+     * **Range**: 128 - 10240 MB
+     * **Default**: Uses global lambdaMemorySize from InfraOptions
+     *
+     * @example
+     * ```typescript
+     * memorySize: 1024  // 1GB memory
+     * ```
+     */
+    memorySize?: number;
+    /**
+     * Timeout for this Lambda function (seconds).
+     *
+     * **Range**: 1 - 900 seconds (15 minutes)
+     * **Default**: Uses global lambdaTimeout from InfraOptions
+     *
+     * @example
+     * ```typescript
+     * timeout: 30  // 30 second timeout
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Additional environment variables for this Lambda function.
+     *
+     * Merged with global environment variables from InfraOptions.
+     * Lambda-specific variables take precedence over global ones.
+     *
+     * @example
+     * ```typescript
+     * environment: {
+     *   PAYMENT_PROVIDER: 'stripe',
+     *   MAX_RETRY_ATTEMPTS: '3'
+     * }
+     * ```
+     */
+    environment?: Record<string, string>;
+}
+/**
+ * Lambda endpoint definition with dependency injection.
+ *
+ * Declaratively defines a Lambda function with its dependencies, business logic,
+ * and optional HTTP integration. The framework automatically creates the Lambda
+ * function, injects dependencies, and sets up API Gateway routes.
+ */
+export interface LambdaDefinition {
+    /**
+     * Lambda identifier within the microservice.
+     *
+     * **Optional**: If omitted, automatically generated from handler function name.
+     * **Final ID**: Combined with service name as `{serviceName}.{id}`
+     *
+     * @example
+     * ```typescript
+     * id: 'charge'  // Results in 'payments.charge' if service is 'payments'
+     * ```
+     */
+    id?: string;
+    /**
+     * Service name (auto-set by framework).
+     *
+     * **Internal**: Automatically populated by the framework during registration.
+     * **Do not set manually**.
+     */
+    service?: string;
+    /**
+     * Array of class constructors for dependency injection.
+     *
+     * Classes are automatically resolved from the microservice's PureContainer
+     * using their class names as keys. Dependencies are injected into the handler
+     * with camelCase property names.
+     *
+     * **Key Generation**: Automatic via Class.name (no magic strings)
+     * **Property Names**: ClassName → camelCase (PaymentsService → paymentsService)
+     *
+     * @example
+     * ```typescript
+     * ties: [PaymentsService, BillingService, ConfigService]
+     * // Results in: { paymentsService, billingService, configService }
+     * ```
+     */
+    ties: Array<new (...args: unknown[]) => unknown>;
+    /**
+     * Lambda handler factory function.
+     *
+     * Receives injected dependencies and returns the actual Lambda handler.
+     * The framework calls this function with resolved dependencies from the
+     * microservice's PureContainer.
+     *
+     * @see {@link LambdaHandlerFactory}
+     *
+     * @example
+     * ```typescript
+     * handler: (deps) => async (event, context) => {
+     *   const result = await deps.paymentsService.processPayment(event.body);
+     *   return {
+     *     statusCode: 200,
+     *     body: JSON.stringify(result)
+     *   };
+     * }
+     * ```
+     */
+    handler: LambdaHandlerFactory;
+    /**
+     * HTTP integration configuration.
+     *
+     * **Optional**: If provided, creates an API Gateway route for this Lambda.
+     * If omitted, Lambda can only be invoked directly or via other AWS services.
+     *
+     * @see {@link HttpIntegration}
+     *
+     * @example
+     * ```typescript
+     * http: {
+     *   method: 'POST',
+     *   path: '/api/payments/charge',
+     *   auth: 'jwt',
+     *   cors: true
+     * }
+     * ```
+     */
+    http?: HttpIntegration;
+    /**
+     * Lambda-specific configuration overrides.
+     *
+     * **Optional**: Overrides global Lambda settings for this specific function.
+     * Useful for functions with special requirements (more memory, longer timeout, etc.).
+     *
+     * @see {@link LambdaConfig}
+     *
+     * @example
+     * ```typescript
+     * config: {
+     *   memorySize: 2048,  // 2GB for heavy processing
+     *   timeout: 300,      // 5 minutes for long operations
+     *   environment: {
+     *     SPECIAL_CONFIG: 'value'
+     *   }
+     * }
+     * ```
+     */
+    config?: LambdaConfig;
+}
+//# sourceMappingURL=lambda.types.d.ts.map

package/out/dist/lib/lib/runtime-web/types/microservice.types.d.ts

@@ -0,0 +1,70 @@
+import type { LambdaDefinition } from './lambda.types';
+/**
+ * Type for Ties class constructors.
+ *
+ * Ties classes implement the register(container) pattern for dependency injection.
+ * They use PureContainer from @worktif/utils to register services.
+ *
+ * @template T - The type of the Ties class instance
+ */
+export type TiesInstance<T = unknown> = new (...args: unknown[]) => T;
+/**
+ * Microservice definition containing DI configuration and Lambda endpoints.
+ *
+ * A microservice is a logical grouping of related Lambda functions that share
+ * a common PureContainer instance for dependency injection.
+ *
+ * @example
+ * ```typescript
+ * const paymentsService: MicroserviceDefinition = {
+ *   ties: [PaymentsTies, BillingTies],
+ *   lambdas: [chargeHandler, refundHandler, webhookHandler]
+ * };
+ * ```
+ */
+export interface MicroserviceDefinition {
+    /**
+     * Array of Ties class constructors for dependency injection.
+     *
+     * Each Ties class must implement a register(container: PureContainer<string>) method
+     * that registers services using container.tie(), container.tieConst(), or container.tieSingleton().
+     *
+     * The framework automatically creates a PureContainer instance for each microservice
+     * and calls register() on each Ties class to build the DI container.
+     *
+     * @example
+     * ```typescript
+     * ties: [PaymentsTies, BillingTies, ConfigTies]
+     * ```
+     */
+    ties: TiesInstance[];
+    /**
+     * Array of Lambda endpoint definitions.
+     *
+     * Each Lambda definition describes a single Lambda function with its dependencies,
+     * handler logic, and optional HTTP integration.
+     *
+     * The framework automatically creates Lambda functions from these definitions
+     * and injects dependencies from the microservice's PureContainer.
+     *
+     * @example
+     * ```typescript
+     * lambdas: [
+     *   {
+     *     id: 'charge',
+     *     ties: [PaymentsService, BillingService],
+     *     handler: (deps) => async (event, context) => {
+     *       return await deps.paymentsService.processCharge(event.body);
+     *     },
+     *     http: {
+     *       method: 'POST',
+     *       path: '/api/payments/charge',
+     *       auth: 'jwt'
+     *     }
+     *   }
+     * ]
+     * ```
+     */
+    lambdas: LambdaDefinition[];
+}
+//# sourceMappingURL=microservice.types.d.ts.map

package/out/dist/lib/lib/runtime-web/types/runtime.types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Browser environment metadata.
+ */
+export interface BrowserMetadata {
+    /** User agent string */
+    userAgent: string;
+    /** Current URL */
+    url: string;
+    /** Viewport dimensions */
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Lambda environment metadata.
+ */
+export interface LambdaMetadata {
+    /** Lambda function name */
+    functionName: string;
+    /** Function version */
+    version: string;
+    /** AWS region */
+    region: string;
+    /** Memory limit (MB) */
+    memoryLimit: number;
+    /** Request ID */
+    requestId?: string;
+}
+/**
+ * CDK environment metadata.
+ */
+export interface CDKMetadata {
+    /** AWS account ID */
+    account: string;
+    /** AWS region */
+    region: string;
+    /** CDK version */
+    cdkVersion?: string;
+    /** Node.js version */
+    nodeVersion: string;
+}
+/**
+ * Runtime environment context.
+ *
+ * Contains the detected environment type and relevant metadata.
+ * Used by the framework to route execution to the appropriate pipeline.
+ */
+export interface EnvironmentContext {
+    /** Detected environment type */
+    type: 'browser' | 'lambda' | 'cdk';
+    /** Environment-specific metadata */
+    metadata: BrowserMetadata | LambdaMetadata | CDKMetadata;
+}
+//# sourceMappingURL=runtime.types.d.ts.map

package/out/dist/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/lib/utils/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { RuntimeConfig, } from './runtime.config.types';
+export { mergeRuntimeConfig, isRuntimeConfig, extractRuntimeConfig, createRuntimeConfig, } from './runtime.config.types';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/lib/utils/types/runtime.config.types.d.ts

@@ -0,0 +1,71 @@
+import type { PurenowConfig } from '@worktif/purenow';
+/**
+ * Runtime-specific configuration that extends PurenowConfig.
+ *
+ * This interface adds runtime workspace functionality while preserving
+ * all existing purenow configuration options. The runtime configuration
+ * is merged with purenow configuration rather than replacing it.
+ */
+export interface RuntimeConfig extends PurenowConfig {
+    /**
+     * Runtime-specific configuration options.
+     * These settings extend purenow functionality without replacing it.
+     */
+    runtime?: {
+        /** Enable Runtime Core stack deployment (extends purenow's two-stack architecture) */
+        enableThirdStack?: boolean;
+        /** Runtime web mode configuration */
+        runtimeWebMode?: 'development' | 'production';
+        /** Additional runtime features to enable */
+        additionalFeatures?: string[];
+        /** Development server enhancements */
+        devServerEnhancements?: {
+            /** Enable hot module replacement */
+            hotReload?: boolean;
+            /** Enable debug mode with additional logging */
+            debugMode?: boolean;
+            /** Enable performance monitoring */
+            performanceMonitoring?: boolean;
+        };
+        /** Build optimizations */
+        buildOptimizations?: {
+            /** Enable bundle analysis */
+            bundleAnalysis?: boolean;
+            /** Enable tree shaking */
+            treeshaking?: boolean;
+            /** Enable code minification */
+            codeMinification?: boolean;
+        };
+    };
+}
+/**
+ * Configuration merging utility that preserves all purenow settings
+ * while adding runtime-specific extensions.
+ *
+ * @param purenowConfig - Base purenow configuration
+ * @param runtimeConfig - Runtime-specific configuration to merge
+ * @returns Merged configuration with all purenow settings preserved
+ */
+export declare function mergeRuntimeConfig(purenowConfig: PurenowConfig, runtimeConfig?: Partial<RuntimeConfig['runtime']>): RuntimeConfig;
+/**
+ * Type guard to check if a configuration is a RuntimeConfig.
+ *
+ * @param config - Configuration to check
+ * @returns True if the configuration has runtime-specific properties
+ */
+export declare function isRuntimeConfig(config: any): config is RuntimeConfig;
+/**
+ * Extract runtime-specific configuration from a RuntimeConfig.
+ *
+ * @param config - RuntimeConfig to extract from
+ * @returns Runtime-specific configuration or undefined
+ */
+export declare function extractRuntimeConfig(config: RuntimeConfig): RuntimeConfig['runtime'];
+/**
+ * Create a RuntimeConfig from a base PurenowConfig with default runtime settings.
+ *
+ * @param purenowConfig - Base purenow configuration
+ * @returns RuntimeConfig with default runtime settings
+ */
+export declare function createRuntimeConfig(purenowConfig: PurenowConfig): RuntimeConfig;
+//# sourceMappingURL=runtime.config.types.d.ts.map

package/out/dist/src/bin/index.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export { PurenowRuntimeCli } from './purenow-runtime-cli';
+export { TemplateService as RuntimeTemplateService, ScaffoldOptions as RuntimeScaffoldOptions, TemplateContext as RuntimeTemplateContext, PurenowRuntimeStacksDeployService, RuntimeDeploymentStrategy, buildStaticHtml, PurenowRuntimeCliContext, PurenowRuntimeDeploymentOutputs, PurenowRuntimeStacksDeployResult, } from './services';
+export * from './purenow-runtime-cli';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/src/bin/index.unix.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main CLI entry point with runtime-web extensions
+ */
+export declare function main(): Promise<void>;
+//# sourceMappingURL=index.unix.d.ts.map

package/out/dist/src/bin/purenow-runtime-cli.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import 'reflect-metadata';
+import { GlobalOptions, PurenowCli, PurenowCliContext } from '@worktif/purenow/bin';
+import { PurenowRuntimeCliContext } from './services';
+/**
+ * Runtime CLI that properly extends PurenowCli using the extensible architecture
+ *
+ * This implementation uses purenow's ExtensibleCliCore.addCommands() and addActions()
+ * to add runtime-specific functionality while preserving all existing purenow commands.
+ */
+export declare class PurenowRuntimeCli extends PurenowCli {
+    static defaultToolName: string;
+    constructor();
+    /**
+     * Create Purenow-specific context with all required services
+     */
+    protected createContext<T extends PurenowCliContext = PurenowRuntimeCliContext>(globalOpts: GlobalOptions, cwd?: string): Promise<T>;
+    /**
+     * Run the CLI with provided arguments
+     */
+    run(args?: string[]): Promise<void>;
+    /**
+     * Handle errors with structured logging (no emoji)
+     */
+    static handleError(error: unknown): never;
+}
+/**
+ * Create CLI instance that properly extends purenow
+ */
+export declare function createRuntimeCli(): PurenowRuntimeCli;
+//# sourceMappingURL=purenow-runtime-cli.d.ts.map

package/out/dist/src/bin/services/index.d.ts

@@ -0,0 +1,8 @@
+export * from './template.service';
+export * from './purenow-runtime-stacks-deploy.service';
+export * from './purenow-runtime-deployment.strategy';
+export * from './purenow-runtime-stacks-deploy.service';
+export * from './purenow-runtime-stacks-deploy.service.types';
+export * from './runtime-web-cli-extensions';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map