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

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

@@ -0,0 +1,94 @@
+import { PureContainer } from '@worktif/utils';
+import { LambdaApi } from '@worktif/purews';
+import type { LambdaInterface } from '@aws-lambda-powertools/commons/types';
+import type { LambdaDefinition } from '../../../lib/runtime-web/types';
+import type { LambdaHandlerFactory } from './lambda-handler-factory';
+/**
+ * Runtime Web Lambda handler that extends LambdaApi with dependency injection.
+ *
+ * This class bridges the gap between the existing Purenow Core LambdaApi
+ * infrastructure and the new Runtime Web Core dependency injection system.
+ * It extends LambdaApi to maintain compatibility while adding automatic
+ * DI resolution and user handler invocation.
+ *
+ * @example
+ * ```typescript
+ * const handler = new RuntimeWebLambdaHandler(definition, container, factory);
+ *
+ * // AWS Lambda runtime calls this method
+ * const result = await handler.handler(event, context);
+ * ```
+ */
+export declare class RuntimeWebLambdaHandler extends LambdaApi implements LambdaInterface {
+    private readonly definition;
+    private readonly container;
+    private readonly factory;
+    private readonly logger;
+    private readonly userHandler;
+    /**
+     * Create a Runtime Web Lambda handler.
+     *
+     * @param definition - Lambda definition with handler and dependencies
+     * @param container - PureContainer with registered services
+     * @param factory - Factory instance for dependency injection and wrapping
+     */
+    constructor(definition: LambdaDefinition, container: PureContainer<string>, factory: LambdaHandlerFactory);
+    /**
+     * Main Lambda handler method called by AWS Lambda runtime.
+     *
+     * This method is called by the AWS Lambda runtime for each invocation.
+     * It injects dependencies, calls the user's handler function, and returns
+     * the result. Extends the existing LambdaApi.handler() method to add
+     * dependency injection support.
+     *
+     * @param event - Lambda event object
+     * @param context - Lambda context object
+     * @returns Promise resolving to the handler result
+     *
+     * @example
+     * ```typescript
+     * // AWS Lambda runtime calls this automatically
+     * const result = await handler.handler(apiGatewayEvent, lambdaContext);
+     * ```
+     */
+    handler(event: unknown, context: unknown): Promise<unknown>;
+    /**
+     * Create the user handler with dependency injection and wrapping.
+     *
+     * This method is called once during construction to resolve dependencies
+     * and create the wrapped user handler. The result is cached for reuse
+     * across Lambda invocations to avoid repeated DI resolution.
+     *
+     * @returns Wrapped user handler with dependencies injected
+     * @private
+     */
+    private createUserHandler;
+    /**
+     * Get the Lambda definition used by this handler.
+     *
+     * Provides access to the original Lambda definition for debugging
+     * or introspection purposes.
+     *
+     * @returns The Lambda definition
+     */
+    getDefinition(): LambdaDefinition;
+    /**
+     * Get the PureContainer used by this handler.
+     *
+     * Provides access to the DI container for debugging or advanced
+     * use cases. Generally not needed in normal operation.
+     *
+     * @returns The PureContainer instance
+     */
+    getContainer(): PureContainer<string>;
+    /**
+     * Check if the handler has been properly initialized.
+     *
+     * Verifies that the user handler has been created successfully
+     * and is ready for invocation.
+     *
+     * @returns True if handler is ready, false otherwise
+     */
+    isReady(): boolean;
+}
+//# sourceMappingURL=runtime-web-lambda-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-web-lambda-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/factory/runtime-web-lambda-handler.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAU,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,uBAAwB,SAAQ,SAAU,YAAW,eAAe;IAY7E,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyD;IAErF;;;;;;OAMG;gBAEgB,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAChC,OAAO,EAAE,oBAAoB;IAsBhD;;;;;;;;;;;;;;;;;OAiBG;IACG,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BjE;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAmCzB;;;;;;;OAOG;IACH,aAAa,IAAI,gBAAgB;IAIjC;;;;;;;OAOG;IACH,YAAY,IAAI,aAAa,CAAC,MAAM,CAAC;IAIrC;;;;;;;OAOG;IACH,OAAO,IAAI,OAAO;CAGnB"}

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

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+export * from './detector';
+export * from './di';
+export * from './factory';
+export * from './pipelines';
+export * from './registrar';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/runtime-web/index.ts"],"names":[],"mappings":"AAgBA,OAAO,kBAAkB,CAAC;AAE1B,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

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

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export * from './lambda-pipeline';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/pipelines/index.ts"],"names":[],"mappings":"AAgBA,OAAO,kBAAkB,CAAC;AAK1B,cAAc,mBAAmB,CAAC"}

package/out/dist/src/core/runtime-web/pipelines/lambda-pipeline.d.ts

@@ -0,0 +1,110 @@
+import type { LambdaMetadata, RuntimeWebConfig } from '../../../lib/runtime-web/types';
+/**
+ * Lambda execution pipeline for Runtime Target Core.
+ *
+ * Handles Lambda function execution with dependency injection.
+ * Resolves the Lambda ID from environment variables, gets the appropriate
+ * DI container, creates the handler with injected dependencies, and executes
+ * the business logic.
+ *
+ * **Execution Flow**:
+ * 1. Resolve Lambda ID from LAMBDA_ID environment variable
+ * 2. Use MicroserviceRegistrar to get container for Lambda
+ * 3. Use LambdaHandlerFactory to create handler with DI
+ * 4. Execute handler and return result
+ *
+ * **Requirements**: REQ-06, REQ-08
+ */
+export declare class LambdaPipeline {
+    private readonly logger;
+    private registrar?;
+    private handlerFactory?;
+    /**
+     * Execute Lambda pipeline for server-side function execution.
+     *
+     * Processes the microservice registry, resolves the Lambda ID from environment
+     * variables, gets the appropriate DI container, creates the handler with
+     * dependency injection, and executes the business logic.
+     *
+     * @param config - Purenow configuration with microservice registry
+     * @param context - Lambda environment context with metadata
+     * @returns Result from Lambda handler execution
+     *
+     * @example
+     * ```typescript
+     * const pipeline = new LambdaPipeline();
+     * const result = await pipeline.execute(config, {
+     *   type: 'lambda',
+     *   metadata: {
+     *     functionName: 'my-app-payments-charge-dev',
+     *     version: '$LATEST',
+     *     region: 'us-east-1',
+     *     memoryLimit: 1024,
+     *     requestId: 'abc-123'
+     *   }
+     * });
+     * ```
+     */
+    execute(config: RuntimeWebConfig, context: {
+        type: 'lambda';
+        metadata: LambdaMetadata;
+    }): Promise<unknown>;
+    /**
+     * Initialize the microservice registrar and process all services.
+     *
+     * Creates a new MicroserviceRegistrar and processes all microservice
+     * definitions from the configuration to build DI containers.
+     *
+     * @param config - Purenow configuration
+     * @private
+     */
+    private initializeRegistrar;
+    /**
+     * Resolve Lambda ID from environment variables.
+     *
+     * Gets the Lambda ID from the LAMBDA_ID environment variable that
+     * is set by the CDK stack during deployment.
+     *
+     * @returns Lambda ID (e.g., 'payments.charge')
+     * @throws Error if LAMBDA_ID environment variable is not set
+     * @private
+     */
+    private resolveLambdaId;
+    /**
+     * Get DI container for the specified Lambda.
+     *
+     * Uses the MicroserviceRegistrar to look up the appropriate DI container
+     * for the Lambda function based on its ID.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns PureContainer instance for the Lambda's microservice
+     * @throws Error if container not found
+     * @private
+     */
+    private getContainerForLambda;
+    /**
+     * Create Lambda handler with dependency injection.
+     *
+     * Uses the LambdaHandlerFactory to create a handler instance with
+     * automatic dependency injection from the DI container.
+     *
+     * @param lambdaId - Full Lambda ID
+     * @param container - PureContainer with registered services
+     * @returns Lambda handler instance ready for execution
+     * @private
+     */
+    private createHandlerWithDI;
+    /**
+     * Find Lambda definition by ID from the processed microservices.
+     *
+     * Uses the MicroserviceRegistrar to retrieve the Lambda definition
+     * that matches the specified ID.
+     *
+     * @param lambdaId - Full Lambda ID to find
+     * @returns Lambda definition
+     * @throws Error if Lambda definition not found
+     * @private
+     */
+    private findLambdaDefinition;
+}
+//# sourceMappingURL=lambda-pipeline.d.ts.map

package/out/dist/src/core/runtime-web/pipelines/lambda-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda-pipeline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/pipelines/lambda-pipeline.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK/E;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAEpB;IAEH,OAAO,CAAC,SAAS,CAAC,CAAwB;IAC1C,OAAO,CAAC,cAAc,CAAC,CAAuB;IAE9C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,OAAO,CAAC,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAgDhH;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IA8B3B;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;IAcvB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,qBAAqB;IAwB7B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,mBAAmB;IA+B3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;CAW7B"}

package/out/dist/src/core/runtime-web/registrar/container-registry.d.ts

@@ -0,0 +1,261 @@
+import { PureContainer } from '@worktif/utils';
+import type { LambdaDefinition } from '../../../lib/runtime-web/types';
+/**
+ * Registry for managing PureContainer instances and Lambda-to-service mappings.
+ *
+ * Provides a centralized registry for storing and retrieving DI containers
+ * for microservices, along with mappings between Lambda functions and their
+ * parent services. This enables clean separation of concerns and makes the
+ * MicroserviceRegistrar more focused on processing logic.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ContainerRegistry();
+ *
+ * // Register a service with its container
+ * registry.registerService('payments', paymentsContainer);
+ *
+ * // Map Lambda to service
+ * registry.registerLambda('payments.charge', 'payments');
+ *
+ * // Retrieve container for Lambda
+ * const container = registry.getContainer('payments.charge');
+ * ```
+ */
+export declare class ContainerRegistry {
+    private readonly containers;
+    private readonly lambdaToService;
+    private readonly lambdaDefinitions;
+    /**
+     * Register a service with its DI container.
+     *
+     * Stores the PureContainer instance for the given service name.
+     * Validates that the service name is not already registered to prevent
+     * accidental overwrites.
+     *
+     * @param serviceName - Name of the microservice
+     * @param container - PureContainer instance for the service
+     * @throws DIContainerError if service is already registered
+     *
+     * @example
+     * ```typescript
+     * const paymentsContainer = new PureContainer<string>();
+     * registry.registerService('payments', paymentsContainer);
+     * ```
+     */
+    registerService(serviceName: string, container: PureContainer<string>): void;
+    /**
+     * Register a Lambda function with its parent service and definition.
+     *
+     * Creates a mapping between the Lambda ID and its parent service name,
+     * and stores the Lambda definition for runtime lookup.
+     * This enables looking up the correct DI container for Lambda invocations.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @param serviceName - Name of the parent microservice
+     * @param definition - Lambda definition with handler and dependencies
+     * @throws DIContainerError if Lambda is already registered
+     * @throws MissingServiceError if parent service is not registered
+     *
+     * @example
+     * ```typescript
+     * registry.registerLambda('payments.charge', 'payments', chargeDefinition);
+     * registry.registerLambda('payments.refund', 'payments', refundDefinition);
+     * ```
+     */
+    registerLambda(lambdaId: string, serviceName: string, definition: LambdaDefinition): void;
+    /**
+     * Get the DI container for a service by name.
+     *
+     * Retrieves the PureContainer instance for the given service name.
+     *
+     * @param serviceName - Name of the microservice
+     * @returns PureContainer instance for the service
+     * @throws MissingServiceError if service is not registered
+     *
+     * @example
+     * ```typescript
+     * const container = registry.getContainer('payments');
+     * const paymentsService = container.run('PaymentsService');
+     * ```
+     */
+    getContainer(serviceName: string): PureContainer<string>;
+    /**
+     * Get the DI container for a Lambda function.
+     *
+     * Looks up the parent service for the Lambda ID and returns the
+     * corresponding PureContainer instance.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns PureContainer instance for the Lambda's microservice
+     * @throws MissingServiceError if Lambda or service is not registered
+     *
+     * @example
+     * ```typescript
+     * const container = registry.getContainerForLambda('payments.charge');
+     * const paymentsService = container.run('PaymentsService');
+     * ```
+     */
+    getContainerForLambda(lambdaId: string): PureContainer<string>;
+    /**
+     * Get the parent service name for a Lambda function.
+     *
+     * Looks up the service name that owns the given Lambda ID.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns Name of the parent microservice
+     * @throws MissingServiceError if Lambda is not registered
+     *
+     * @example
+     * ```typescript
+     * const serviceName = registry.getLambdaService('payments.charge');
+     * console.log(serviceName); // 'payments'
+     * ```
+     */
+    getLambdaService(lambdaId: string): string;
+    /**
+     * Get the Lambda definition for a Lambda function.
+     *
+     * Retrieves the stored Lambda definition for the given Lambda ID.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns Lambda definition with handler and dependencies
+     * @throws MissingServiceError if Lambda is not registered
+     *
+     * @example
+     * ```typescript
+     * const definition = registry.getLambdaDefinition('payments.charge');
+     * console.log(definition.ties); // [PaymentsService, BillingService]
+     * ```
+     */
+    getLambdaDefinition(lambdaId: string): LambdaDefinition;
+    /**
+     * Check if a service is registered.
+     *
+     * @param serviceName - Name of the service to check
+     * @returns True if service is registered
+     *
+     * @example
+     * ```typescript
+     * if (registry.hasService('payments')) {
+     *   const container = registry.getContainer('payments');
+     * }
+     * ```
+     */
+    hasService(serviceName: string): boolean;
+    /**
+     * Check if a Lambda is registered.
+     *
+     * @param lambdaId - Full Lambda ID to check
+     * @returns True if Lambda is registered
+     *
+     * @example
+     * ```typescript
+     * if (registry.hasLambda('payments.charge')) {
+     *   const container = registry.getContainerForLambda('payments.charge');
+     * }
+     * ```
+     */
+    hasLambda(lambdaId: string): boolean;
+    /**
+     * Get all registered service names.
+     *
+     * @returns Array of service names that have been registered
+     *
+     * @example
+     * ```typescript
+     * const services = registry.getServiceNames();
+     * console.log(services); // ['payments', 'users', 'notifications']
+     * ```
+     */
+    getServiceNames(): string[];
+    /**
+     * Get all registered Lambda IDs.
+     *
+     * @returns Array of Lambda IDs that have been registered
+     *
+     * @example
+     * ```typescript
+     * const lambdas = registry.getLambdaIds();
+     * console.log(lambdas); // ['payments.charge', 'payments.refund', 'users.create']
+     * ```
+     */
+    getLambdaIds(): string[];
+    /**
+     * Get all Lambda IDs for a specific service.
+     *
+     * @param serviceName - Name of the service
+     * @returns Array of Lambda IDs belonging to the service
+     *
+     * @example
+     * ```typescript
+     * const paymentLambdas = registry.getLambdasForService('payments');
+     * console.log(paymentLambdas); // ['payments.charge', 'payments.refund']
+     * ```
+     */
+    getLambdasForService(serviceName: string): string[];
+    /**
+     * Remove a service and all its Lambda mappings.
+     *
+     * Removes the service container and all Lambda-to-service mappings
+     * for Lambdas belonging to this service.
+     *
+     * @param serviceName - Name of the service to remove
+     * @returns True if service was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * const removed = registry.removeService('payments');
+     * console.log(removed); // true if 'payments' was registered
+     * ```
+     */
+    removeService(serviceName: string): boolean;
+    /**
+     * Remove a Lambda mapping.
+     *
+     * Removes the Lambda-to-service mapping for the given Lambda ID.
+     * Does not affect the parent service container.
+     *
+     * @param lambdaId - Full Lambda ID to remove
+     * @returns True if Lambda was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * const removed = registry.removeLambda('payments.charge');
+     * console.log(removed); // true if 'payments.charge' was registered
+     * ```
+     */
+    removeLambda(lambdaId: string): boolean;
+    /**
+     * Clear all registered services and Lambda mappings.
+     *
+     * Removes all containers, mappings, and definitions from the registry.
+     * Useful for testing or when reinitializing the registry.
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * console.log(registry.getServiceNames()); // []
+     * console.log(registry.getLambdaIds()); // []
+     * ```
+     */
+    clear(): void;
+    /**
+     * Get registry statistics.
+     *
+     * Returns information about the current state of the registry.
+     *
+     * @returns Object with service and Lambda counts
+     *
+     * @example
+     * ```typescript
+     * const stats = registry.getStats();
+     * console.log(stats); // { services: 3, lambdas: 8 }
+     * ```
+     */
+    getStats(): {
+        services: number;
+        lambdas: number;
+    };
+}
+//# sourceMappingURL=container-registry.d.ts.map

package/out/dist/src/core/runtime-web/registrar/container-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-registry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/registrar/container-registry.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiD;IAC5E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA4C;IAE9E;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI;IAW5E;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAmBzF;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;IAQxD;;;;;;;;;;;;;;;OAeG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;IAK9D;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAQ1C;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IAQvD;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIxC;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;;;;;;OAUG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;;;;;;;;;OAUG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE;IAYnD;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAoB3C;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,IAAI;IAMb;;;;;;;;;;;;OAYG;IACH,QAAQ,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAMlD"}

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

@@ -0,0 +1,6 @@
+/**
+ * Microservice registration module for Runtime Target Core.
+ */
+export { MicroserviceRegistrar } from './microservice-registrar';
+export { ContainerRegistry } from './container-registry';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/registrar/index.ts"],"names":[],"mappings":"AAgBA;;GAEG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,167 @@
+import { PureContainer } from '@worktif/utils';
+import type { LambdaDefinition, MicroserviceDefinition } from '../../../lib/runtime-web/types';
+import { ContainerRegistry } from '../../runtime-web/registrar/container-registry';
+/**
+ * Microservice registrar for managing DI containers and Lambda mappings.
+ *
+ * Processes microservice definitions to create PureContainer instances and
+ * maintains mappings between Lambda functions and their parent services.
+ * This enables the framework to resolve the correct DI container for each
+ * Lambda invocation.
+ *
+ * @example
+ * ```typescript
+ * const registrar = new MicroserviceRegistrar();
+ *
+ * // Process a microservice definition
+ * registrar.processService('payments', {
+ *   ties: [PaymentsTies],
+ *   lambdas: [chargeHandler, refundHandler]
+ * });
+ *
+ * // Get container for a specific Lambda
+ * const container = registrar.getContainerForLambda('payments.charge');
+ * ```
+ */
+export declare class MicroserviceRegistrar {
+    private readonly containerFactory;
+    private readonly registry;
+    constructor();
+    /**
+     * Process a microservice definition and create its DI container.
+     *
+     * Creates a PureContainer from the Ties classes and processes all Lambda
+     * definitions to establish service mappings. Auto-sets the service property
+     * on each Lambda definition and generates Lambda IDs.
+     *
+     * @param serviceName - Name of the microservice
+     * @param definition - Microservice definition with Ties and Lambdas
+     * @throws Error if service processing fails
+     *
+     * @example
+     * ```typescript
+     * registrar.processService('payments', {
+     *   ties: [PaymentsTies, BillingTies],
+     *   lambdas: [
+     *     {
+     *       id: 'charge',
+     *       ties: [PaymentsService],
+     *       handler: (deps) => async (event) => { ... }
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    processService(serviceName: string, definition: MicroserviceDefinition): void;
+    /**
+     * Get the DI container for a specific Lambda function.
+     *
+     * Looks up the service name for the Lambda ID and returns the
+     * corresponding PureContainer instance.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns PureContainer instance for the Lambda's microservice
+     * @throws MissingServiceError if Lambda or service not found
+     *
+     * @example
+     * ```typescript
+     * const container = registrar.getContainerForLambda('payments.charge');
+     * const paymentsService = container.run('PaymentsService');
+     * ```
+     */
+    getContainerForLambda(lambdaId: string): PureContainer<string>;
+    /**
+     * Generate a Lambda ID from service name and Lambda definition.
+     *
+     * Uses explicit ID if provided, otherwise extracts from handler function name.
+     * The final ID format is always '{serviceName}.{lambdaId}'.
+     *
+     * @param serviceName - Name of the parent microservice
+     * @param definition - Lambda definition
+     * @returns Full Lambda ID
+     *
+     * @example
+     * ```typescript
+     * // With explicit ID
+     * generateLambdaId('payments', { id: 'charge', ... }) // → 'payments.charge'
+     *
+     * // Without explicit ID (extracts from handler name)
+     * generateLambdaId('payments', { handler: function processPayment() {...} }) // → 'payments.processPayment'
+     * ```
+     */
+    generateLambdaId(serviceName: string, definition: LambdaDefinition): string;
+    /**
+     * Get all registered service names.
+     *
+     * @returns Array of service names that have been processed
+     */
+    getServiceNames(): string[];
+    /**
+     * Get all registered Lambda IDs.
+     *
+     * @returns Array of Lambda IDs that have been processed
+     */
+    getLambdaIds(): string[];
+    /**
+     * Get the service name for a Lambda ID.
+     *
+     * @param lambdaId - Full Lambda ID
+     * @returns Service name or undefined if not found
+     */
+    getServiceForLambda(lambdaId: string): string | undefined;
+    /**
+     * Check if a service is registered.
+     *
+     * @param serviceName - Name of the service to check
+     * @returns True if service is registered
+     */
+    hasService(serviceName: string): boolean;
+    /**
+     * Check if a Lambda is registered.
+     *
+     * @param lambdaId - Full Lambda ID to check
+     * @returns True if Lambda is registered
+     */
+    hasLambda(lambdaId: string): boolean;
+    /**
+     * Get all Lambda definitions for a service.
+     *
+     * @param serviceName - Name of the service
+     * @returns Array of Lambda IDs for the service
+     */
+    getLambdasForService(serviceName: string): string[];
+    /**
+     * Clear all registered services and containers.
+     *
+     * Useful for testing or when reinitializing the registrar.
+     */
+    clear(): void;
+    /**
+     * Get Lambda definition by ID.
+     *
+     * Retrieves the Lambda definition for the specified Lambda ID.
+     *
+     * @param lambdaId - Full Lambda ID (e.g., 'payments.charge')
+     * @returns Lambda definition with handler and dependencies
+     * @throws Error if Lambda definition not found
+     */
+    getLambdaDefinition(lambdaId: string): LambdaDefinition;
+    /**
+     * Get the underlying container registry.
+     *
+     * Provides access to the internal ContainerRegistry for advanced use cases.
+     *
+     * @returns ContainerRegistry instance
+     */
+    getRegistry(): ContainerRegistry;
+    /**
+     * Validate a container has all required services (private helper).
+     *
+     * This is currently disabled but can be enabled for debugging.
+     *
+     * @param container - Container to validate
+     * @param definition - Microservice definition
+     */
+    private validateContainer;
+}
+//# sourceMappingURL=microservice-registrar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"microservice-registrar.d.ts","sourceRoot":"","sources":["../../../../../../src/core/runtime-web/registrar/microservice-registrar.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuB;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;;IAO7C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,sBAAsB,GAAG,IAAI;IA0B7E;;;;;;;;;;;;;;;OAeG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;IAI9D;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,GAAG,MAAM;IAU3E;;;;OAIG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;;;OAIG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;;;;OAKG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQzD;;;;;OAKG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIxC;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;;OAKG;IACH,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE;IAInD;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;OAQG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IAIvD;;;;;;OAMG;IACH,WAAW,IAAI,iBAAiB;IAIhC;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;CAa1B"}