@geekmidas/services 1.0.4 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @geekmidas/services
 
+## 1.1.1
+
+### Patch Changes
+
+- 🐛 [`9f02e9c`](https://github.com/geekmidas/toolbox/commit/9f02e9c8419db1e41692e996e177f2473237ca76) Thanks [@geekmidas](https://github.com/geekmidas)! - fix(services): bind `this` when invoking request-scoped logger methods
+
+  The request-scoped logger proxy re-resolved log methods at call time but
+  invoked them unbound. Pino's log methods read internal state off the
+  receiver (`this[Symbol(pino.msgPrefix)]`), so calling them without `this`
+  threw "Cannot read properties of undefined (reading 'Symbol(pino.msgPrefix)')"
+  in production (pino), while dev/test console & spy loggers were unaffected.
+  The proxy now invokes the resolved method with the current request's logger
+  as `this`.
+
+## 1.1.0
+
+### Minor Changes
+
+- [#5](https://github.com/geekmidas/toolbox/pull/5) [`811d740`](https://github.com/geekmidas/toolbox/commit/811d740ae3875d59ad1b0dc50261266963c8cb76) Thanks [@geekmidas](https://github.com/geekmidas)! - Move the tRPC and Middy service integrations from `@geekmidas/constructs` to `@geekmidas/services`, where they belong — they depend only on `@geekmidas/services`, not on any construct.
+  - ✨ **`@geekmidas/constructs`:** the `@geekmidas/constructs/trpc` and `@geekmidas/constructs/middy` entry points are removed (they were only just added). Import from `@geekmidas/services/trpc` and `@geekmidas/services/middy` instead. (`@trpc/server` is no longer a peer dependency of `@geekmidas/constructs`.)
+  - ✨ **`@geekmidas/services`:** adds `/trpc` (`createServicesMiddleware`, `createRequestContextMiddleware`) and `/middy` (`requestContext`, `addServices`, `withServices`, `EventServices`) exports.
+
+  The Middy middlewares were also tightened:
+  - `requestContext` / `withServices` now require an explicit `logger` (no `ConsoleLogger` default) and are generic over `TLogger extends Logger`, so a custom logger type is preserved.
+  - `addServices` / `withServices` now require an `envParser` (no implicit `process.env` default).
+  - 🐛 Resolved services are attached to `event.services` (matching the `Function`/`Cron` constructs).
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/{ServiceDiscovery-CadEgTKz.d.mts → ServiceDiscovery-BO8W-RY8.d.cts}

@@ -1,4 +1,4 @@
-import { Service } from "./types-B99KrvXR.mjs";
+import { Service } from "./types-Bgk-0NOO.cjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/ServiceDiscovery.d.ts
@@ -184,4 +184,4 @@ type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]
 //# sourceMappingURL=ServiceDiscovery.d.ts.map
 //#endregion
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };
-//# sourceMappingURL=ServiceDiscovery-CadEgTKz.d.mts.map
+//# sourceMappingURL=ServiceDiscovery-BO8W-RY8.d.cts.map

package/dist/{ServiceDiscovery-DF4OKEZp.d.cts.map → ServiceDiscovery-BO8W-RY8.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-DF4OKEZp.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}
+{"version":3,"file":"ServiceDiscovery-BO8W-RY8.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/{ServiceDiscovery-Cxus7ber.cjs → ServiceDiscovery-BrCUabG_.cjs}

@@ -1,4 +1,4 @@
-const require_context = require('./context-CkCPt2Fe.cjs');
+const require_context = require('./context-1ROj3zvL.cjs');
 
 //#region src/ServiceDiscovery.ts
 /**
@@ -195,4 +195,4 @@ Object.defineProperty(exports, 'ServiceDiscovery', {
     return ServiceDiscovery;
   }
 });
-//# sourceMappingURL=ServiceDiscovery-Cxus7ber.cjs.map
+//# sourceMappingURL=ServiceDiscovery-BrCUabG_.cjs.map

package/dist/{ServiceDiscovery-Cxus7ber.cjs.map → ServiceDiscovery-BrCUabG_.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-Cxus7ber.cjs","names":["envParser: EnvironmentParser<{}>","services: T","serviceContext","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAASC;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAASD;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLE,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}
+{"version":3,"file":"ServiceDiscovery-BrCUabG_.cjs","names":["envParser: EnvironmentParser<{}>","services: T","serviceContext","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAASC;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAASD;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLE,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}

package/dist/{ServiceDiscovery-DF4OKEZp.d.cts → ServiceDiscovery-CRq_bGbi.d.mts}

@@ -1,4 +1,4 @@
-import { Service } from "./types-BY9yrY6Y.cjs";
+import { Service } from "./types-BoyOCa57.mjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/ServiceDiscovery.d.ts
@@ -184,4 +184,4 @@ type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]
 //# sourceMappingURL=ServiceDiscovery.d.ts.map
 //#endregion
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };
-//# sourceMappingURL=ServiceDiscovery-DF4OKEZp.d.cts.map
+//# sourceMappingURL=ServiceDiscovery-CRq_bGbi.d.mts.map

package/dist/{ServiceDiscovery-CadEgTKz.d.mts.map → ServiceDiscovery-CRq_bGbi.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-CadEgTKz.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}
+{"version":3,"file":"ServiceDiscovery-CRq_bGbi.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/{ServiceDiscovery-SujDuYHr.mjs → ServiceDiscovery-WHikQSQv.mjs}

@@ -1,4 +1,4 @@
-import { serviceContext } from "./context-BojeLlxs.mjs";
+import { serviceContext } from "./context-CH2c0ftq.mjs";
 
 //#region src/ServiceDiscovery.ts
 /**
@@ -190,4 +190,4 @@ var ServiceDiscovery = class ServiceDiscovery {
 
 //#endregion
 export { ServiceDiscovery };
-//# sourceMappingURL=ServiceDiscovery-SujDuYHr.mjs.map
+//# sourceMappingURL=ServiceDiscovery-WHikQSQv.mjs.map

package/dist/{ServiceDiscovery-SujDuYHr.mjs.map → ServiceDiscovery-WHikQSQv.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-SujDuYHr.mjs","names":["envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAAS;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAAS;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLC,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}
+{"version":3,"file":"ServiceDiscovery-WHikQSQv.mjs","names":["envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAAS;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAAS;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLC,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}

package/dist/{context-CkCPt2Fe.cjs → context-1ROj3zvL.cjs}

@@ -73,7 +73,11 @@ function createRequestScopedLogger(bindings = []) {
 			if (prop === "child") return (obj) => createRequestScopedLogger([...bindings, obj]);
 			if (prop === "then" || typeof prop === "symbol") return void 0;
 			const value = resolve()[prop];
-			return typeof value === "function" ? (...args) => resolve()[prop](...args) : value;
+			return typeof value === "function" ? (...args) => {
+				const resolved = resolve();
+				const fn = resolved[prop];
+				return fn.apply(resolved, args);
+			} : value;
 		},
 		has(_target, prop) {
 			if (prop === "child") return true;
@@ -160,6 +164,12 @@ function exitRequestContext() {
 }
 
 //#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
 Object.defineProperty(exports, 'enterRequestContext', {
   enumerable: true,
   get: function () {
@@ -184,4 +194,4 @@ Object.defineProperty(exports, 'serviceContext', {
     return serviceContext;
   }
 });
-//# sourceMappingURL=context-CkCPt2Fe.cjs.map
+//# sourceMappingURL=context-1ROj3zvL.cjs.map

package/dist/context-1ROj3zvL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-1ROj3zvL.cjs","names":["AsyncLocalStorage","bindings: object[]","cachedBase: Logger | undefined","cachedResolved: Logger | undefined","obj: object","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * Resolve the logger for the current request, or throw if there is none.\n */\nfunction resolveRequestLogger(): Logger {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) {\n\t\tthrow new Error(\n\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t);\n\t}\n\treturn store.logger;\n}\n\n/**\n * Create a Logger that re-resolves its underlying logger on every call instead\n * of capturing it once.\n *\n * This is what makes it safe for a **singleton** service to grab the logger a\n * single time (e.g. during `register()`, which `ServiceDiscovery` only runs\n * once and then caches) and reuse that reference for every request: each log\n * call resolves the *current* request's logger from `AsyncLocalStorage`, so\n * requests no longer inherit the first request's logger (and its `requestId`,\n * user bindings, etc.).\n *\n * Implemented as a `Proxy` rather than a fixed list of methods so it forwards\n * the *entire* surface of whatever logger is supplied — including members\n * beyond the base `Logger` interface (e.g. a richer pino-backed logger's\n * `flush()` or `level`) and any methods added to `Logger` in the future.\n *\n * @param bindings - `child()` bindings applied, in order, on top of the\n *   resolved logger before each call.\n */\nfunction createRequestScopedLogger(bindings: object[] = []): Logger {\n\t// Memoise the resolved (optionally child) logger per underlying base logger\n\t// so we don't rebuild the child chain on every access within a request.\n\t// Recomputed whenever the current request's logger changes — there is no\n\t// await between the check and use, so this is safe under concurrency.\n\tlet cachedBase: Logger | undefined;\n\tlet cachedResolved: Logger | undefined;\n\n\tconst resolve = (): Logger => {\n\t\tconst base = resolveRequestLogger();\n\t\tif (base !== cachedBase) {\n\t\t\tcachedBase = base;\n\t\t\tcachedResolved = bindings.reduce<Logger>(\n\t\t\t\t(log, obj) => log.child(obj),\n\t\t\t\tbase,\n\t\t\t);\n\t\t}\n\t\treturn cachedResolved as Logger;\n\t};\n\n\treturn new Proxy({} as Logger, {\n\t\tget(_target, prop) {\n\t\t\t// `child()` must stay request-scoped: return a new proxy carrying the\n\t\t\t// extra binding, NOT the underlying logger's child (which would freeze\n\t\t\t// to the current request).\n\t\t\tif (prop === 'child') {\n\t\t\t\treturn (obj: object) => createRequestScopedLogger([...bindings, obj]);\n\t\t\t}\n\t\t\t// Never look like a thenable, and don't answer symbol/inspection probes\n\t\t\t// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst value = (resolve() as unknown as Record<string, unknown>)[prop];\n\t\t\t// Functions are re-resolved at *call* time so detached references\n\t\t\t// (`const info = logger.info`) still target the current request's\n\t\t\t// logger. Non-function members (e.g. `level`) forward as their live\n\t\t\t// value on the current request's logger.\n\t\t\treturn typeof value === 'function'\n\t\t\t\t? (...args: unknown[]) => {\n\t\t\t\t\t\t// Re-resolve at call time so detached references target the\n\t\t\t\t\t\t// current request's logger, and invoke with that logger as\n\t\t\t\t\t\t// `this`: pino's log methods read internal state off the\n\t\t\t\t\t\t// receiver (`this[Symbol(pino.msgPrefix)]`), so calling them\n\t\t\t\t\t\t// unbound throws \"Cannot read properties of undefined\".\n\t\t\t\t\t\tconst resolved = resolve();\n\t\t\t\t\t\tconst fn = (resolved as unknown as Record<string, unknown>)[\n\t\t\t\t\t\t\tprop\n\t\t\t\t\t\t] as (...a: unknown[]) => unknown;\n\t\t\t\t\t\treturn fn.apply(resolved, args);\n\t\t\t\t\t}\n\t\t\t\t: value;\n\t\t},\n\t\t// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying\n\t\t// logger so feature-detection works.\n\t\thas(_target, prop) {\n\t\t\tif (prop === 'child') return true;\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') return false;\n\t\t\treturn prop in (resolve() as object);\n\t\t},\n\t});\n}\n\n/**\n * Stable, process-wide request-scoped logger proxy. Shared across requests on\n * purpose — it carries no request state itself, delegating to the current\n * `AsyncLocalStorage` store on each call.\n */\nconst requestScopedLogger = createRequestScopedLogger();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\t// Throw eagerly if there is no context, preserving the \"catch bugs early\"\n\t\t// contract for callers that read the logger at an unexpected time.\n\t\tresolveRequestLogger();\n\t\t// Return the shared proxy rather than the raw `store.logger`. A service\n\t\t// that captures this once still logs against the correct per-request\n\t\t// logger because the proxy re-resolves on every call.\n\t\treturn requestScopedLogger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAM,wBAAwB,IAAIA;;;;AAKlC,SAAS,uBAA+B;CACvC,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,MAAK,MACJ,OAAM,IAAI,MACT;AAIF,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;;AAqBD,SAAS,0BAA0BC,WAAqB,CAAE,GAAU;CAKnE,IAAIC;CACJ,IAAIC;CAEJ,MAAM,UAAU,MAAc;EAC7B,MAAM,OAAO,sBAAsB;AACnC,MAAI,SAAS,YAAY;AACxB,gBAAa;AACb,oBAAiB,SAAS,OACzB,CAAC,KAAK,QAAQ,IAAI,MAAM,IAAI,EAC5B,KACA;EACD;AACD,SAAO;CACP;AAED,QAAO,IAAI,MAAM,CAAE,GAAY;EAC9B,IAAI,SAAS,MAAM;AAIlB,OAAI,SAAS,QACZ,QAAO,CAACC,QAAgB,0BAA0B,CAAC,GAAG,UAAU,GAAI,EAAC;AAItE,OAAI,SAAS,iBAAiB,SAAS,SACtC;GAED,MAAM,QAAS,SAAS,CAAwC;AAKhE,iBAAc,UAAU,aACrB,CAAC,GAAG,SAAoB;IAMxB,MAAM,WAAW,SAAS;IAC1B,MAAM,KAAM,SACX;AAED,WAAO,GAAG,MAAM,UAAU,KAAK;GAC/B,IACA;EACH;EAGD,IAAI,SAAS,MAAM;AAClB,OAAI,SAAS,QAAS,QAAO;AAC7B,OAAI,SAAS,iBAAiB,SAAS,SAAU,QAAO;AACxD,UAAO,QAAS,SAAS;EACzB;CACD;AACD;;;;;;AAOD,MAAM,sBAAsB,2BAA2B;;;;;;AAOvD,MAAaC,iBAAiC;CAC7C,YAAY;AAGX,wBAAsB;AAItB,SAAO;CACP;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/{context-BojeLlxs.mjs → context-CH2c0ftq.mjs}

@@ -50,7 +50,11 @@ function createRequestScopedLogger(bindings = []) {
 			if (prop === "child") return (obj) => createRequestScopedLogger([...bindings, obj]);
 			if (prop === "then" || typeof prop === "symbol") return void 0;
 			const value = resolve()[prop];
-			return typeof value === "function" ? (...args) => resolve()[prop](...args) : value;
+			return typeof value === "function" ? (...args) => {
+				const resolved = resolve();
+				const fn = resolved[prop];
+				return fn.apply(resolved, args);
+			} : value;
 		},
 		has(_target, prop) {
 			if (prop === "child") return true;
@@ -138,4 +142,4 @@ function exitRequestContext() {
 
 //#endregion
 export { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-BojeLlxs.mjs.map
+//# sourceMappingURL=context-CH2c0ftq.mjs.map

package/dist/context-CH2c0ftq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-CH2c0ftq.mjs","names":["bindings: object[]","cachedBase: Logger | undefined","cachedResolved: Logger | undefined","obj: object","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * Resolve the logger for the current request, or throw if there is none.\n */\nfunction resolveRequestLogger(): Logger {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) {\n\t\tthrow new Error(\n\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t);\n\t}\n\treturn store.logger;\n}\n\n/**\n * Create a Logger that re-resolves its underlying logger on every call instead\n * of capturing it once.\n *\n * This is what makes it safe for a **singleton** service to grab the logger a\n * single time (e.g. during `register()`, which `ServiceDiscovery` only runs\n * once and then caches) and reuse that reference for every request: each log\n * call resolves the *current* request's logger from `AsyncLocalStorage`, so\n * requests no longer inherit the first request's logger (and its `requestId`,\n * user bindings, etc.).\n *\n * Implemented as a `Proxy` rather than a fixed list of methods so it forwards\n * the *entire* surface of whatever logger is supplied — including members\n * beyond the base `Logger` interface (e.g. a richer pino-backed logger's\n * `flush()` or `level`) and any methods added to `Logger` in the future.\n *\n * @param bindings - `child()` bindings applied, in order, on top of the\n *   resolved logger before each call.\n */\nfunction createRequestScopedLogger(bindings: object[] = []): Logger {\n\t// Memoise the resolved (optionally child) logger per underlying base logger\n\t// so we don't rebuild the child chain on every access within a request.\n\t// Recomputed whenever the current request's logger changes — there is no\n\t// await between the check and use, so this is safe under concurrency.\n\tlet cachedBase: Logger | undefined;\n\tlet cachedResolved: Logger | undefined;\n\n\tconst resolve = (): Logger => {\n\t\tconst base = resolveRequestLogger();\n\t\tif (base !== cachedBase) {\n\t\t\tcachedBase = base;\n\t\t\tcachedResolved = bindings.reduce<Logger>(\n\t\t\t\t(log, obj) => log.child(obj),\n\t\t\t\tbase,\n\t\t\t);\n\t\t}\n\t\treturn cachedResolved as Logger;\n\t};\n\n\treturn new Proxy({} as Logger, {\n\t\tget(_target, prop) {\n\t\t\t// `child()` must stay request-scoped: return a new proxy carrying the\n\t\t\t// extra binding, NOT the underlying logger's child (which would freeze\n\t\t\t// to the current request).\n\t\t\tif (prop === 'child') {\n\t\t\t\treturn (obj: object) => createRequestScopedLogger([...bindings, obj]);\n\t\t\t}\n\t\t\t// Never look like a thenable, and don't answer symbol/inspection probes\n\t\t\t// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst value = (resolve() as unknown as Record<string, unknown>)[prop];\n\t\t\t// Functions are re-resolved at *call* time so detached references\n\t\t\t// (`const info = logger.info`) still target the current request's\n\t\t\t// logger. Non-function members (e.g. `level`) forward as their live\n\t\t\t// value on the current request's logger.\n\t\t\treturn typeof value === 'function'\n\t\t\t\t? (...args: unknown[]) => {\n\t\t\t\t\t\t// Re-resolve at call time so detached references target the\n\t\t\t\t\t\t// current request's logger, and invoke with that logger as\n\t\t\t\t\t\t// `this`: pino's log methods read internal state off the\n\t\t\t\t\t\t// receiver (`this[Symbol(pino.msgPrefix)]`), so calling them\n\t\t\t\t\t\t// unbound throws \"Cannot read properties of undefined\".\n\t\t\t\t\t\tconst resolved = resolve();\n\t\t\t\t\t\tconst fn = (resolved as unknown as Record<string, unknown>)[\n\t\t\t\t\t\t\tprop\n\t\t\t\t\t\t] as (...a: unknown[]) => unknown;\n\t\t\t\t\t\treturn fn.apply(resolved, args);\n\t\t\t\t\t}\n\t\t\t\t: value;\n\t\t},\n\t\t// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying\n\t\t// logger so feature-detection works.\n\t\thas(_target, prop) {\n\t\t\tif (prop === 'child') return true;\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') return false;\n\t\t\treturn prop in (resolve() as object);\n\t\t},\n\t});\n}\n\n/**\n * Stable, process-wide request-scoped logger proxy. Shared across requests on\n * purpose — it carries no request state itself, delegating to the current\n * `AsyncLocalStorage` store on each call.\n */\nconst requestScopedLogger = createRequestScopedLogger();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\t// Throw eagerly if there is no context, preserving the \"catch bugs early\"\n\t\t// contract for callers that read the logger at an unexpected time.\n\t\tresolveRequestLogger();\n\t\t// Return the shared proxy rather than the raw `store.logger`. A service\n\t\t// that captures this once still logs against the correct per-request\n\t\t// logger because the proxy re-resolves on every call.\n\t\treturn requestScopedLogger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;AAmBA,MAAM,wBAAwB,IAAI;;;;AAKlC,SAAS,uBAA+B;CACvC,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,MAAK,MACJ,OAAM,IAAI,MACT;AAIF,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;;AAqBD,SAAS,0BAA0BA,WAAqB,CAAE,GAAU;CAKnE,IAAIC;CACJ,IAAIC;CAEJ,MAAM,UAAU,MAAc;EAC7B,MAAM,OAAO,sBAAsB;AACnC,MAAI,SAAS,YAAY;AACxB,gBAAa;AACb,oBAAiB,SAAS,OACzB,CAAC,KAAK,QAAQ,IAAI,MAAM,IAAI,EAC5B,KACA;EACD;AACD,SAAO;CACP;AAED,QAAO,IAAI,MAAM,CAAE,GAAY;EAC9B,IAAI,SAAS,MAAM;AAIlB,OAAI,SAAS,QACZ,QAAO,CAACC,QAAgB,0BAA0B,CAAC,GAAG,UAAU,GAAI,EAAC;AAItE,OAAI,SAAS,iBAAiB,SAAS,SACtC;GAED,MAAM,QAAS,SAAS,CAAwC;AAKhE,iBAAc,UAAU,aACrB,CAAC,GAAG,SAAoB;IAMxB,MAAM,WAAW,SAAS;IAC1B,MAAM,KAAM,SACX;AAED,WAAO,GAAG,MAAM,UAAU,KAAK;GAC/B,IACA;EACH;EAGD,IAAI,SAAS,MAAM;AAClB,OAAI,SAAS,QAAS,QAAO;AAC7B,OAAI,SAAS,iBAAiB,SAAS,SAAU,QAAO;AACxD,UAAO,QAAS,SAAS;EACzB;CACD;AACD;;;;;;AAOD,MAAM,sBAAsB,2BAA2B;;;;;;AAOvD,MAAaC,iBAAiC;CAC7C,YAAY;AAGX,wBAAsB;AAItB,SAAO;CACP;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/{context-D5pIUGkm.d.cts → context-CU-87vsM.d.mts}

@@ -1,4 +1,4 @@
-import { ServiceContext } from "./types-BY9yrY6Y.cjs";
+import { ServiceContext } from "./types-BoyOCa57.mjs";
 import { Logger } from "@geekmidas/logger";
 
 //#region src/context.d.ts
@@ -61,4 +61,4 @@ declare function exitRequestContext(): void;
 //# sourceMappingURL=context.d.ts.map
 //#endregion
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-D5pIUGkm.d.cts.map
+//# sourceMappingURL=context-CU-87vsM.d.mts.map

package/dist/{context-D5pIUGkm.d.cts.map → context-CU-87vsM.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"context-D5pIUGkm.d.cts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAiHA;AA0DgB,UA3KC,kBAAA,CA2KoB;EAAA,MAAA,EA1K5B,MA0K4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}
+{"version":3,"file":"context-CU-87vsM.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAyHA;AA0DgB,UAnLC,kBAAA,CAmLoB;EAAA,MAAA,EAlL5B,MAkL4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/{context-OmKid3Mr.d.mts → context-D2owD3ac.d.cts}

@@ -1,4 +1,4 @@
-import { ServiceContext } from "./types-B99KrvXR.mjs";
+import { ServiceContext } from "./types-Bgk-0NOO.cjs";
 import { Logger } from "@geekmidas/logger";
 
 //#region src/context.d.ts
@@ -61,4 +61,4 @@ declare function exitRequestContext(): void;
 //# sourceMappingURL=context.d.ts.map
 //#endregion
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-OmKid3Mr.d.mts.map
+//# sourceMappingURL=context-D2owD3ac.d.cts.map

package/dist/{context-OmKid3Mr.d.mts.map → context-D2owD3ac.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"context-OmKid3Mr.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAiHA;AA0DgB,UA3KC,kBAAA,CA2KoB;EAAA,MAAA,EA1K5B,MA0K4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}
+{"version":3,"file":"context-D2owD3ac.d.cts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAyHA;AA0DgB,UAnLC,kBAAA,CAmLoB;EAAA,MAAA,EAlL5B,MAkL4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/context.cjs

@@ -1,4 +1,4 @@
-const require_context = require('./context-CkCPt2Fe.cjs');
+const require_context = require('./context-1ROj3zvL.cjs');
 
 exports.enterRequestContext = require_context.enterRequestContext;
 exports.exitRequestContext = require_context.exitRequestContext;

package/dist/context.d.cts

@@ -1,3 +1,3 @@
-import "./types-BY9yrY6Y.cjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D5pIUGkm.cjs";
+import "./types-Bgk-0NOO.cjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D2owD3ac.cjs";
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/context.d.mts

@@ -1,3 +1,3 @@
-import "./types-B99KrvXR.mjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-OmKid3Mr.mjs";
+import "./types-BoyOCa57.mjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CU-87vsM.mjs";
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/context.mjs

@@ -1,3 +1,3 @@
-import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BojeLlxs.mjs";
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CH2c0ftq.mjs";
 
 export { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_context = require('./context-CkCPt2Fe.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-Cxus7ber.cjs');
+const require_context = require('./context-1ROj3zvL.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-BrCUabG_.cjs');
 
 exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;
 exports.enterRequestContext = require_context.enterRequestContext;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-BY9yrY6Y.cjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-DF4OKEZp.cjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D5pIUGkm.cjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-Bgk-0NOO.cjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D2owD3ac.cjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-BO8W-RY8.cjs";
 export { ExtractServiceNames, RequestContextData, Service, ServiceContext, ServiceDiscovery, ServiceRecord, ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-B99KrvXR.mjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CadEgTKz.mjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-OmKid3Mr.mjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-BoyOCa57.mjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CU-87vsM.mjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CRq_bGbi.mjs";
 export { ExtractServiceNames, RequestContextData, Service, ServiceContext, ServiceDiscovery, ServiceRecord, ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BojeLlxs.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-SujDuYHr.mjs";
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CH2c0ftq.mjs";
+import { ServiceDiscovery } from "./ServiceDiscovery-WHikQSQv.mjs";
 
 export { ServiceDiscovery, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/middy.cjs

@@ -0,0 +1,120 @@
+const require_context = require('./context-1ROj3zvL.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-BrCUabG_.cjs');
+
+//#region src/middy.ts
+function deriveRequestId(options, event, context) {
+	return options.getRequestId?.(event, context) ?? context.awsRequestId;
+}
+function buildLogger(baseLogger, options, requestId, event, context) {
+	return baseLogger.child({
+		requestId,
+		...options.bindings?.(event, context) ?? {}
+	});
+}
+/**
+* Middy middleware that establishes a request context for the handler so any
+* code it reaches — including `@geekmidas/services` service methods — can call
+* `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.
+*
+* Use this on standalone functions that need request-scoped logging. To also
+* resolve services, pair it with {@link addServices}, or use
+* {@link withServices} which bundles both.
+*
+* @example
+* ```ts
+* import middy from '@middy/core';
+* import { serviceContext } from '@geekmidas/services';
+* import { requestContext } from '@geekmidas/services/middy';
+*
+* export const handler = middy(async () => {
+*   serviceContext.getLogger().info('tick');
+* }).use(requestContext({ logger }));
+* ```
+*/
+function requestContext(options) {
+	const baseLogger = options.logger;
+	return {
+		before: (request) => {
+			const { event, context } = request;
+			const requestId = deriveRequestId(options, event, context);
+			const logger = buildLogger(baseLogger, options, requestId, event, context);
+			require_context.enterRequestContext({
+				logger,
+				requestId,
+				startTime: Date.now()
+			});
+		},
+		after: () => {
+			require_context.exitRequestContext();
+		},
+		onError: () => {
+			require_context.exitRequestContext();
+		}
+	};
+}
+function resolveDiscovery(options) {
+	return options.serviceDiscovery ?? require_ServiceDiscovery.ServiceDiscovery.getInstance(options.envParser);
+}
+/**
+* Middy middleware that resolves an array of {@link Service}s via
+* {@link ServiceDiscovery} and attaches the resolved record to `event.services`
+* (keyed by each service's `serviceName`), matching how the `Function`/`Cron`
+* constructs expose services on the event.
+*
+* This middleware only resolves services; it does **not** establish a request
+* context. If your services read `serviceContext` (e.g. `getLogger()`), pair it
+* with {@link requestContext}, or use {@link withServices} which bundles both.
+*
+* Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto
+* `event.services`.
+*
+* @example
+* ```ts
+* import middy from '@middy/core';
+* import { addServices, requestContext } from '@geekmidas/services/middy';
+*
+* export const handler = middy(async (event) => {
+*   await event.services.database.users.deletePast();
+*   event.services.cache.clear();
+* })
+*   .use(requestContext())
+*   .use(addServices([databaseService, cacheService], { envParser }));
+* ```
+*/
+function addServices(services, options) {
+	const discovery = resolveDiscovery(options);
+	return { before: async (request) => {
+		const resolved = await discovery.register(services);
+		const event = request.event;
+		event.services = {
+			...event.services ?? {},
+			...resolved
+		};
+	} };
+}
+/**
+* Batteries-included Middy setup for service-backed handlers: returns a pair of
+* middlewares — {@link requestContext} followed by {@link addServices} — so a
+* single `.use(withServices([...]))` gives the handler both a request context
+* and the resolved services on `event.services`.
+*
+* @example
+* ```ts
+* import middy from '@middy/core';
+* import { withServices } from '@geekmidas/services/middy';
+*
+* export const handler = middy(async (event) => {
+*   await event.services.database.users.deletePast();
+*   event.services.cache.clear();
+* }).use(withServices([databaseService, cacheService], { envParser }));
+* ```
+*/
+function withServices(services, options) {
+	return [requestContext(options), addServices(services, options)];
+}
+
+//#endregion
+exports.addServices = addServices;
+exports.requestContext = requestContext;
+exports.withServices = withServices;
+//# sourceMappingURL=middy.cjs.map

package/dist/middy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.cjs","names":["options: RequestContextOptions","event: unknown","context: Context","baseLogger: Logger","requestId: string","options: RequestContextOptions<TLogger>","options: ServiceResolverOptions","services: [...T]","options: ServiceMiddlewareOptions<TLogger>"],"sources":["../src/middy.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type { MiddlewareObj } from '@middy/core';\nimport type { Context } from 'aws-lambda';\nimport { enterRequestContext, exitRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Middy middleware helpers that bring `@geekmidas/services` request context and\n * service discovery to **standalone** Middy Lambda handlers — i.e. functions\n * that aren't built with the `@geekmidas/constructs` Function/Cron constructs\n * but still want `serviceContext.getLogger()` and resolved services.\n *\n * Why middleware (and not `runWithRequestContext`)? Middy runs `before → handler\n * → after` as sequential awaits in a single async context, so establishing the\n * context with `AsyncLocalStorage.enterWith` (via `enterRequestContext`) in a\n * `before` hook propagates to the handler. `after`/`onError` reset it.\n *\n * Teardown is best-effort: like `enterRequestContext`, the reset is observable\n * to code the handler reaches but not necessarily to the frame that invoked the\n * Middy handler. This is fine for Lambda, where each invocation runs in its own\n * fresh async context — `requestContext` always establishes a brand-new context\n * per invocation, so requests never inherit a previous invocation's logger.\n *\n * @module\n */\n\n/**\n * Options for {@link requestContext}. Generic over the logger type so a custom\n * logger that extends {@link Logger} is preserved rather than widened.\n */\nexport interface RequestContextOptions<TLogger extends Logger = Logger> {\n\t/**\n\t * Logger to derive the per-request child logger from. Required — the caller\n\t * decides which logger to use (there is no implicit default).\n\t */\n\tlogger: TLogger;\n\t/**\n\t * Derive the request id from the event/context.\n\t * Defaults to `context.awsRequestId` (always present in a Lambda invocation).\n\t */\n\tgetRequestId?: (event: unknown, context: Context) => string;\n\t/**\n\t * Extra bindings to attach to the per-request child logger.\n\t */\n\tbindings?: (event: unknown, context: Context) => Record<string, unknown>;\n}\n\n/**\n * Options for {@link addServices} — how services are resolved. No logger is\n * needed because resolving services doesn't establish a request context.\n */\nexport interface ServiceResolverOptions {\n\t/**\n\t * Environment parser used to build the {@link ServiceDiscovery}. Required —\n\t * the caller supplies the parser (there is no implicit `process.env` default).\n\t */\n\tenvParser: EnvironmentParser<{}>;\n\t/**\n\t * Explicit {@link ServiceDiscovery} to resolve services from. Takes\n\t * precedence over `envParser`.\n\t */\n\tserviceDiscovery?: ServiceDiscovery;\n}\n\n/**\n * Options for {@link withServices}: request context (logger) + service resolution.\n */\nexport type ServiceMiddlewareOptions<TLogger extends Logger = Logger> =\n\tRequestContextOptions<TLogger> & ServiceResolverOptions;\n\nfunction deriveRequestId(\n\toptions: RequestContextOptions,\n\tevent: unknown,\n\tcontext: Context,\n): string {\n\t// Lambda always populates context.awsRequestId; getRequestId can override it.\n\treturn options.getRequestId?.(event, context) ?? context.awsRequestId;\n}\n\nfunction buildLogger(\n\tbaseLogger: Logger,\n\toptions: RequestContextOptions,\n\trequestId: string,\n\tevent: unknown,\n\tcontext: Context,\n): Logger {\n\treturn baseLogger.child({\n\t\trequestId,\n\t\t...(options.bindings?.(event, context) ?? {}),\n\t});\n}\n\n/**\n * Middy middleware that establishes a request context for the handler so any\n * code it reaches — including `@geekmidas/services` service methods — can call\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * Use this on standalone functions that need request-scoped logging. To also\n * resolve services, pair it with {@link addServices}, or use\n * {@link withServices} which bundles both.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { serviceContext } from '@geekmidas/services';\n * import { requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async () => {\n *   serviceContext.getLogger().info('tick');\n * }).use(requestContext({ logger }));\n * ```\n */\nexport function requestContext<TLogger extends Logger = Logger>(\n\toptions: RequestContextOptions<TLogger>,\n): MiddlewareObj<unknown, unknown, Error, Context> {\n\tconst baseLogger = options.logger;\n\treturn {\n\t\tbefore: (request) => {\n\t\t\tconst { event, context } = request;\n\t\t\tconst requestId = deriveRequestId(options, event, context);\n\t\t\tconst logger = buildLogger(\n\t\t\t\tbaseLogger,\n\t\t\t\toptions,\n\t\t\t\trequestId,\n\t\t\t\tevent,\n\t\t\t\tcontext,\n\t\t\t);\n\t\t\tenterRequestContext({ logger, requestId, startTime: Date.now() });\n\t\t},\n\t\tafter: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t\tonError: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t};\n}\n\nfunction resolveDiscovery(options: ServiceResolverOptions): ServiceDiscovery {\n\treturn (\n\t\toptions.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser)\n\t);\n}\n\n/**\n * Event augmentation applied by {@link addServices} / {@link withServices}:\n * resolved services keyed by `serviceName`. Intersect it with your own event\n * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.\n */\nexport type EventServices<T extends Service[]> = {\n\tservices: ServiceRecord<T>;\n};\n\n/**\n * Middy middleware that resolves an array of {@link Service}s via\n * {@link ServiceDiscovery} and attaches the resolved record to `event.services`\n * (keyed by each service's `serviceName`), matching how the `Function`/`Cron`\n * constructs expose services on the event.\n *\n * This middleware only resolves services; it does **not** establish a request\n * context. If your services read `serviceContext` (e.g. `getLogger()`), pair it\n * with {@link requestContext}, or use {@link withServices} which bundles both.\n *\n * Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto\n * `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { addServices, requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * })\n *   .use(requestContext())\n *   .use(addServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function addServices<const T extends Service[]>(\n\tservices: [...T],\n\toptions: ServiceResolverOptions,\n): MiddlewareObj<EventServices<T>, unknown, Error, Context> {\n\tconst discovery = resolveDiscovery(options);\n\n\treturn {\n\t\tbefore: async (request) => {\n\t\t\tconst resolved = await discovery.register(services);\n\t\t\tconst event = request.event as { services?: Record<string, unknown> };\n\t\t\t// Merge so chained addServices(...) calls accumulate on event.services.\n\t\t\tevent.services = { ...(event.services ?? {}), ...resolved };\n\t\t},\n\t};\n}\n\n/**\n * Batteries-included Middy setup for service-backed handlers: returns a pair of\n * middlewares — {@link requestContext} followed by {@link addServices} — so a\n * single `.use(withServices([...]))` gives the handler both a request context\n * and the resolved services on `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { withServices } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * }).use(withServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function withServices<\n\tconst T extends Service[],\n\tTLogger extends Logger = Logger,\n>(\n\tservices: [...T],\n\toptions: ServiceMiddlewareOptions<TLogger>,\n): [\n\tMiddlewareObj<unknown, unknown, Error, Context>,\n\tMiddlewareObj<EventServices<T>, unknown, Error, Context>,\n] {\n\treturn [requestContext(options), addServices(services, options)];\n}\n"],"mappings":";;;;AAwEA,SAAS,gBACRA,SACAC,OACAC,SACS;AAET,QAAO,QAAQ,eAAe,OAAO,QAAQ,IAAI,QAAQ;AACzD;AAED,SAAS,YACRC,YACAH,SACAI,WACAH,OACAC,SACS;AACT,QAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,QAAQ,IAAI,CAAE;CAC5C,EAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,eACfG,SACkD;CAClD,MAAM,aAAa,QAAQ;AAC3B,QAAO;EACN,QAAQ,CAAC,YAAY;GACpB,MAAM,EAAE,OAAO,SAAS,GAAG;GAC3B,MAAM,YAAY,gBAAgB,SAAS,OAAO,QAAQ;GAC1D,MAAM,SAAS,YACd,YACA,SACA,WACA,OACA,QACA;AACD,uCAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,KAAK;GAAE,EAAC;EACjE;EACD,OAAO,MAAM;AACZ,uCAAoB;EACpB;EACD,SAAS,MAAM;AACd,uCAAoB;EACpB;CACD;AACD;AAED,SAAS,iBAAiBC,SAAmD;AAC5E,QACC,QAAQ,oBAAoB,0CAAiB,YAAY,QAAQ,UAAU;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCD,SAAgB,YACfC,UACAD,SAC2D;CAC3D,MAAM,YAAY,iBAAiB,QAAQ;AAE3C,QAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;EACnD,MAAM,QAAQ,QAAQ;AAEtB,QAAM,WAAW;GAAE,GAAI,MAAM,YAAY,CAAE;GAAG,GAAG;EAAU;CAC3D,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAgB,aAIfC,UACAC,SAIC;AACD,QAAO,CAAC,eAAe,QAAQ,EAAE,YAAY,UAAU,QAAQ,AAAC;AAChE"}