@worktif/runtime 0.3.0-edge.0 → 0.3.0-edge.10

package/out/dist/src/core/runtime-web/detector/runtime-detector.d.ts

@@ -0,0 +1,69 @@
+import type { EnvironmentContext } from '../../../lib/runtime-web/types';
+/**
+ * Runtime environment detector for Runtime Target Core.
+ *
+ * Automatically detects the execution environment (browser, Lambda, or CDK)
+ * and provides appropriate metadata for each context. This enables the
+ * unified purenow() entry point to route execution to the correct pipeline.
+ *
+ * **Detection Priority**:
+ * 1. Browser: Check for `window` object
+ * 2. Lambda: Check for `AWS_LAMBDA_FUNCTION_NAME` environment variable
+ * 3. CDK: Check for explicit mode, CDK env vars, or process arguments
+ *
+ * @example
+ * ```typescript
+ * const detector = new RuntimeDetector();
+ * const context = detector.detect();
+ *
+ * switch (context.type) {
+ *   case 'browser':
+ *     // Execute browser pipeline
+ *     break;
+ *   case 'lambda':
+ *     // Execute Lambda pipeline
+ *     break;
+ *   case 'cdk':
+ *     // Execute CDK pipeline
+ *     break;
+ * }
+ * ```
+ */
+export declare class RuntimeDetector {
+    /**
+     * Detect the current runtime environment.
+     *
+     * Uses a series of checks to determine the execution context:
+     * - Browser: Presence of `window` object
+     * - Lambda: AWS Lambda environment variables
+     * - CDK: Explicit mode or CDK-specific indicators
+     *
+     * @returns Environment context with type and metadata
+     * @throws Error if environment cannot be determined
+     */
+    detect(): EnvironmentContext;
+    /**
+     * Check if running in browser environment.
+     *
+     * @returns True if `window` object exists
+     */
+    private isBrowser;
+    /**
+     * Check if running in AWS Lambda environment.
+     *
+     * @returns True if AWS Lambda environment variable is present
+     */
+    private isLambda;
+    /**
+     * Check if running in CDK environment.
+     *
+     * Uses multiple detection methods in priority order:
+     * 1. Explicit mode: PURENOW_MODE=cdk (recommended)
+     * 2. CDK environment variables: CDK_DEFAULT_ACCOUNT or CDK_DEFAULT_REGION
+     * 3. Process arguments: contains 'cdk' or 'synth'
+     *
+     * @returns True if CDK environment is detected
+     */
+    private isCDK;
+}
+//# sourceMappingURL=runtime-detector.d.ts.map

package/out/dist/src/core/runtime-web/detector/runtime-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-detector.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/detector/runtime-detector.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;;OAUG;IACH,MAAM,IAAI,kBAAkB;IA6B5B;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK;CAkBd"}

package/out/dist/src/core/runtime-web/detector/runtime-detector.types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Internal types for the RuntimeDetector module.
+ *
+ * These types are used internally by the detector and are not part of the public API.
+ * Public types are exported from @lib/runtime-web/types.
+ */
+/**
+ * Detection result for internal use.
+ *
+ * Contains the raw detection result before metadata collection.
+ */
+export interface DetectionResult {
+    /** Detected environment type */
+    type: 'browser' | 'lambda' | 'cdk';
+    /** Whether detection was successful */
+    success: boolean;
+    /** Detection method used */
+    method: 'window' | 'lambda-env' | 'cdk-explicit' | 'cdk-env' | 'cdk-args';
+}
+/**
+ * Detection error information.
+ */
+export interface DetectionError {
+    /** Error message */
+    message: string;
+    /** Detection attempts made */
+    attempts: string[];
+    /** Environment variables checked */
+    envVarsChecked: string[];
+}
+/**
+ * Metadata collection options.
+ */
+export interface MetadataOptions {
+    /** Whether to include sensitive information */
+    includeSensitive?: boolean;
+    /** Whether to validate collected data */
+    validate?: boolean;
+}
+//# sourceMappingURL=runtime-detector.types.d.ts.map

package/out/dist/src/core/runtime-web/detector/runtime-detector.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-detector.types.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/detector/runtime-detector.types.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AAEH;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;IACnC,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,4BAA4B;IAC5B,MAAM,EAAE,QAAQ,GAAG,YAAY,GAAG,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;CAC3E;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,oCAAoC;IACpC,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/out/dist/src/core/runtime-web/di/di-errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Error thrown when a DI container operation fails.
+ *
+ * Used for container creation, service resolution, and validation errors.
+ */
+export declare class DIContainerError extends Error {
+    /**
+     * Create a new DI container error.
+     *
+     * @param containerName - Name or identifier of the container
+     * @param message - Detailed error message
+     */
+    constructor(containerName: string, message: string);
+}
+/**
+ * Error thrown when Ties class registration fails.
+ *
+ * Used when a Ties class doesn't implement the required register() method
+ * or when registration fails for other reasons.
+ */
+export declare class TiesRegistrationError extends Error {
+    /**
+     * Create a new Ties registration error.
+     *
+     * @param tiesClassName - Name of the Ties class that failed
+     * @param reason - Reason for the registration failure
+     */
+    constructor(tiesClassName: string, reason: string);
+}
+/**
+ * Error thrown when a required service is not found in the container.
+ *
+ * Used when attempting to resolve a service that hasn't been registered.
+ */
+export declare class MissingServiceError extends Error {
+    /**
+     * Create a new missing service error.
+     *
+     * @param serviceName - Name of the missing service
+     * @param containerName - Name or identifier of the container
+     */
+    constructor(serviceName: string, containerName: string);
+}
+//# sourceMappingURL=di-errors.d.ts.map

package/out/dist/src/core/runtime-web/di/di-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"di-errors.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/di/di-errors.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;;;;OAKG;gBACS,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKnD;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C;;;;;OAKG;gBACS,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAKlD;AAED;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C;;;;;OAKG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;CAKvD"}

package/out/dist/src/core/runtime-web/di/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Dependency injection module for Runtime Target Core.
+ *
+ * Provides PureContainer integration and Ties registration functionality.
+ */
+export { TiesRegistrar } from './ties-registrar';
+export { PureContainerFactory } from './pure-container-factory';
+export { DIContainerError, TiesRegistrationError, MissingServiceError } from './di-errors';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/src/core/runtime-web/di/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/di/index.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/out/dist/src/core/runtime-web/di/pure-container-factory.d.ts

@@ -0,0 +1,105 @@
+import { PureContainer } from '@worktif/utils';
+import type { TiesInstance } from '../../../lib/runtime-web/types';
+/**
+ * Factory for creating and configuring PureContainer instances for microservices.
+ *
+ * Creates PureContainer<string> instances with singleton scope by default and
+ * registers all services from the provided Ties classes. This provides a
+ * consistent way to build DI containers for microservices.
+ *
+ * @example
+ * ```typescript
+ * const factory = new PureContainerFactory();
+ * const container = factory.createMicroserviceContainer([PaymentsTies, BillingTies]);
+ *
+ * // Container now has all services registered by the Ties classes
+ * const paymentsService = container.run('PaymentsService');
+ * ```
+ */
+export declare class PureContainerFactory {
+    private readonly tiesRegistrar;
+    constructor();
+    /**
+     * Create a PureContainer for a microservice with registered Ties classes.
+     *
+     * Creates a new PureContainer<string> with singleton scope by default,
+     * then registers all services from the provided Ties classes.
+     *
+     * @param tiesClasses - Array of Ties class constructors to register
+     * @returns Configured PureContainer with all services registered
+     * @throws DIContainerError if container creation or registration fails
+     *
+     * @example
+     * ```typescript
+     * const container = factory.createMicroserviceContainer([
+     *   PaymentsTies,
+     *   BillingTies,
+     *   ConfigTies
+     * ]);
+     *
+     * // Use the container to resolve services
+     * const paymentsService = container.run('PaymentsService');
+     * const config = container.runConstant('PaymentsConfig');
+     * ```
+     */
+    createMicroserviceContainer(tiesClasses: TiesInstance[]): PureContainer<string>;
+    /**
+     * Create a PureContainer with custom configuration.
+     *
+     * Allows creating containers with custom scope settings or other options.
+     * Still registers the provided Ties classes.
+     *
+     * @param tiesClasses - Array of Ties class constructors to register
+     * @param options - PureContainer configuration options
+     * @returns Configured PureContainer with all services registered
+     * @throws DIContainerError if container creation or registration fails
+     *
+     * @example
+     * ```typescript
+     * const container = factory.createCustomContainer(
+     *   [PaymentsTies],
+     *   { defaultScope: 'Transient' }
+     * );
+     * ```
+     */
+    createCustomContainer(tiesClasses: TiesInstance[], options?: {
+        defaultScope?: 'Singleton' | 'Transient';
+    }): PureContainer<string>;
+    /**
+     * Validate that a container has all required services registered.
+     *
+     * Convenience method that delegates to TiesRegistrar.validateContainer().
+     * Useful for ensuring container integrity after creation.
+     *
+     * @param container - PureContainer to validate
+     * @param requiredServices - Array of service names that must be registered
+     * @throws Error if any required service is not registered
+     *
+     * @example
+     * ```typescript
+     * const container = factory.createMicroserviceContainer([PaymentsTies]);
+     * factory.validateContainer(container, ['PaymentsService', 'PaymentsConfig']);
+     * ```
+     */
+    validateContainer(container: PureContainer<string>, requiredServices: string[]): void;
+    /**
+     * Create a container and validate it has all expected services.
+     *
+     * Combines container creation with validation in a single step.
+     * Automatically extracts expected service names from Ties classes if possible.
+     *
+     * @param tiesClasses - Array of Ties class constructors to register
+     * @param additionalServices - Additional service names to validate (optional)
+     * @returns Validated PureContainer with all services registered
+     * @throws DIContainerError if container creation fails
+     * @throws Error if validation fails
+     *
+     * @example
+     * ```typescript
+     * const container = factory.createValidatedContainer([PaymentsTies]);
+     * // Container is guaranteed to have all services registered by PaymentsTies
+     * ```
+     */
+    createValidatedContainer(tiesClasses: TiesInstance[], additionalServices?: string[]): PureContainer<string>;
+}
+//# sourceMappingURL=pure-container-factory.d.ts.map

package/out/dist/src/core/runtime-web/di/pure-container-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-container-factory.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/di/pure-container-factory.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAI3D;;;;;;;;;;;;;;;GAeG;AACH,qBACa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;;IAM9C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2BAA2B,CAAC,WAAW,EAAE,YAAY,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC;IAoB/E;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBAAqB,CACnB,WAAW,EAAE,YAAY,EAAE,EAC3B,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,WAAW,GAAG,WAAW,CAAA;KAAO,GACzD,aAAa,CAAC,MAAM,CAAC;IAcxB;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IAIrF;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAAwB,CACtB,WAAW,EAAE,YAAY,EAAE,EAC3B,kBAAkB,GAAE,MAAM,EAAO,GAChC,aAAa,CAAC,MAAM,CAAC;CAazB"}

package/out/dist/src/core/runtime-web/di/ties-registrar.d.ts

@@ -0,0 +1,87 @@
+import { PureContainer } from '@worktif/utils';
+import type { TiesInstance } from '../../../lib/runtime-web/types';
+/**
+ * Ties registration helper for PureContainer integration.
+ *
+ * Processes Ties classes and registers their services with a PureContainer instance.
+ * Each Ties class must implement a register(container: PureContainer<string>) method
+ * that uses container.tie(), container.tieConst(), or container.tieSingleton() to
+ * register services.
+ *
+ * @example
+ * ```typescript
+ * const registrar = new TiesRegistrar();
+ * const container = new PureContainer<string>({ defaultScope: 'Singleton' });
+ *
+ * registrar.registerTies(container, [PaymentsTies, BillingTies]);
+ *
+ * // Now container has all services registered by the Ties classes
+ * const paymentsService = container.run('PaymentsService');
+ * ```
+ */
+export declare class TiesRegistrar {
+    /**
+     * Register all Ties classes with the provided container.
+     *
+     * Calls the register(container) method on each Ties class instance.
+     * The Ties classes are responsible for calling container.tie(),
+     * container.tieConst(), or container.tieSingleton() to register their services.
+     *
+     * @param container - PureContainer instance to register services with
+     * @param tiesClasses - Array of Ties class constructors
+     * @throws TiesRegistrationError if a Ties class doesn't implement register()
+     *
+     * @example
+     * ```typescript
+     * // Ties class example
+     * class PaymentsTies {
+     *   register(container: PureContainer<string>): void {
+     *     container.tieSingleton({
+     *       PaymentsService: {
+     *         instance: PaymentsService,
+     *         args: []
+     *       }
+     *     });
+     *   }
+     * }
+     *
+     * registrar.registerTies(container, [PaymentsTies]);
+     * ```
+     */
+    registerTies(container: PureContainer<string>, tiesClasses: TiesInstance[]): void;
+    /**
+     * Validate that all required services are registered in the container.
+     *
+     * Attempts to resolve each service name to ensure it's properly registered.
+     * This is useful for catching missing service registrations early.
+     *
+     * @param container - PureContainer to validate
+     * @param requiredServices - Array of service names that must be registered
+     * @throws Error if any required service is not registered
+     *
+     * @example
+     * ```typescript
+     * registrar.validateContainer(container, ['PaymentsService', 'BillingService']);
+     * ```
+     */
+    validateContainer(container: PureContainer<string>, requiredServices: string[]): void;
+    /**
+     * Extract service names from Ties classes for validation.
+     *
+     * This is a helper method that can be used to automatically determine
+     * which services should be registered by a set of Ties classes.
+     * Note: This requires the Ties classes to expose their service names,
+     * which is optional but recommended for better error reporting.
+     *
+     * @param tiesClasses - Array of Ties class constructors
+     * @returns Array of service names that should be registered
+     *
+     * @example
+     * ```typescript
+     * const expectedServices = registrar.extractServiceNames([PaymentsTies]);
+     * registrar.validateContainer(container, expectedServices);
+     * ```
+     */
+    extractServiceNames(tiesClasses: TiesInstance[]): string[];
+}
+//# sourceMappingURL=ties-registrar.d.ts.map

package/out/dist/src/core/runtime-web/di/ties-registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ties-registrar.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/di/ties-registrar.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,YAAY,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,YAAY,EAAE,GAAG,IAAI;IA6BjF;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IAmBrF;;;;;;;;;;;;;;;;OAgBG;IACH,mBAAmB,CAAC,WAAW,EAAE,YAAY,EAAE,GAAG,MAAM,EAAE;CAsB3D"}

package/out/dist/src/core/runtime-web/factory/handler-wrappers.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Lambda context information for logging and monitoring.
+ */
+export interface LambdaContextInfo {
+    /** Lambda function name */
+    functionName?: string;
+    /** Lambda function version */
+    functionVersion?: string;
+    /** AWS request ID */
+    awsRequestId?: string;
+    /** Remaining time in milliseconds */
+    getRemainingTimeInMillis?: () => number;
+    /** Memory limit in MB */
+    memoryLimitInMB?: string;
+    /** Log group name */
+    logGroupName?: string;
+    /** Log stream name */
+    logStreamName?: string;
+}
+/**
+ * Handler metadata for logging context.
+ */
+export interface HandlerMetadata {
+    /** Lambda identifier (e.g., 'payments.charge') */
+    id: string;
+    /** Service name (e.g., 'payments') */
+    service: string;
+}
+/**
+ * Execution metrics collected during handler invocation.
+ */
+export interface ExecutionMetrics {
+    /** Start timestamp */
+    startTime: number;
+    /** End timestamp */
+    endTime: number;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Memory usage information (if available) */
+    memoryUsed?: number;
+    /** Remaining time when handler completed */
+    remainingTime?: number;
+}
+/**
+ * Logging wrapper for Lambda invocation lifecycle.
+ *
+ * Provides structured logging for Lambda invocation start/end with
+ * contextual information including timing, memory usage, and AWS
+ * Lambda context details.
+ *
+ * @param handler - Original Lambda handler function
+ * @param metadata - Handler metadata for logging context
+ * @returns Wrapped handler with logging
+ *
+ * @example
+ * ```typescript
+ * const wrappedHandler = loggingWrapper(
+ *   async (event, context) => { return { success: true }; },
+ *   { id: 'payments.charge', service: 'payments' }
+ * );
+ * ```
+ */
+export declare function loggingWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
+/**
+ * Error wrapper for Lambda handler error handling.
+ *
+ * Catches and logs errors with structured information, then returns
+ * appropriate error responses. Handles both thrown errors and rejected
+ * promises consistently.
+ *
+ * @param handler - Original Lambda handler function
+ * @param metadata - Handler metadata for error context
+ * @returns Wrapped handler with error handling
+ *
+ * @example
+ * ```typescript
+ * const wrappedHandler = errorWrapper(
+ *   async (event, context) => { return { success: true }; },
+ *   { id: 'payments.charge', service: 'payments' }
+ * );
+ * ```
+ */
+export declare function errorWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
+/**
+ * Timing wrapper for Lambda handler performance monitoring.
+ *
+ * Measures handler execution time and memory usage, providing
+ * detailed performance metrics for monitoring and optimization.
+ *
+ * @param handler - Original Lambda handler function
+ * @param metadata - Handler metadata for timing context
+ * @returns Wrapped handler with timing measurements
+ *
+ * @example
+ * ```typescript
+ * const wrappedHandler = timingWrapper(
+ *   async (event, context) => { return { success: true }; },
+ *   { id: 'payments.charge', service: 'payments' }
+ * );
+ * ```
+ */
+export declare function timingWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
+/**
+ * Combined wrapper that applies logging, error handling, and timing.
+ *
+ * Convenience function that applies all three wrappers in the correct
+ * order: timing (innermost) → error handling → logging (outermost).
+ *
+ * @param handler - Original Lambda handler function
+ * @param metadata - Handler metadata for all wrappers
+ * @returns Fully wrapped handler with all enhancements
+ *
+ * @example
+ * ```typescript
+ * const wrappedHandler = fullWrapper(
+ *   async (event, context) => { return { success: true }; },
+ *   { id: 'payments.charge', service: 'payments' }
+ * );
+ * ```
+ */
+export declare function fullWrapper(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: HandlerMetadata): (event: unknown, context: unknown) => Promise<unknown>;
+//# sourceMappingURL=handler-wrappers.d.ts.map

package/out/dist/src/core/runtime-web/factory/handler-wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-wrappers.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/factory/handler-wrappers.ts"],"names":[],"mappings":"AAkBA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2BAA2B;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,wBAAwB,CAAC,EAAE,MAAM,MAAM,CAAC;IACxC,yBAAyB;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/D,QAAQ,EAAE,eAAe,GACxB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAoDxD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/D,QAAQ,EAAE,eAAe,GACxB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAkDxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/D,QAAQ,EAAE,eAAe,GACxB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CA+CxD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/D,QAAQ,EAAE,eAAe,GACxB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CASxD"}

package/out/dist/src/core/runtime-web/factory/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lambda Handler Factory Module
+ *
+ * Provides factory classes and utilities for creating Lambda handlers with
+ * dependency injection support. This module bridges the gap between the
+ * existing Purenow Core LambdaApi infrastructure and the new Runtime Web
+ * Core dependency injection system.
+ */
+export { LambdaHandlerFactory } from './lambda-handler-factory';
+export { RuntimeWebLambdaHandler } from './runtime-web-lambda-handler';
+export { loggingWrapper, errorWrapper, timingWrapper, fullWrapper, type HandlerMetadata, type LambdaContextInfo, type ExecutionMetrics, } from './handler-wrappers';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/src/core/runtime-web/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/factory/index.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EACL,cAAc,EACd,YAAY,EACZ,aAAa,EACb,WAAW,EACX,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC"}

package/out/dist/src/core/runtime-web/factory/lambda-handler-factory.d.ts

@@ -0,0 +1,110 @@
+import { PureContainer } from '@worktif/utils';
+import type { LambdaDefinition } from '../../../lib/runtime-web/types';
+import type { RuntimeWebLambdaHandler } from './runtime-web-lambda-handler';
+/**
+ * Factory for creating Lambda handlers with dependency injection.
+ *
+ * Transforms user-provided Lambda definitions into full Lambda handler classes
+ * that extend LambdaApi and include automatic dependency injection using
+ * PureContainer. Handles the complexity of DI resolution and error wrapping.
+ *
+ * @example
+ * ```typescript
+ * const factory = new LambdaHandlerFactory();
+ * const handler = factory.create(lambdaDefinition, container);
+ *
+ * // Handler is ready to be invoked by AWS Lambda runtime
+ * const result = await handler.handler(event, context);
+ * ```
+ */
+export declare class LambdaHandlerFactory {
+    private readonly logger;
+    constructor();
+    /**
+     * Create a Lambda handler class instance from a definition.
+     *
+     * Creates a RuntimeWebLambdaHandler that extends LambdaApi and includes
+     * automatic dependency injection. The handler will resolve dependencies
+     * from the provided container and inject them into the user's handler function.
+     *
+     * @param definition - Lambda definition with handler and dependencies
+     * @param container - PureContainer with registered services
+     * @returns Lambda handler class instance ready for AWS Lambda runtime
+     *
+     * @example
+     * ```typescript
+     * const lambdaDef: LambdaDefinition = {
+     *   id: 'charge',
+     *   ties: [PaymentsService, BillingService],
+     *   handler: (deps) => async (event, context) => {
+     *     return await deps.paymentsService.processCharge(event.body);
+     *   }
+     * };
+     *
+     * const handler = factory.create(lambdaDef, container);
+     * ```
+     */
+    create(definition: LambdaDefinition, container: PureContainer<string>): RuntimeWebLambdaHandler;
+    /**
+     * Inject dependencies from PureContainer using class references.
+     *
+     * Resolves class references to service instances using PureContainer.run()
+     * with class names as keys. Converts class names to camelCase for the
+     * dependency object keys (e.g., PaymentsService → paymentsService).
+     *
+     * @param ties - Array of class constructors for dependency injection
+     * @param container - PureContainer with registered services
+     * @returns Object with camelCase keys containing resolved dependencies
+     * @throws Error if any dependency cannot be resolved
+     *
+     * @example
+     * ```typescript
+     * const ties = [PaymentsService, BillingService];
+     * const deps = factory.injectDependencies(ties, container);
+     * // Result: { paymentsService: PaymentsService, billingService: BillingService }
+     * ```
+     */
+    injectDependencies(ties: Array<new (...args: unknown[]) => unknown>, container: PureContainer<string>): Record<string, unknown>;
+    /**
+     * Wrap a handler function with logging and error handling.
+     *
+     * Adds structured logging for Lambda invocation start/end, error handling
+     * that catches and logs exceptions, and timing information. Returns a
+     * wrapped handler that maintains the same signature as the original.
+     *
+     * @param handler - Original Lambda handler function
+     * @param metadata - Lambda metadata for logging context
+     * @returns Wrapped handler with logging and error handling
+     *
+     * @example
+     * ```typescript
+     * const wrappedHandler = factory.wrapHandler(
+     *   async (event, context) => { return { success: true }; },
+     *   { id: 'payments.charge', service: 'payments' }
+     * );
+     * ```
+     */
+    wrapHandler(handler: (event: unknown, context: unknown) => Promise<unknown>, metadata: {
+        id: string;
+        service: string;
+    }): (event: unknown, context: unknown) => Promise<unknown>;
+    /**
+     * Convert class name to camelCase for dependency object keys.
+     *
+     * Converts PascalCase class names to camelCase property names for the
+     * dependency injection object. This provides a consistent naming convention
+     * for injected dependencies.
+     *
+     * @param className - PascalCase class name
+     * @returns camelCase property name
+     *
+     * @example
+     * ```typescript
+     * factory.toCamelCase('PaymentsService'); // 'paymentsService'
+     * factory.toCamelCase('BillingService');  // 'billingService'
+     * factory.toCamelCase('ConfigService');   // 'configService'
+     * ```
+     */
+    private toCamelCase;
+}
+//# sourceMappingURL=lambda-handler-factory.d.ts.map

package/out/dist/src/core/runtime-web/factory/lambda-handler-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda-handler-factory.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/factory/lambda-handler-factory.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAmB,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,qBACa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;;IAQhC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,UAAU,EAAE,gBAAgB,EAAE,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,uBAAuB;IAY/F;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB,CAChB,IAAI,EAAE,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,EAChD,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAqC1B;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CACT,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/D,QAAQ,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GACxC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;IAIzD;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,WAAW;CAGpB"}