@geekmidas/services 10.0.0-alpha.15 → 10.0.0-alpha.150

package/dist/{ServiceDiscovery-I7GKGDgi.d.mts → ServiceDiscovery-D8OKCBzy.d.mts}

@@ -1,4 +1,4 @@
-import { t as Service } from "./types-DDxt5Kcu.mjs";
+import { n as Service } from "./types-BJldyZ-B.mjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 //#region src/ServiceDiscovery.d.ts
 /**
@@ -181,4 +181,4 @@ type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];
 type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]: K extends Service ? Awaited<ReturnType<K['register']>> : never; };
 //#endregion
 export { ServiceDiscovery as n, ServiceRecord as r, ExtractServiceNames as t };
-//# sourceMappingURL=ServiceDiscovery-I7GKGDgi.d.mts.map
+//# sourceMappingURL=ServiceDiscovery-D8OKCBzy.d.mts.map

package/dist/ServiceDiscovery-D8OKCBzy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceDiscovery-D8OKCBzy.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,iBAAiB,kBAAkB;WAkD1B,WAAW;;iBAhDjB;;UAEP;;UAEA;;;;;;;;;;;;;;SAeD,YAAY,UAAU,4BAC5B,WAAW,wBACT,iBAAiB;;;;;;;;;;;;;SAmBb;;;;;EAQP,YAAqB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1B,SAAS,UAAU,WAAW,UAAU,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;EAwCxE,IAAI,gBAAgB,oBAAoB,MAAM,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;EA6B9D,QAAQ,iBAAiB,uBAC9B,WAAW,KACT,WAAW,KAAK,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;EA6BzC,IAAI,kBAAkB;;;;;;;;;;;;;KAoBX,oBAAoB,UAAU,aAAa;;;;;;;;;;;;;;;;KAiB3C,cAAc,UAAU,gBAClC,KAAK,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/{ServiceDiscovery-YbZxbSHi.d.cts → ServiceDiscovery-zMTNKupf.d.cts}

@@ -1,4 +1,4 @@
-import { t as Service } from "./types-DDxt5Kcu.cjs";
+import { n as Service } from "./types-BJldyZ-B.cjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 //#region src/ServiceDiscovery.d.ts
 /**
@@ -181,4 +181,4 @@ type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];
 type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]: K extends Service ? Awaited<ReturnType<K['register']>> : never; };
 //#endregion
 export { ServiceDiscovery as n, ServiceRecord as r, ExtractServiceNames as t };
-//# sourceMappingURL=ServiceDiscovery-YbZxbSHi.d.cts.map
+//# sourceMappingURL=ServiceDiscovery-zMTNKupf.d.cts.map

package/dist/ServiceDiscovery-zMTNKupf.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceDiscovery-zMTNKupf.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,iBAAiB,kBAAkB;WAkD1B,WAAW;;iBAhDjB;;UAEP;;UAEA;;;;;;;;;;;;;;SAeD,YAAY,UAAU,4BAC5B,WAAW,wBACT,iBAAiB;;;;;;;;;;;;;SAmBb;;;;;EAQP,YAAqB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1B,SAAS,UAAU,WAAW,UAAU,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;EAwCxE,IAAI,gBAAgB,oBAAoB,MAAM,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;EA6B9D,QAAQ,iBAAiB,uBAC9B,WAAW,KACT,WAAW,KAAK,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;EA6BzC,IAAI,kBAAkB;;;;;;;;;;;;;KAoBX,oBAAoB,UAAU,aAAa;;;;;;;;;;;;;;;;KAiB3C,cAAc,UAAU,gBAClC,KAAK,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/context.cjs

@@ -89,9 +89,58 @@ const serviceContext = {
 	},
 	hasContext() {
 		return requestContextStorage.getStore() !== void 0;
+	},
+	getUser() {
+		return requestContextStorage.getStore()?.user;
 	}
 };
 /**
+* Say who the current request is for, once its session was verified.
+*
+* Kept on the request's own context, so everything that runs for it from
+* here on — the handler, every service, a query, an event it publishes, work
+* it awaits after any number of hops — reads the same user, and no other
+* request ever does. Its logger is rebound with `userId` (and
+* `sessionId`): every line logged for the request after this, through the
+* logger a handler is handed or one a service captured, says whose it was.
+*
+* Identifying again with another user replaces the first — the bindings are
+* applied to the request's logger as it was before any identification, so a
+* line never carries two users.
+*
+* Outside a request there is nothing to identify, and it does nothing: a
+* session verified from a script is still verified.
+*
+* @returns whether there was a request to identify
+*/
+function identifyRequest(user) {
+	const store = requestContextStorage.getStore();
+	if (!store) return false;
+	const anonymous = anonymousLoggers.get(store) ?? store.logger;
+	anonymousLoggers.set(store, anonymous);
+	store.user = user;
+	store.logger = anonymous.child({
+		userId: user.id,
+		...user.sessionId ? { sessionId: user.sessionId } : {}
+	});
+	return true;
+}
+/**
+* Each request's logger as it was before {@link identifyRequest} rebound it,
+* so identifying again binds to that rather than stacking a second user.
+*/
+const anonymousLoggers = /* @__PURE__ */ new WeakMap();
+/**
+* The current request's context, or undefined outside one.
+*
+* For code that annotates work when there is a request and carries on when
+* there is not — tagging a query, say — where {@link serviceContext}'s
+* accessors would throw.
+*/
+function currentRequestContext() {
+	return requestContextStorage.getStore();
+}
+/**
 * Run a function with request context.
 * Used by endpoint/function/subscriber adaptors.
 *
@@ -138,8 +187,10 @@ function exitRequestContext() {
 	requestContextStorage.enterWith(void 0);
 }
 //#endregion
+exports.currentRequestContext = currentRequestContext;
 exports.enterRequestContext = enterRequestContext;
 exports.exitRequestContext = exitRequestContext;
+exports.identifyRequest = identifyRequest;
 exports.runWithRequestContext = runWithRequestContext;
 exports.serviceContext = serviceContext;
 

package/dist/context.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"context.cjs","names":["AsyncLocalStorage"],"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,+BAAIA,EAAAA,CAAAA,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"}
+{"version":3,"file":"context.cjs","names":["AsyncLocalStorage"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { RequestUser, 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\t/**\n\t * What is running: `POST /orders`, `queue Emails`, `cron rate(1 day)`.\n\t * Carried so that work done on the request's behalf — a database query —\n\t * can say what it was done for.\n\t */\n\toperation?: string;\n\t/**\n\t * Who the request is for, once its session was verified. Set by\n\t * {@link identifyRequest}, which also rebinds {@link logger} with it.\n\t */\n\tuser?: RequestUser;\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\tgetUser() {\n\t\treturn requestContextStorage.getStore()?.user;\n\t},\n};\n\n/**\n * Say who the current request is for, once its session was verified.\n *\n * Kept on the request's own context, so everything that runs for it from\n * here on — the handler, every service, a query, an event it publishes, work\n * it awaits after any number of hops — reads the same user, and no other\n * request ever does. Its logger is rebound with `userId` (and\n * `sessionId`): every line logged for the request after this, through the\n * logger a handler is handed or one a service captured, says whose it was.\n *\n * Identifying again with another user replaces the first — the bindings are\n * applied to the request's logger as it was before any identification, so a\n * line never carries two users.\n *\n * Outside a request there is nothing to identify, and it does nothing: a\n * session verified from a script is still verified.\n *\n * @returns whether there was a request to identify\n */\nexport function identifyRequest(user: RequestUser): boolean {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) return false;\n\n\tconst anonymous = anonymousLoggers.get(store) ?? store.logger;\n\tanonymousLoggers.set(store, anonymous);\n\n\tstore.user = user;\n\tstore.logger = anonymous.child({\n\t\tuserId: user.id,\n\t\t...(user.sessionId ? { sessionId: user.sessionId } : {}),\n\t});\n\treturn true;\n}\n\n/**\n * Each request's logger as it was before {@link identifyRequest} rebound it,\n * so identifying again binds to that rather than stacking a second user.\n */\nconst anonymousLoggers = new WeakMap<RequestContextData, Logger>();\n\n/**\n * The current request's context, or undefined outside one.\n *\n * For code that annotates work when there is a request and carries on when\n * there is not — tagging a query, say — where {@link serviceContext}'s\n * accessors would throw.\n */\nexport function currentRequestContext():\n\t| Readonly<RequestContextData>\n\t| undefined {\n\treturn requestContextStorage.getStore();\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":";;;;;;;AA8BA,MAAM,wBAAwB,+BAAIA,EAAAA,CAAAA,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;CAEA,UAAU;EACT,OAAO,sBAAsB,SAAS,CAAC,EAAE;CAC1C;AACD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,gBAAgB,MAA4B;CAC3D,MAAM,QAAQ,sBAAsB,SAAS;CAC7C,IAAI,CAAC,OAAO,OAAO;CAEnB,MAAM,YAAY,iBAAiB,IAAI,KAAK,KAAK,MAAM;CACvD,iBAAiB,IAAI,OAAO,SAAS;CAErC,MAAM,OAAO;CACb,MAAM,SAAS,UAAU,MAAM;EAC9B,QAAQ,KAAK;EACb,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACvD,CAAC;CACD,OAAO;AACR;;;;;AAMA,MAAM,mCAAmB,IAAI,QAAoC;;;;;;;;AASjE,SAAgB,wBAEH;CACZ,OAAO,sBAAsB,SAAS;AACvC;;;;;;;;;;;;;;;;;;;;;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/context.d.cts

@@ -1,4 +1,4 @@
-import { n as ServiceContext } from "./types-DDxt5Kcu.cjs";
+import { r as ServiceContext, t as RequestUser } from "./types-BJldyZ-B.cjs";
 import { Logger } from "@geekmidas/logger";
 //#region src/context.d.ts
 /**
@@ -9,6 +9,17 @@ export interface RequestContextData {
   logger: Logger;
   requestId: string;
   startTime: number;
+  /**
+   * What is running: `POST /orders`, `queue Emails`, `cron rate(1 day)`.
+   * Carried so that work done on the request's behalf — a database query —
+   * can say what it was done for.
+   */
+  operation?: string;
+  /**
+   * Who the request is for, once its session was verified. Set by
+   * {@link identifyRequest}, which also rebinds {@link logger} with it.
+   */
+  user?: RequestUser;
 }
 /**
  * ServiceContext implementation.
@@ -16,6 +27,34 @@ export interface RequestContextData {
  * Methods throw if called outside a request context (catches bugs early).
  */
 export declare const serviceContext: ServiceContext;
+/**
+ * Say who the current request is for, once its session was verified.
+ *
+ * Kept on the request's own context, so everything that runs for it from
+ * here on — the handler, every service, a query, an event it publishes, work
+ * it awaits after any number of hops — reads the same user, and no other
+ * request ever does. Its logger is rebound with `userId` (and
+ * `sessionId`): every line logged for the request after this, through the
+ * logger a handler is handed or one a service captured, says whose it was.
+ *
+ * Identifying again with another user replaces the first — the bindings are
+ * applied to the request's logger as it was before any identification, so a
+ * line never carries two users.
+ *
+ * Outside a request there is nothing to identify, and it does nothing: a
+ * session verified from a script is still verified.
+ *
+ * @returns whether there was a request to identify
+ */
+export declare function identifyRequest(user: RequestUser): boolean;
+/**
+ * The current request's context, or undefined outside one.
+ *
+ * For code that annotates work when there is a request and carries on when
+ * there is not — tagging a query, say — where {@link serviceContext}'s
+ * accessors would throw.
+ */
+export declare function currentRequestContext(): Readonly<RequestContextData> | undefined;
 /**
  * Run a function with request context.
  * Used by endpoint/function/subscriber adaptors.

package/dist/context.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;iBAQiB;EAChB,QAAQ;EACR;EACA;;;;;;;qBAsHY,gBAAgB;;;;;;;;;;;;;;;;;;;;;wBA0Db,sBAAsB,GACrC,MAAM,oBACN,UAAU,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;wBAgBC,oBAAoB,MAAM;;;;;;wBAS1B"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;iBAQiB;EAChB,QAAQ;EACR;EACA;;;;;;EAMA;;;;;EAKA,OAAO;;;;;;;qBAsHK,gBAAgB;;;;;;;;;;;;;;;;;;;;wBA6Db,gBAAgB,MAAM;;;;;;;;wBA4BtB,yBACb,SAAS;;;;;;;;;;;;;;;;;;;;;wBAyBI,sBAAsB,GACrC,MAAM,oBACN,UAAU,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;wBAgBC,oBAAoB,MAAM;;;;;;wBAS1B"}

package/dist/context.d.mts

@@ -1,4 +1,4 @@
-import { n as ServiceContext } from "./types-DDxt5Kcu.mjs";
+import { r as ServiceContext, t as RequestUser } from "./types-BJldyZ-B.mjs";
 import { Logger } from "@geekmidas/logger";
 //#region src/context.d.ts
 /**
@@ -9,6 +9,17 @@ export interface RequestContextData {
   logger: Logger;
   requestId: string;
   startTime: number;
+  /**
+   * What is running: `POST /orders`, `queue Emails`, `cron rate(1 day)`.
+   * Carried so that work done on the request's behalf — a database query —
+   * can say what it was done for.
+   */
+  operation?: string;
+  /**
+   * Who the request is for, once its session was verified. Set by
+   * {@link identifyRequest}, which also rebinds {@link logger} with it.
+   */
+  user?: RequestUser;
 }
 /**
  * ServiceContext implementation.
@@ -16,6 +27,34 @@ export interface RequestContextData {
  * Methods throw if called outside a request context (catches bugs early).
  */
 export declare const serviceContext: ServiceContext;
+/**
+ * Say who the current request is for, once its session was verified.
+ *
+ * Kept on the request's own context, so everything that runs for it from
+ * here on — the handler, every service, a query, an event it publishes, work
+ * it awaits after any number of hops — reads the same user, and no other
+ * request ever does. Its logger is rebound with `userId` (and
+ * `sessionId`): every line logged for the request after this, through the
+ * logger a handler is handed or one a service captured, says whose it was.
+ *
+ * Identifying again with another user replaces the first — the bindings are
+ * applied to the request's logger as it was before any identification, so a
+ * line never carries two users.
+ *
+ * Outside a request there is nothing to identify, and it does nothing: a
+ * session verified from a script is still verified.
+ *
+ * @returns whether there was a request to identify
+ */
+export declare function identifyRequest(user: RequestUser): boolean;
+/**
+ * The current request's context, or undefined outside one.
+ *
+ * For code that annotates work when there is a request and carries on when
+ * there is not — tagging a query, say — where {@link serviceContext}'s
+ * accessors would throw.
+ */
+export declare function currentRequestContext(): Readonly<RequestContextData> | undefined;
 /**
  * Run a function with request context.
  * Used by endpoint/function/subscriber adaptors.

package/dist/context.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.mts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;iBAQiB;EAChB,QAAQ;EACR;EACA;;;;;;;qBAsHY,gBAAgB;;;;;;;;;;;;;;;;;;;;;wBA0Db,sBAAsB,GACrC,MAAM,oBACN,UAAU,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;wBAgBC,oBAAoB,MAAM;;;;;;wBAS1B"}
+{"version":3,"file":"context.d.mts","names":[],"sources":["../src/context.ts"],"mappings":";;;;;;;iBAQiB;EAChB,QAAQ;EACR;EACA;;;;;;EAMA;;;;;EAKA,OAAO;;;;;;;qBAsHK,gBAAgB;;;;;;;;;;;;;;;;;;;;wBA6Db,gBAAgB,MAAM;;;;;;;;wBA4BtB,yBACb,SAAS;;;;;;;;;;;;;;;;;;;;;wBAyBI,sBAAsB,GACrC,MAAM,oBACN,UAAU,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;wBAgBC,oBAAoB,MAAM;;;;;;wBAS1B"}

package/dist/context.mjs

@@ -89,9 +89,58 @@ const serviceContext = {
 	},
 	hasContext() {
 		return requestContextStorage.getStore() !== void 0;
+	},
+	getUser() {
+		return requestContextStorage.getStore()?.user;
 	}
 };
 /**
+* Say who the current request is for, once its session was verified.
+*
+* Kept on the request's own context, so everything that runs for it from
+* here on — the handler, every service, a query, an event it publishes, work
+* it awaits after any number of hops — reads the same user, and no other
+* request ever does. Its logger is rebound with `userId` (and
+* `sessionId`): every line logged for the request after this, through the
+* logger a handler is handed or one a service captured, says whose it was.
+*
+* Identifying again with another user replaces the first — the bindings are
+* applied to the request's logger as it was before any identification, so a
+* line never carries two users.
+*
+* Outside a request there is nothing to identify, and it does nothing: a
+* session verified from a script is still verified.
+*
+* @returns whether there was a request to identify
+*/
+function identifyRequest(user) {
+	const store = requestContextStorage.getStore();
+	if (!store) return false;
+	const anonymous = anonymousLoggers.get(store) ?? store.logger;
+	anonymousLoggers.set(store, anonymous);
+	store.user = user;
+	store.logger = anonymous.child({
+		userId: user.id,
+		...user.sessionId ? { sessionId: user.sessionId } : {}
+	});
+	return true;
+}
+/**
+* Each request's logger as it was before {@link identifyRequest} rebound it,
+* so identifying again binds to that rather than stacking a second user.
+*/
+const anonymousLoggers = /* @__PURE__ */ new WeakMap();
+/**
+* The current request's context, or undefined outside one.
+*
+* For code that annotates work when there is a request and carries on when
+* there is not — tagging a query, say — where {@link serviceContext}'s
+* accessors would throw.
+*/
+function currentRequestContext() {
+	return requestContextStorage.getStore();
+}
+/**
 * Run a function with request context.
 * Used by endpoint/function/subscriber adaptors.
 *
@@ -138,6 +187,6 @@ function exitRequestContext() {
 	requestContextStorage.enterWith(void 0);
 }
 //#endregion
-export { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
+export { currentRequestContext, enterRequestContext, exitRequestContext, identifyRequest, runWithRequestContext, serviceContext };
 
 //# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -1 +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"}
+{"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 { RequestUser, 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\t/**\n\t * What is running: `POST /orders`, `queue Emails`, `cron rate(1 day)`.\n\t * Carried so that work done on the request's behalf — a database query —\n\t * can say what it was done for.\n\t */\n\toperation?: string;\n\t/**\n\t * Who the request is for, once its session was verified. Set by\n\t * {@link identifyRequest}, which also rebinds {@link logger} with it.\n\t */\n\tuser?: RequestUser;\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\tgetUser() {\n\t\treturn requestContextStorage.getStore()?.user;\n\t},\n};\n\n/**\n * Say who the current request is for, once its session was verified.\n *\n * Kept on the request's own context, so everything that runs for it from\n * here on — the handler, every service, a query, an event it publishes, work\n * it awaits after any number of hops — reads the same user, and no other\n * request ever does. Its logger is rebound with `userId` (and\n * `sessionId`): every line logged for the request after this, through the\n * logger a handler is handed or one a service captured, says whose it was.\n *\n * Identifying again with another user replaces the first — the bindings are\n * applied to the request's logger as it was before any identification, so a\n * line never carries two users.\n *\n * Outside a request there is nothing to identify, and it does nothing: a\n * session verified from a script is still verified.\n *\n * @returns whether there was a request to identify\n */\nexport function identifyRequest(user: RequestUser): boolean {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) return false;\n\n\tconst anonymous = anonymousLoggers.get(store) ?? store.logger;\n\tanonymousLoggers.set(store, anonymous);\n\n\tstore.user = user;\n\tstore.logger = anonymous.child({\n\t\tuserId: user.id,\n\t\t...(user.sessionId ? { sessionId: user.sessionId } : {}),\n\t});\n\treturn true;\n}\n\n/**\n * Each request's logger as it was before {@link identifyRequest} rebound it,\n * so identifying again binds to that rather than stacking a second user.\n */\nconst anonymousLoggers = new WeakMap<RequestContextData, Logger>();\n\n/**\n * The current request's context, or undefined outside one.\n *\n * For code that annotates work when there is a request and carries on when\n * there is not — tagging a query, say — where {@link serviceContext}'s\n * accessors would throw.\n */\nexport function currentRequestContext():\n\t| Readonly<RequestContextData>\n\t| undefined {\n\treturn requestContextStorage.getStore();\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":";;;;;;;AA8BA,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;CAEA,UAAU;EACT,OAAO,sBAAsB,SAAS,CAAC,EAAE;CAC1C;AACD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,gBAAgB,MAA4B;CAC3D,MAAM,QAAQ,sBAAsB,SAAS;CAC7C,IAAI,CAAC,OAAO,OAAO;CAEnB,MAAM,YAAY,iBAAiB,IAAI,KAAK,KAAK,MAAM;CACvD,iBAAiB,IAAI,OAAO,SAAS;CAErC,MAAM,OAAO;CACb,MAAM,SAAS,UAAU,MAAM;EAC9B,QAAQ,KAAK;EACb,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;CACvD,CAAC;CACD,OAAO;AACR;;;;;AAMA,MAAM,mCAAmB,IAAI,QAAoC;;;;;;;;AASjE,SAAgB,wBAEH;CACZ,OAAO,sBAAsB,SAAS;AACvC;;;;;;;;;;;;;;;;;;;;;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

@@ -2,7 +2,9 @@ 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.currentRequestContext = require_context.currentRequestContext;
 exports.enterRequestContext = require_context.enterRequestContext;
 exports.exitRequestContext = require_context.exitRequestContext;
+exports.identifyRequest = require_context.identifyRequest;
 exports.runWithRequestContext = require_context.runWithRequestContext;
 exports.serviceContext = require_context.serviceContext;

package/dist/index.d.cts

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

package/dist/index.d.mts

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

package/dist/index.mjs

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

package/dist/middy.d.cts

@@ -1,5 +1,5 @@
-import { t as Service } from "./types-DDxt5Kcu.cjs";
-import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-YbZxbSHi.cjs";
+import { n as Service } from "./types-BJldyZ-B.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-zMTNKupf.cjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { MiddlewareObj } from "@middy/core";

package/dist/middy.d.mts

@@ -1,5 +1,5 @@
-import { t as Service } from "./types-DDxt5Kcu.mjs";
-import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-I7GKGDgi.mjs";
+import { n as Service } from "./types-BJldyZ-B.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-D8OKCBzy.mjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { MiddlewareObj } from "@middy/core";

package/dist/trpc.d.cts

@@ -1,5 +1,5 @@
-import { t as Service } from "./types-DDxt5Kcu.cjs";
-import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-YbZxbSHi.cjs";
+import { n as Service } from "./types-BJldyZ-B.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-zMTNKupf.cjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";

package/dist/trpc.d.mts

@@ -1,5 +1,5 @@
-import { t as Service } from "./types-DDxt5Kcu.mjs";
-import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-I7GKGDgi.mjs";
+import { n as Service } from "./types-BJldyZ-B.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-D8OKCBzy.mjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";

package/dist/{types-DDxt5Kcu.d.cts → types-BJldyZ-B.d.cts}

@@ -35,6 +35,24 @@ interface ServiceContext {
    * Use this to guard calls if you need to handle both cases.
    */
   hasContext(): boolean;
+  /**
+   * Who the current request is for, once its session was verified
+   * (`identifyRequest`), or `undefined` — before then, for a request with no
+   * session, and outside a request.
+   */
+  getUser(): RequestUser | undefined;
+}
+/**
+ * Who a request is for: the identity its session was verified as.
+ *
+ * An id, never an address: it rides on every log line and span of the
+ * request, and both leave the process for wherever telemetry is kept.
+ */
+interface RequestUser {
+  /** The user's id at the identity provider — Better Auth's `user.id`. */
+  id: string;
+  /** The session the request was made with. */
+  sessionId?: string;
 }
 /**
  * Options passed to service register method.
@@ -86,5 +104,5 @@ interface Service<TName extends string = string, TInstance = unknown> {
   register(options: ServiceRegisterOptions): TInstance | Promise<TInstance>;
 }
 //#endregion
-export { ServiceContext as n, ServiceRegisterOptions as r, Service as t };
-//# sourceMappingURL=types-DDxt5Kcu.d.cts.map
+export { ServiceRegisterOptions as i, Service as n, ServiceContext as r, RequestUser as t };
+//# sourceMappingURL=types-BJldyZ-B.d.cts.map

package/dist/types-BJldyZ-B.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BJldyZ-B.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;;EAOA,WAAW;;;;;;;;UASK;;EAEhB;;EAEA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}

package/dist/{types-DDxt5Kcu.d.mts → types-BJldyZ-B.d.mts}

@@ -35,6 +35,24 @@ interface ServiceContext {
    * Use this to guard calls if you need to handle both cases.
    */
   hasContext(): boolean;
+  /**
+   * Who the current request is for, once its session was verified
+   * (`identifyRequest`), or `undefined` — before then, for a request with no
+   * session, and outside a request.
+   */
+  getUser(): RequestUser | undefined;
+}
+/**
+ * Who a request is for: the identity its session was verified as.
+ *
+ * An id, never an address: it rides on every log line and span of the
+ * request, and both leave the process for wherever telemetry is kept.
+ */
+interface RequestUser {
+  /** The user's id at the identity provider — Better Auth's `user.id`. */
+  id: string;
+  /** The session the request was made with. */
+  sessionId?: string;
 }
 /**
  * Options passed to service register method.
@@ -86,5 +104,5 @@ interface Service<TName extends string = string, TInstance = unknown> {
   register(options: ServiceRegisterOptions): TInstance | Promise<TInstance>;
 }
 //#endregion
-export { ServiceContext as n, ServiceRegisterOptions as r, Service as t };
-//# sourceMappingURL=types-DDxt5Kcu.d.mts.map
+export { ServiceRegisterOptions as i, Service as n, ServiceContext as r, RequestUser as t };
+//# sourceMappingURL=types-BJldyZ-B.d.mts.map

package/dist/types-BJldyZ-B.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BJldyZ-B.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;;EAOA,WAAW;;;;;;;;UASK;;EAEhB;;EAEA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/services",
-  "version": "10.0.0-alpha.15",
+  "version": "10.0.0-alpha.150",
   "private": false,
   "type": "module",
   "exports": {
@@ -61,8 +61,8 @@
     "@middy/core": ">=7.9.2",
     "@trpc/server": ">=11.19.0",
     "@types/aws-lambda": ">=8.10.163",
-    "@geekmidas/envkit": "^10.0.0-alpha.15",
-    "@geekmidas/logger": "^10.0.0-alpha.15"
+    "@geekmidas/envkit": "^10.0.0-alpha.150",
+    "@geekmidas/logger": "^10.0.0-alpha.150"
   },
   "peerDependenciesMeta": {
     "@geekmidas/envkit": {
@@ -86,10 +86,11 @@
     "@trpc/server": "~11.19.0",
     "@types/aws-lambda": "~8.10.163",
     "@types/node": "~24.9.1",
-    "@geekmidas/envkit": "^10.0.0-alpha.15",
-    "@geekmidas/logger": "^10.0.0-alpha.15"
+    "@geekmidas/envkit": "^10.0.0-alpha.150",
+    "@geekmidas/logger": "^10.0.0-alpha.150"
   },
   "scripts": {
-    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"
+    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts",
+    "build": "tsdown --config ../../tsdown.config.ts --filter ."
   }
 }

package/dist/ServiceDiscovery-I7GKGDgi.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-I7GKGDgi.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,iBAAiB,kBAAkB;WAkD1B,WAAW;;iBAhDjB;;UAEP;;UAEA;;;;;;;;;;;;;;SAeD,YAAY,UAAU,4BAC5B,WAAW,wBACT,iBAAiB;;;;;;;;;;;;;SAmBb;;;;;EAQc,YAAA,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1B,SAAS,UAAU,WAAW,UAAU,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;EAwCxE,IAAI,gBAAgB,oBAAoB,MAAM,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;EA6B9D,QAAQ,iBAAiB,uBAC9B,WAAW,KACT,WAAW,KAAK,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;EA6BzC,IAAI,kBAAkB;;;;;;;;;;;;;KAoBX,oBAAoB,UAAU,aAAa;;;;;;;;;;;;;;;;KAiB3C,cAAc,UAAU,gBAClC,KAAK,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/ServiceDiscovery-YbZxbSHi.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-YbZxbSHi.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,iBAAiB,kBAAkB;WAkD1B,WAAW;;iBAhDjB;;UAEP;;UAEA;;;;;;;;;;;;;;SAeD,YAAY,UAAU,4BAC5B,WAAW,wBACT,iBAAiB;;;;;;;;;;;;;SAmBb;;;;;EAQc,YAAA,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1B,SAAS,UAAU,WAAW,UAAU,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;EAwCxE,IAAI,gBAAgB,oBAAoB,MAAM,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;EA6B9D,QAAQ,iBAAiB,uBAC9B,WAAW,KACT,WAAW,KAAK,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;EA6BzC,IAAI,kBAAkB;;;;;;;;;;;;;KAoBX,oBAAoB,UAAU,aAAa;;;;;;;;;;;;;;;;KAiB3C,cAAc,UAAU,gBAClC,KAAK,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/types-DDxt5Kcu.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DDxt5Kcu.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}

package/dist/types-DDxt5Kcu.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DDxt5Kcu.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}