@geekmidas/services 10.0.0-alpha.4 → 10.0.0-alpha.40

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"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,kBAAsC;;;;AAKxE,SAAS,uBAA+B;CACvC,MAAM,QAAQ,sBAAsB,SAAS;CAC7C,IAAI,CAAC,OACJ,MAAM,IAAI,MACT,6GAED;CAED,OAAO,MAAM;AACd;;;;;;;;;;;;;;;;;;;;AAqBA,SAAS,0BAA0B,WAAqB,CAAC,GAAW;CAKnE,IAAI;CACJ,IAAI;CAEJ,MAAM,gBAAwB;EAC7B,MAAM,OAAO,qBAAqB;EAClC,IAAI,SAAS,YAAY;GACxB,aAAa;GACb,iBAAiB,SAAS,QACxB,KAAK,QAAQ,IAAI,MAAM,GAAG,GAC3B,IACD;EACD;EACA,OAAO;CACR;CAEA,OAAO,IAAI,MAAM,CAAC,GAAa;EAC9B,IAAI,SAAS,MAAM;GAIlB,IAAI,SAAS,SACZ,QAAQ,QAAgB,0BAA0B,CAAC,GAAG,UAAU,GAAG,CAAC;GAIrE,IAAI,SAAS,UAAU,OAAO,SAAS,UACtC;GAED,MAAM,QAAS,QAAQ,CAAC,CAAwC;GAKhE,OAAO,OAAO,UAAU,cACpB,GAAG,SAAoB;IAMxB,MAAM,WAAW,QAAQ;IAIzB,OAHY,SACX,KAEQ,CAAC,MAAM,UAAU,IAAI;GAC/B,IACC;EACJ;EAGA,IAAI,SAAS,MAAM;GAClB,IAAI,SAAS,SAAS,OAAO;GAC7B,IAAI,SAAS,UAAU,OAAO,SAAS,UAAU,OAAO;GACxD,OAAO,QAAS,QAAQ;EACzB;CACD,CAAC;AACF;;;;;;AAOA,MAAM,sBAAsB,0BAA0B;;;;;;AAOtD,MAAa,iBAAiC;CAC7C,YAAY;EAGX,qBAAqB;EAIrB,OAAO;CACR;CAEA,eAAe;EACd,MAAM,QAAQ,sBAAsB,SAAS;EAC7C,IAAI,CAAC,OACJ,MAAM,IAAI,MACT,gHAED;EAED,OAAO,MAAM;CACd;CAEA,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,SAAS;EAC7C,IAAI,CAAC,OACJ,MAAM,IAAI,MACT,uHAED;EAED,OAAO,MAAM;CACd;CAEA,aAAa;EACZ,OAAO,sBAAsB,SAAS,MAAM,KAAA;CAC7C;AACD;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,sBACf,MACA,IACiB;CACjB,OAAO,sBAAsB,IAAI,MAAM,EAAE;AAC1C;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,MAAgC;CACnE,sBAAsB,UAAU,IAAI;AACrC;;;;;;AAOA,SAAgB,qBAA2B;CAG1C,sBAAiE,UAChE,KAAA,CACD;AACD"}

package/dist/index.cjs

@@ -1,8 +1,8 @@
-const require_context = require('./context-1ROj3zvL.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-BrCUabG_.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_context = require("./context.cjs");
+const require_ServiceDiscovery = require("./ServiceDiscovery-C1bAv6vY.cjs");
 exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;
 exports.enterRequestContext = require_context.enterRequestContext;
 exports.exitRequestContext = require_context.exitRequestContext;
 exports.runWithRequestContext = require_context.runWithRequestContext;
-exports.serviceContext = require_context.serviceContext;
+exports.serviceContext = require_context.serviceContext;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-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 };
+import { n as ServiceContext, r as ServiceRegisterOptions, t as Service } from "./types-DDxt5Kcu.cjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord, t as ExtractServiceNames } from "./ServiceDiscovery-YbZxbSHi.cjs";
+export { type ExtractServiceNames, type RequestContextData, type Service, type ServiceContext, ServiceDiscovery, type ServiceRecord, type ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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 };
+import { n as ServiceContext, r as ServiceRegisterOptions, t as Service } from "./types-DDxt5Kcu.mjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord, t as ExtractServiceNames } from "./ServiceDiscovery-I7GKGDgi.mjs";
+export { type ExtractServiceNames, type RequestContextData, type Service, type ServiceContext, ServiceDiscovery, type ServiceRecord, type ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CH2c0ftq.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-WHikQSQv.mjs";
-
-export { ServiceDiscovery, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context.mjs";
+import { t as ServiceDiscovery } from "./ServiceDiscovery-5LlW7BgD.mjs";
+export { ServiceDiscovery, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/middy.cjs

@@ -1,6 +1,6 @@
-const require_context = require('./context-1ROj3zvL.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-BrCUabG_.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_context = require("./context.cjs");
+const require_ServiceDiscovery = require("./ServiceDiscovery-C1bAv6vY.cjs");
 //#region src/middy.ts
 function deriveRequestId(options, event, context) {
 	return options.getRequestId?.(event, context) ?? context.awsRequestId;
@@ -112,9 +112,9 @@ function addServices(services, options) {
 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

@@ -1 +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"}
+{"version":3,"file":"middy.cjs","names":["ServiceDiscovery"],"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,gBACR,SACA,OACA,SACS;CAET,OAAO,QAAQ,eAAe,OAAO,OAAO,KAAK,QAAQ;AAC1D;AAEA,SAAS,YACR,YACA,SACA,WACA,OACA,SACS;CACT,OAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,OAAO,KAAK,CAAC;CAC5C,CAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,eACf,SACkD;CAClD,MAAM,aAAa,QAAQ;CAC3B,OAAO;EACN,SAAS,YAAY;GACpB,MAAM,EAAE,OAAO,YAAY;GAC3B,MAAM,YAAY,gBAAgB,SAAS,OAAO,OAAO;GACzD,MAAM,SAAS,YACd,YACA,SACA,WACA,OACA,OACD;GACA,gBAAA,oBAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,IAAI;GAAE,CAAC;EACjE;EACA,aAAa;GACZ,gBAAA,mBAAmB;EACpB;EACA,eAAe;GACd,gBAAA,mBAAmB;EACpB;CACD;AACD;AAEA,SAAS,iBAAiB,SAAmD;CAC5E,OACC,QAAQ,oBAAoBA,yBAAAA,iBAAiB,YAAY,QAAQ,SAAS;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,YACf,UACA,SAC2D;CAC3D,MAAM,YAAY,iBAAiB,OAAO;CAE1C,OAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,QAAQ;EAClD,MAAM,QAAQ,QAAQ;EAEtB,MAAM,WAAW;GAAE,GAAI,MAAM,YAAY,CAAC;GAAI,GAAG;EAAS;CAC3D,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aAIf,UACA,SAIC;CACD,OAAO,CAAC,eAAe,OAAO,GAAG,YAAY,UAAU,OAAO,CAAC;AAChE"}

package/dist/middy.d.cts

@@ -1,12 +1,10 @@
-import { Service } from "./types-Bgk-0NOO.cjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-BO8W-RY8.cjs";
+import { t as Service } from "./types-DDxt5Kcu.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-YbZxbSHi.cjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { MiddlewareObj } from "@middy/core";
 import { Context } from "aws-lambda";
-
 //#region src/middy.d.ts
-
 /**
  * Middy middleware helpers that bring `@geekmidas/services` request context and
  * service discovery to **standalone** Middy Lambda handlers — i.e. functions
@@ -30,7 +28,7 @@ import { Context } from "aws-lambda";
  * Options for {@link requestContext}. Generic over the logger type so a custom
  * logger that extends {@link Logger} is preserved rather than widened.
  */
-interface RequestContextOptions<TLogger extends Logger = Logger> {
+export interface RequestContextOptions<TLogger extends Logger = Logger> {
   /**
    * Logger to derive the per-request child logger from. Required — the caller
    * decides which logger to use (there is no implicit default).
@@ -50,7 +48,7 @@ interface RequestContextOptions<TLogger extends Logger = Logger> {
  * Options for {@link addServices} — how services are resolved. No logger is
  * needed because resolving services doesn't establish a request context.
  */
-interface ServiceResolverOptions {
+export interface ServiceResolverOptions {
   /**
    * Environment parser used to build the {@link ServiceDiscovery}. Required —
    * the caller supplies the parser (there is no implicit `process.env` default).
@@ -65,7 +63,7 @@ interface ServiceResolverOptions {
 /**
  * Options for {@link withServices}: request context (logger) + service resolution.
  */
-type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
+export type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
 /**
  * Middy middleware that establishes a request context for the handler so any
  * code it reaches — including `@geekmidas/services` service methods — can call
@@ -86,13 +84,13 @@ type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextO
  * }).use(requestContext({ logger }));
  * ```
  */
-declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
+export declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
 /**
  * Event augmentation applied by {@link addServices} / {@link withServices}:
  * resolved services keyed by `serviceName`. Intersect it with your own event
  * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.
  */
-type EventServices<T extends Service[]> = {
+export type EventServices<T extends Service[]> = {
   services: ServiceRecord<T>;
 };
 /**
@@ -121,7 +119,7 @@ type EventServices<T extends Service[]> = {
  *   .use(addServices([databaseService, cacheService], { envParser }));
  * ```
  */
-declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
+export declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
 /**
  * Batteries-included Middy setup for service-backed handlers: returns a pair of
  * middlewares — {@link requestContext} followed by {@link addServices} — so a
@@ -139,8 +137,6 @@ declare function addServices<const T extends Service[]>(services: [...T], option
  * }).use(withServices([databaseService, cacheService], { envParser }));
  * ```
  */
-declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
-//# sourceMappingURL=middy.d.ts.map
+export declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
 //#endregion
-export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, ServiceResolverOptions, addServices, requestContext, withServices };
 //# sourceMappingURL=middy.d.cts.map

package/dist/middy.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"middy.d.cts","names":[],"sources":["../src/middy.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAgCA;;;;;;;;AAcwD;AAOxD;;;;AAUoC;AAMpC;;;;;;;AACwD,UAtCvC,qBAsCuC,CAAA,gBAtCD,MAsCC,GAtCQ,MAsCR,CAAA,CAAA;EA4CxC;;;;EAA8C,MAC9B,EA9EvB,OA8EuB;EAAO;;;;EACvB,YAAA,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA1E0B,OA0E1B,EAAA,GAAA,MAAA;EAmCJ;;;EAA+B,QAClB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA1Ga,OA0Gb,EAAA,GA1GyB,MA0GzB,CAAA,MAAA,EAAA,OAAA,CAAA;;AAAD;AA6BxB;;;AACe,UAjIE,sBAAA,CAiIF;EAAC;;;;EAEiC,SAAE,EA9HvC,iBA8HuC,CAAA,CAAA,CAAA,CAAA;EAAO;AAA1C;AA8BhB;;EAA4B,gBACX,CAAA,EAxJG,gBAwJH;;;;;AAIP,KAtJE,wBAsJF,CAAA,gBAtJ2C,MAsJ3C,GAtJoD,MAsJpD,CAAA,GArJT,qBAqJS,CArJa,OAqJb,CAAA,GArJwB,sBAqJxB;;;;;;;;;AAGI;;;;;;;;;;;;iBA5GE,+BAA+B,SAAS,iBAC9C,sBAAsB,WAC7B,gCAAgC,OAAO;;;;;;KAmC9B,wBAAwB;YACzB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BT,4BAA4B,yBAC7B,aACL,yBACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;iBA8BnC,6BACC,2BACA,SAAS,sBAEX,aACL,yBAAyB,YAElC,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}
+{"version":3,"file":"middy.d.cts","names":[],"sources":["../src/middy.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCiB,sBAAsB,gBAAgB,SAAS;;;;;EAK/D,QAAQ;;;;;EAKR,gBAAgB,gBAAgB,SAAS;;;;EAIzC,YAAY,gBAAgB,SAAS,YAAY;;;;;;iBAOjC;;;;;EAKhB,WAAW;;;;;EAKX,mBAAmB;;;;;YAMR,yBAAyB,gBAAgB,SAAS,UAC7D,sBAAsB,WAAW;;;;;;;;;;;;;;;;;;;;;wBA4ClB,eAAe,gBAAgB,SAAS,QACvD,SAAS,sBAAsB,WAC7B,gCAAgC,OAAO;;;;;;YAmC9B,cAAc,UAAU;EACnC,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BT,kBAAkB,UAAU,WAC3C,cAAc,IACd,SAAS,yBACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;wBA8BnC,mBACT,UAAU,WAChB,gBAAgB,SAAS,QAEzB,cAAc,IACd,SAAS,yBAAyB,YAElC,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}

package/dist/middy.d.mts

@@ -1,12 +1,10 @@
-import { Service } from "./types-BoyOCa57.mjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CRq_bGbi.mjs";
+import { t as Service } from "./types-DDxt5Kcu.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-I7GKGDgi.mjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { MiddlewareObj } from "@middy/core";
 import { Context } from "aws-lambda";
-
 //#region src/middy.d.ts
-
 /**
  * Middy middleware helpers that bring `@geekmidas/services` request context and
  * service discovery to **standalone** Middy Lambda handlers — i.e. functions
@@ -30,7 +28,7 @@ import { Context } from "aws-lambda";
  * Options for {@link requestContext}. Generic over the logger type so a custom
  * logger that extends {@link Logger} is preserved rather than widened.
  */
-interface RequestContextOptions<TLogger extends Logger = Logger> {
+export interface RequestContextOptions<TLogger extends Logger = Logger> {
   /**
    * Logger to derive the per-request child logger from. Required — the caller
    * decides which logger to use (there is no implicit default).
@@ -50,7 +48,7 @@ interface RequestContextOptions<TLogger extends Logger = Logger> {
  * Options for {@link addServices} — how services are resolved. No logger is
  * needed because resolving services doesn't establish a request context.
  */
-interface ServiceResolverOptions {
+export interface ServiceResolverOptions {
   /**
    * Environment parser used to build the {@link ServiceDiscovery}. Required —
    * the caller supplies the parser (there is no implicit `process.env` default).
@@ -65,7 +63,7 @@ interface ServiceResolverOptions {
 /**
  * Options for {@link withServices}: request context (logger) + service resolution.
  */
-type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
+export type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
 /**
  * Middy middleware that establishes a request context for the handler so any
  * code it reaches — including `@geekmidas/services` service methods — can call
@@ -86,13 +84,13 @@ type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextO
  * }).use(requestContext({ logger }));
  * ```
  */
-declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
+export declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
 /**
  * Event augmentation applied by {@link addServices} / {@link withServices}:
  * resolved services keyed by `serviceName`. Intersect it with your own event
  * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.
  */
-type EventServices<T extends Service[]> = {
+export type EventServices<T extends Service[]> = {
   services: ServiceRecord<T>;
 };
 /**
@@ -121,7 +119,7 @@ type EventServices<T extends Service[]> = {
  *   .use(addServices([databaseService, cacheService], { envParser }));
  * ```
  */
-declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
+export declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
 /**
  * Batteries-included Middy setup for service-backed handlers: returns a pair of
  * middlewares — {@link requestContext} followed by {@link addServices} — so a
@@ -139,8 +137,6 @@ declare function addServices<const T extends Service[]>(services: [...T], option
  * }).use(withServices([databaseService, cacheService], { envParser }));
  * ```
  */
-declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
-//# sourceMappingURL=middy.d.ts.map
+export declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
 //#endregion
-export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, ServiceResolverOptions, addServices, requestContext, withServices };
 //# sourceMappingURL=middy.d.mts.map

package/dist/middy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middy.d.mts","names":[],"sources":["../src/middy.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAgCA;;;;;;;;AAcwD;AAOxD;;;;AAUoC;AAMpC;;;;;;;AACwD,UAtCvC,qBAsCuC,CAAA,gBAtCD,MAsCC,GAtCQ,MAsCR,CAAA,CAAA;EA4CxC;;;;EAA8C,MAC9B,EA9EvB,OA8EuB;EAAO;;;;EACvB,YAAA,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA1E0B,OA0E1B,EAAA,GAAA,MAAA;EAmCJ;;;EAA+B,QAClB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA1Ga,OA0Gb,EAAA,GA1GyB,MA0GzB,CAAA,MAAA,EAAA,OAAA,CAAA;;AAAD;AA6BxB;;;AACe,UAjIE,sBAAA,CAiIF;EAAC;;;;EAEiC,SAAE,EA9HvC,iBA8HuC,CAAA,CAAA,CAAA,CAAA;EAAO;AAA1C;AA8BhB;;EAA4B,gBACX,CAAA,EAxJG,gBAwJH;;;;;AAIP,KAtJE,wBAsJF,CAAA,gBAtJ2C,MAsJ3C,GAtJoD,MAsJpD,CAAA,GArJT,qBAqJS,CArJa,OAqJb,CAAA,GArJwB,sBAqJxB;;;;;;;;;AAGI;;;;;;;;;;;;iBA5GE,+BAA+B,SAAS,iBAC9C,sBAAsB,WAC7B,gCAAgC,OAAO;;;;;;KAmC9B,wBAAwB;YACzB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BT,4BAA4B,yBAC7B,aACL,yBACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;iBA8BnC,6BACC,2BACA,SAAS,sBAEX,aACL,yBAAyB,YAElC,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}
+{"version":3,"file":"middy.d.mts","names":[],"sources":["../src/middy.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCiB,sBAAsB,gBAAgB,SAAS;;;;;EAK/D,QAAQ;;;;;EAKR,gBAAgB,gBAAgB,SAAS;;;;EAIzC,YAAY,gBAAgB,SAAS,YAAY;;;;;;iBAOjC;;;;;EAKhB,WAAW;;;;;EAKX,mBAAmB;;;;;YAMR,yBAAyB,gBAAgB,SAAS,UAC7D,sBAAsB,WAAW;;;;;;;;;;;;;;;;;;;;;wBA4ClB,eAAe,gBAAgB,SAAS,QACvD,SAAS,sBAAsB,WAC7B,gCAAgC,OAAO;;;;;;YAmC9B,cAAc,UAAU;EACnC,UAAU,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6BT,kBAAkB,UAAU,WAC3C,cAAc,IACd,SAAS,yBACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;wBA8BnC,mBACT,UAAU,WAChB,gBAAgB,SAAS,QAEzB,cAAc,IACd,SAAS,yBAAyB,YAElC,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}

package/dist/middy.mjs

@@ -1,6 +1,5 @@
-import { enterRequestContext, exitRequestContext } from "./context-CH2c0ftq.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-WHikQSQv.mjs";
-
+import { enterRequestContext, exitRequestContext } from "./context.mjs";
+import { t as ServiceDiscovery } from "./ServiceDiscovery-5LlW7BgD.mjs";
 //#region src/middy.ts
 function deriveRequestId(options, event, context) {
 	return options.getRequestId?.(event, context) ?? context.awsRequestId;
@@ -112,7 +111,7 @@ function addServices(services, options) {
 function withServices(services, options) {
 	return [requestContext(options), addServices(services, options)];
 }
-
 //#endregion
 export { addServices, requestContext, withServices };
+
 //# sourceMappingURL=middy.mjs.map

package/dist/middy.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"middy.mjs","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,uBAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,KAAK;GAAE,EAAC;EACjE;EACD,OAAO,MAAM;AACZ,uBAAoB;EACpB;EACD,SAAS,MAAM;AACd,uBAAoB;EACpB;CACD;AACD;AAED,SAAS,iBAAiBC,SAAmD;AAC5E,QACC,QAAQ,oBAAoB,iBAAiB,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"}
+{"version":3,"file":"middy.mjs","names":[],"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,gBACR,SACA,OACA,SACS;CAET,OAAO,QAAQ,eAAe,OAAO,OAAO,KAAK,QAAQ;AAC1D;AAEA,SAAS,YACR,YACA,SACA,WACA,OACA,SACS;CACT,OAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,OAAO,KAAK,CAAC;CAC5C,CAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,eACf,SACkD;CAClD,MAAM,aAAa,QAAQ;CAC3B,OAAO;EACN,SAAS,YAAY;GACpB,MAAM,EAAE,OAAO,YAAY;GAC3B,MAAM,YAAY,gBAAgB,SAAS,OAAO,OAAO;GACzD,MAAM,SAAS,YACd,YACA,SACA,WACA,OACA,OACD;GACA,oBAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,IAAI;GAAE,CAAC;EACjE;EACA,aAAa;GACZ,mBAAmB;EACpB;EACA,eAAe;GACd,mBAAmB;EACpB;CACD;AACD;AAEA,SAAS,iBAAiB,SAAmD;CAC5E,OACC,QAAQ,oBAAoB,iBAAiB,YAAY,QAAQ,SAAS;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,YACf,UACA,SAC2D;CAC3D,MAAM,YAAY,iBAAiB,OAAO;CAE1C,OAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,QAAQ;EAClD,MAAM,QAAQ,QAAQ;EAEtB,MAAM,WAAW;GAAE,GAAI,MAAM,YAAY,CAAC;GAAI,GAAG;EAAS;CAC3D,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aAIf,UACA,SAIC;CACD,OAAO,CAAC,eAAe,OAAO,GAAG,YAAY,UAAU,OAAO,CAAC;AAChE"}

package/dist/trpc.cjs

@@ -1,10 +1,10 @@
-const require_context = require('./context-1ROj3zvL.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-BrCUabG_.cjs');
-const node_crypto = require_context.__toESM(require("node:crypto"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_context = require("./context.cjs");
+const require_ServiceDiscovery = require("./ServiceDiscovery-C1bAv6vY.cjs");
+let node_crypto = require("node:crypto");
 //#region src/trpc.ts
 function createServicesMiddleware(mw, envParser) {
-	return (services) => {
+	return ((services) => {
 		const builder = mw(async (opts) => {
 			const ctx = opts.ctx;
 			const discovery = ctx.serviceDiscovery ?? require_ServiceDiscovery.ServiceDiscovery.getInstance(envParser ?? (() => {
@@ -30,7 +30,7 @@ function createServicesMiddleware(mw, envParser) {
 			if (last) last._services = services;
 		}
 		return builder;
-	};
+	});
 }
 /**
 * Create a tRPC middleware that establishes a request context for downstream
@@ -59,8 +59,8 @@ function createRequestContextMiddleware(mw) {
 		}, () => opts.next());
 	});
 }
-
 //#endregion
 exports.createRequestContextMiddleware = createRequestContextMiddleware;
 exports.createServicesMiddleware = createServicesMiddleware;
+
 //# sourceMappingURL=trpc.cjs.map

package/dist/trpc.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.cjs","names":["mw: CreateMiddleware<TContext, TMeta>","envParser?: EnvironmentParser<{}>","services: [...T]"],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;;AAgGA,SAAgB,yBAIfA,IACAC,WACsC;AACtC,QAAQ,CAA4BC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJ,0CAAiB,YAChB,aACC,CAAC,MAAM;AAIN,UAAM,IAAI,MACT;GAKD,IAAG,CACL;GAEF,MAAM,YAAY,IAAI,aAAa,6BAAY;GAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAE7C,UAAO,sCACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAW,GAC5C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;AACnD,WAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAU,EAEjC,EAAC;GACF,EACD;EACD,EAAC;EAKF,MAAM,cACL,QACC;AACF,MAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;AAC9C,OAAI,KAAM,MAAK,YAAY;EAC3B;AAED,SAAO;CAMP;AACD;;;;;;;;;;;;;;;;AAiBD,SAAgB,+BAIfF,IAC0D;AAC1D,QAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,aAAa,6BAAY;EAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAC7C,SAAO,sCACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAW,GAC5C,MAAM,KAAK,MAAM,CACjB;CACD,EAAC;AACF"}
+{"version":3,"file":"trpc.cjs","names":["ServiceDiscovery","randomUUID","runWithRequestContext"],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;;AAgGA,SAAgB,yBAIf,IACA,WACsC;CACtC,SAAoC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJA,yBAAAA,iBAAiB,YAChB,oBACQ;IAIN,MAAM,IAAI,MACT,8MAID;GACD,EAAA,CAAG,CACL;GAED,MAAM,YAAY,IAAI,cAAA,GAAaC,YAAAA,WAAAA,CAAW;GAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;GAE5C,OAAOC,gBAAAA,sBACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAU,GAC3C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,QAAQ;IAClD,OAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAS,EAEjC,CAAC;GACF,CACD;EACD,CAAC;EAKD,MAAM,cACL,QACC;EACF,IAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;GAC9C,IAAI,MAAM,KAAK,YAAY;EAC5B;EAEA,OAAO;CAMR;AACD;;;;;;;;;;;;;;;;AAiBA,SAAgB,+BAIf,IAC0D;CAC1D,OAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,cAAA,GAAaD,YAAAA,WAAAA,CAAW;EAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;EAC5C,OAAOC,gBAAAA,sBACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAU,SACrC,KAAK,KAAK,CACjB;CACD,CAAC;AACF"}

package/dist/trpc.d.cts

@@ -1,11 +1,9 @@
-import { Service } from "./types-Bgk-0NOO.cjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-BO8W-RY8.cjs";
+import { t as Service } from "./types-DDxt5Kcu.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-YbZxbSHi.cjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
-
 //#region src/trpc.d.ts
-
 /**
  * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
  * initialized `t` object so callers retain ownership of their tRPC instance
@@ -17,13 +15,13 @@ type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(fn: TRPCMiddlewareF
  * tuple and returns a tRPC middleware that merges resolved services onto the
  * context.
  */
-type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+export type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
 /**
  * Context shape required by `createServicesMiddleware` overload 2.
  * Procedures that pull services via context-stored discovery must expose it
  * under `serviceDiscovery`.
  */
-interface ContextWithServiceDiscovery {
+export interface ContextWithServiceDiscovery {
   serviceDiscovery: ServiceDiscovery;
 }
 /**
@@ -31,7 +29,7 @@ interface ContextWithServiceDiscovery {
  * present so services can call `serviceContext.getLogger()`. `requestId` and
  * `startTime` are auto-generated if missing.
  */
-interface ContextWithLogger {
+export interface ContextWithLogger {
   logger: Logger;
   requestId?: string;
   startTime?: number;
@@ -63,8 +61,8 @@ interface ContextWithLogger {
  * );
  * ```
  */
-declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
-declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
 /**
  * Create a tRPC middleware that establishes a request context for downstream
  * code without resolving any services. Useful when services aren't needed on
@@ -80,7 +78,6 @@ declare function createServicesMiddleware<TContext extends ContextWithLogger & C
  * export const baseProcedure = t.procedure.use(withRequestContext);
  * ```
  */
-declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+export declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
 //#endregion
-export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
 //# sourceMappingURL=trpc.d.cts.map

package/dist/trpc.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.cts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}
+{"version":3,"file":"trpc.d.cts","names":[],"sources":["../src/trpc.ts"],"mappings":";;;;;;;;;;;KAgBK,iBAAiB,UAAU,UAAU,mBACzC,IAAI,uBACH,UACA,eAEA,gCAGG,sBAAsB,UAAU,OAAO;;;;;;YAOhC,mBACX,yBACA,+BACU,UAAU,WACpB,cAAc,OACV,sBAAsB,UAAU,OAAO,cAAc;;;;;;iBAOzC;EAChB,kBAAkB;;;;;;;iBAQF;EAChB,QAAQ;EACR;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Be,yBACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,QAC/B,WAAW,wBACT,mBAAmB,UAAU;wBAChB,yBACf,iBAAiB,oBAAoB,sCACrC,sBACC,IAAI,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;wBA+EvD,+BACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}

package/dist/trpc.d.mts

@@ -1,11 +1,9 @@
-import { Service } from "./types-BoyOCa57.mjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CRq_bGbi.mjs";
+import { t as Service } from "./types-DDxt5Kcu.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-I7GKGDgi.mjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
-
 //#region src/trpc.d.ts
-
 /**
  * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
  * initialized `t` object so callers retain ownership of their tRPC instance
@@ -17,13 +15,13 @@ type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(fn: TRPCMiddlewareF
  * tuple and returns a tRPC middleware that merges resolved services onto the
  * context.
  */
-type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+export type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
 /**
  * Context shape required by `createServicesMiddleware` overload 2.
  * Procedures that pull services via context-stored discovery must expose it
  * under `serviceDiscovery`.
  */
-interface ContextWithServiceDiscovery {
+export interface ContextWithServiceDiscovery {
   serviceDiscovery: ServiceDiscovery;
 }
 /**
@@ -31,7 +29,7 @@ interface ContextWithServiceDiscovery {
  * present so services can call `serviceContext.getLogger()`. `requestId` and
  * `startTime` are auto-generated if missing.
  */
-interface ContextWithLogger {
+export interface ContextWithLogger {
   logger: Logger;
   requestId?: string;
   startTime?: number;
@@ -63,8 +61,8 @@ interface ContextWithLogger {
  * );
  * ```
  */
-declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
-declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
 /**
  * Create a tRPC middleware that establishes a request context for downstream
  * code without resolving any services. Useful when services aren't needed on
@@ -80,7 +78,6 @@ declare function createServicesMiddleware<TContext extends ContextWithLogger & C
  * export const baseProcedure = t.procedure.use(withRequestContext);
  * ```
  */
-declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+export declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
 //#endregion
-export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
 //# sourceMappingURL=trpc.d.mts.map

package/dist/trpc.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}
+{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/trpc.ts"],"mappings":";;;;;;;;;;;KAgBK,iBAAiB,UAAU,UAAU,mBACzC,IAAI,uBACH,UACA,eAEA,gCAGG,sBAAsB,UAAU,OAAO;;;;;;YAOhC,mBACX,yBACA,+BACU,UAAU,WACpB,cAAc,OACV,sBAAsB,UAAU,OAAO,cAAc;;;;;;iBAOzC;EAChB,kBAAkB;;;;;;;iBAQF;EAChB,QAAQ;EACR;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Be,yBACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,QAC/B,WAAW,wBACT,mBAAmB,UAAU;wBAChB,yBACf,iBAAiB,oBAAoB,sCACrC,sBACC,IAAI,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;wBA+EvD,+BACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}