@geekmidas/services 1.0.3 → 1.1.0

package/src/context.ts

@@ -19,6 +19,103 @@ export interface RequestContextData {
  */
 const requestContextStorage = new AsyncLocalStorage<RequestContextData>();
 
+/**
+ * Resolve the logger for the current request, or throw if there is none.
+ */
+function resolveRequestLogger(): Logger {
+	const store = requestContextStorage.getStore();
+	if (!store) {
+		throw new Error(
+			'ServiceContext.getLogger() called outside request context. ' +
+				'Ensure code runs within runWithRequestContext().',
+		);
+	}
+	return store.logger;
+}
+
+/**
+ * Create a Logger that re-resolves its underlying logger on every call instead
+ * of capturing it once.
+ *
+ * This is what makes it safe for a **singleton** service to grab the logger a
+ * single time (e.g. during `register()`, which `ServiceDiscovery` only runs
+ * once and then caches) and reuse that reference for every request: each log
+ * call resolves the *current* request's logger from `AsyncLocalStorage`, so
+ * requests no longer inherit the first request's logger (and its `requestId`,
+ * user bindings, etc.).
+ *
+ * Implemented as a `Proxy` rather than a fixed list of methods so it forwards
+ * the *entire* surface of whatever logger is supplied — including members
+ * beyond the base `Logger` interface (e.g. a richer pino-backed logger's
+ * `flush()` or `level`) and any methods added to `Logger` in the future.
+ *
+ * @param bindings - `child()` bindings applied, in order, on top of the
+ *   resolved logger before each call.
+ */
+function createRequestScopedLogger(bindings: object[] = []): Logger {
+	// Memoise the resolved (optionally child) logger per underlying base logger
+	// so we don't rebuild the child chain on every access within a request.
+	// Recomputed whenever the current request's logger changes — there is no
+	// await between the check and use, so this is safe under concurrency.
+	let cachedBase: Logger | undefined;
+	let cachedResolved: Logger | undefined;
+
+	const resolve = (): Logger => {
+		const base = resolveRequestLogger();
+		if (base !== cachedBase) {
+			cachedBase = base;
+			cachedResolved = bindings.reduce<Logger>(
+				(log, obj) => log.child(obj),
+				base,
+			);
+		}
+		return cachedResolved as Logger;
+	};
+
+	return new Proxy({} as Logger, {
+		get(_target, prop) {
+			// `child()` must stay request-scoped: return a new proxy carrying the
+			// extra binding, NOT the underlying logger's child (which would freeze
+			// to the current request).
+			if (prop === 'child') {
+				return (obj: object) => createRequestScopedLogger([...bindings, obj]);
+			}
+			// Never look like a thenable, and don't answer symbol/inspection probes
+			// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.
+			if (prop === 'then' || typeof prop === 'symbol') {
+				return undefined;
+			}
+			const value = (resolve() as unknown as Record<string, unknown>)[prop];
+			// Functions are re-resolved at *call* time so detached references
+			// (`const info = logger.info`) still target the current request's
+			// logger. Non-function members (e.g. `level`) forward as their live
+			// value on the current request's logger.
+			return typeof value === 'function'
+				? (...args: unknown[]) => {
+						const fn = (resolve() as unknown as Record<string, unknown>)[
+							prop
+						] as (...a: unknown[]) => unknown;
+						return fn(...args);
+					}
+				: value;
+		},
+		// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying
+		// logger so feature-detection works.
+		has(_target, prop) {
+			if (prop === 'child') return true;
+			if (prop === 'then' || typeof prop === 'symbol') return false;
+			return prop in (resolve() as object);
+		},
+	});
+}
+
+/**
+ * Stable, process-wide request-scoped logger proxy. Shared across requests on
+ * purpose — it carries no request state itself, delegating to the current
+ * `AsyncLocalStorage` store on each call.
+ */
+const requestScopedLogger = createRequestScopedLogger();
+
 /**
  * ServiceContext implementation.
  * Singleton that reads from AsyncLocalStorage.
@@ -26,14 +123,13 @@ const requestContextStorage = new AsyncLocalStorage<RequestContextData>();
  */
 export const serviceContext: ServiceContext = {
 	getLogger() {
-		const store = requestContextStorage.getStore();
-		if (!store) {
-			throw new Error(
-				'ServiceContext.getLogger() called outside request context. ' +
-					'Ensure code runs within runWithRequestContext().',
-			);
-		}
-		return store.logger;
+		// Throw eagerly if there is no context, preserving the "catch bugs early"
+		// contract for callers that read the logger at an unexpected time.
+		resolveRequestLogger();
+		// Return the shared proxy rather than the raw `store.logger`. A service
+		// that captures this once still logs against the correct per-request
+		// logger because the proxy re-resolves on every call.
+		return requestScopedLogger;
 	},
 
 	getRequestId() {

package/src/middy.ts

@@ -0,0 +1,226 @@
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import type { MiddlewareObj } from '@middy/core';
+import type { Context } from 'aws-lambda';
+import { enterRequestContext, exitRequestContext } from './context';
+import { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';
+import type { Service } from './types';
+
+/**
+ * Middy middleware helpers that bring `@geekmidas/services` request context and
+ * service discovery to **standalone** Middy Lambda handlers — i.e. functions
+ * that aren't built with the `@geekmidas/constructs` Function/Cron constructs
+ * but still want `serviceContext.getLogger()` and resolved services.
+ *
+ * Why middleware (and not `runWithRequestContext`)? Middy runs `before → handler
+ * → after` as sequential awaits in a single async context, so establishing the
+ * context with `AsyncLocalStorage.enterWith` (via `enterRequestContext`) in a
+ * `before` hook propagates to the handler. `after`/`onError` reset it.
+ *
+ * Teardown is best-effort: like `enterRequestContext`, the reset is observable
+ * to code the handler reaches but not necessarily to the frame that invoked the
+ * Middy handler. This is fine for Lambda, where each invocation runs in its own
+ * fresh async context — `requestContext` always establishes a brand-new context
+ * per invocation, so requests never inherit a previous invocation's logger.
+ *
+ * @module
+ */
+
+/**
+ * Options for {@link requestContext}. Generic over the logger type so a custom
+ * logger that extends {@link Logger} is preserved rather than widened.
+ */
+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).
+	 */
+	logger: TLogger;
+	/**
+	 * Derive the request id from the event/context.
+	 * Defaults to `context.awsRequestId` (always present in a Lambda invocation).
+	 */
+	getRequestId?: (event: unknown, context: Context) => string;
+	/**
+	 * Extra bindings to attach to the per-request child logger.
+	 */
+	bindings?: (event: unknown, context: Context) => Record<string, unknown>;
+}
+
+/**
+ * Options for {@link addServices} — how services are resolved. No logger is
+ * needed because resolving services doesn't establish a request context.
+ */
+export interface ServiceResolverOptions {
+	/**
+	 * Environment parser used to build the {@link ServiceDiscovery}. Required —
+	 * the caller supplies the parser (there is no implicit `process.env` default).
+	 */
+	envParser: EnvironmentParser<{}>;
+	/**
+	 * Explicit {@link ServiceDiscovery} to resolve services from. Takes
+	 * precedence over `envParser`.
+	 */
+	serviceDiscovery?: ServiceDiscovery;
+}
+
+/**
+ * Options for {@link withServices}: request context (logger) + service resolution.
+ */
+export type ServiceMiddlewareOptions<TLogger extends Logger = Logger> =
+	RequestContextOptions<TLogger> & ServiceResolverOptions;
+
+function deriveRequestId(
+	options: RequestContextOptions,
+	event: unknown,
+	context: Context,
+): string {
+	// Lambda always populates context.awsRequestId; getRequestId can override it.
+	return options.getRequestId?.(event, context) ?? context.awsRequestId;
+}
+
+function buildLogger(
+	baseLogger: Logger,
+	options: RequestContextOptions,
+	requestId: string,
+	event: unknown,
+	context: Context,
+): Logger {
+	return baseLogger.child({
+		requestId,
+		...(options.bindings?.(event, context) ?? {}),
+	});
+}
+
+/**
+ * Middy middleware that establishes a request context for the handler so any
+ * code it reaches — including `@geekmidas/services` service methods — can call
+ * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.
+ *
+ * Use this on standalone functions that need request-scoped logging. To also
+ * resolve services, pair it with {@link addServices}, or use
+ * {@link withServices} which bundles both.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { serviceContext } from '@geekmidas/services';
+ * import { requestContext } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async () => {
+ *   serviceContext.getLogger().info('tick');
+ * }).use(requestContext({ logger }));
+ * ```
+ */
+export function requestContext<TLogger extends Logger = Logger>(
+	options: RequestContextOptions<TLogger>,
+): MiddlewareObj<unknown, unknown, Error, Context> {
+	const baseLogger = options.logger;
+	return {
+		before: (request) => {
+			const { event, context } = request;
+			const requestId = deriveRequestId(options, event, context);
+			const logger = buildLogger(
+				baseLogger,
+				options,
+				requestId,
+				event,
+				context,
+			);
+			enterRequestContext({ logger, requestId, startTime: Date.now() });
+		},
+		after: () => {
+			exitRequestContext();
+		},
+		onError: () => {
+			exitRequestContext();
+		},
+	};
+}
+
+function resolveDiscovery(options: ServiceResolverOptions): ServiceDiscovery {
+	return (
+		options.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser)
+	);
+}
+
+/**
+ * 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)`.
+ */
+export type EventServices<T extends Service[]> = {
+	services: ServiceRecord<T>;
+};
+
+/**
+ * Middy middleware that resolves an array of {@link Service}s via
+ * {@link ServiceDiscovery} and attaches the resolved record to `event.services`
+ * (keyed by each service's `serviceName`), matching how the `Function`/`Cron`
+ * constructs expose services on the event.
+ *
+ * This middleware only resolves services; it does **not** establish a request
+ * context. If your services read `serviceContext` (e.g. `getLogger()`), pair it
+ * with {@link requestContext}, or use {@link withServices} which bundles both.
+ *
+ * Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto
+ * `event.services`.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { addServices, requestContext } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async (event) => {
+ *   await event.services.database.users.deletePast();
+ *   event.services.cache.clear();
+ * })
+ *   .use(requestContext())
+ *   .use(addServices([databaseService, cacheService], { envParser }));
+ * ```
+ */
+export function addServices<const T extends Service[]>(
+	services: [...T],
+	options: ServiceResolverOptions,
+): MiddlewareObj<EventServices<T>, unknown, Error, Context> {
+	const discovery = resolveDiscovery(options);
+
+	return {
+		before: async (request) => {
+			const resolved = await discovery.register(services);
+			const event = request.event as { services?: Record<string, unknown> };
+			// Merge so chained addServices(...) calls accumulate on event.services.
+			event.services = { ...(event.services ?? {}), ...resolved };
+		},
+	};
+}
+
+/**
+ * Batteries-included Middy setup for service-backed handlers: returns a pair of
+ * middlewares — {@link requestContext} followed by {@link addServices} — so a
+ * single `.use(withServices([...]))` gives the handler both a request context
+ * and the resolved services on `event.services`.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { withServices } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async (event) => {
+ *   await event.services.database.users.deletePast();
+ *   event.services.cache.clear();
+ * }).use(withServices([databaseService, cacheService], { envParser }));
+ * ```
+ */
+export 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>,
+] {
+	return [requestContext(options), addServices(services, options)];
+}

package/src/trpc.ts

@@ -0,0 +1,190 @@
+import { randomUUID } from 'node:crypto';
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import type {
+	TRPCMiddlewareBuilder,
+	TRPCMiddlewareFunction,
+} from '@trpc/server';
+import { runWithRequestContext } from './context';
+import { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';
+import type { Service } from './types';
+
+/**
+ * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
+ * initialized `t` object so callers retain ownership of their tRPC instance
+ * (no double-initialization, no opinion on context/meta shape).
+ */
+type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(
+	fn: TRPCMiddlewareFunction<
+		TContext,
+		TMeta,
+		object,
+		$ContextOverrides,
+		unknown
+	>,
+) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;
+
+/**
+ * Result of `createServicesMiddleware`: a function that accepts a service
+ * tuple and returns a tRPC middleware that merges resolved services onto the
+ * context.
+ */
+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`.
+ */
+export interface ContextWithServiceDiscovery {
+	serviceDiscovery: ServiceDiscovery;
+}
+
+/**
+ * Minimum context required for request-context propagation. `logger` must be
+ * present so services can call `serviceContext.getLogger()`. `requestId` and
+ * `startTime` are auto-generated if missing.
+ */
+export interface ContextWithLogger {
+	logger: Logger;
+	requestId?: string;
+	startTime?: number;
+}
+
+/**
+ * Create a tRPC middleware that:
+ *
+ * 1. Resolves the requested services via `ServiceDiscovery`.
+ * 2. Wraps the downstream call in `runWithRequestContext` so any code reached
+ *    by the procedure (including service method implementations) can read the
+ *    current logger/request id via `serviceContext`.
+ * 3. Merges the resolved services onto the tRPC context so handlers can access
+ *    them by service name (`ctx.database`, `ctx.cache`, ...).
+ *
+ * Two overloads:
+ * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.
+ * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.
+ *
+ * @example
+ * ```ts
+ * import { initTRPC } from '@trpc/server';
+ * import { createServicesMiddleware } from '@geekmidas/services/trpc';
+ *
+ * const t = initTRPC.context<Context>().create();
+ * const withServices = createServicesMiddleware(t.middleware, envParser);
+ *
+ * export const authedProcedure = t.procedure.use(
+ *   withServices([databaseService, cacheService]),
+ * );
+ * ```
+ */
+export function createServicesMiddleware<
+	TContext extends ContextWithLogger & object,
+	TMeta extends object,
+>(
+	mw: CreateMiddleware<TContext, TMeta>,
+	envParser: EnvironmentParser<{}>,
+): ServicesMiddleware<TContext, TMeta>;
+export function createServicesMiddleware<
+	TContext extends ContextWithLogger & ContextWithServiceDiscovery & object,
+	TMeta extends object,
+>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+export function createServicesMiddleware<
+	TContext extends ContextWithLogger & object,
+	TMeta extends object,
+>(
+	mw: CreateMiddleware<TContext, TMeta>,
+	envParser?: EnvironmentParser<{}>,
+): ServicesMiddleware<TContext, TMeta> {
+	return (<const T extends Service[]>(services: [...T]) => {
+		const builder = mw(async (opts) => {
+			const ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;
+
+			const discovery =
+				ctx.serviceDiscovery ??
+				ServiceDiscovery.getInstance(
+					envParser ??
+						(() => {
+							// Hit only if overload 2 was selected but ctx.serviceDiscovery is
+							// missing at runtime — surface the mistake immediately rather
+							// than letting an undefined env parser fail deep inside register.
+							throw new Error(
+								'createServicesMiddleware: no `envParser` provided and ' +
+									'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +
+									'to createServicesMiddleware(), or attach a ServiceDiscovery ' +
+									'instance to the tRPC context.',
+							);
+						})(),
+				);
+
+			const requestId = ctx.requestId ?? randomUUID();
+			const startTime = ctx.startTime ?? Date.now();
+
+			return runWithRequestContext(
+				{ logger: ctx.logger, requestId, startTime },
+				async () => {
+					const resolved = await discovery.register(services);
+					return opts.next({
+						ctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &
+							ServiceRecord<T>,
+					});
+				},
+			);
+		});
+
+		// Tag the inner middleware function with the requested services so external
+		// tooling (e.g. detect-procedures route generators) can introspect a
+		// procedure's service dependencies without re-executing middleware.
+		const middlewares = (
+			builder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }
+		)._middlewares;
+		if (middlewares?.length) {
+			const last = middlewares[middlewares.length - 1];
+			if (last) last._services = services as unknown as Service[];
+		}
+
+		return builder as TRPCMiddlewareBuilder<
+			TContext,
+			TMeta,
+			ServiceRecord<T>,
+			unknown
+		>;
+	}) as 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
+ * a procedure but the handler (or libraries it calls) still wants to read
+ * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.
+ *
+ * `requestId` and `startTime` are pulled from the tRPC context when present,
+ * otherwise generated (`randomUUID()` and `Date.now()`).
+ *
+ * @example
+ * ```ts
+ * const withRequestContext = createRequestContextMiddleware(t.middleware);
+ * export const baseProcedure = t.procedure.use(withRequestContext);
+ * ```
+ */
+export function createRequestContextMiddleware<
+	TContext extends ContextWithLogger & object,
+	TMeta extends object,
+>(
+	mw: CreateMiddleware<TContext, TMeta>,
+): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {
+	return mw(async (opts) => {
+		const ctx = opts.ctx as TContext;
+		const requestId = ctx.requestId ?? randomUUID();
+		const startTime = ctx.startTime ?? Date.now();
+		return runWithRequestContext(
+			{ logger: ctx.logger, requestId, startTime },
+			() => opts.next(),
+		);
+	});
+}

package/src/types.ts

@@ -9,6 +9,13 @@ import type { Logger } from '@geekmidas/logger';
 export interface ServiceContext {
 	/**
 	 * Get the current request's logger.
+	 *
+	 * Returns a **request-scoped proxy** that re-resolves the underlying logger
+	 * from AsyncLocalStorage on every call. This makes it safe for a singleton
+	 * service to capture the logger once (e.g. during `register()`) and reuse it
+	 * across requests — each log call routes to the current request's logger
+	 * instead of freezing the first request's logger.
+	 *
 	 * @throws Error if called outside a request context
 	 */
 	getLogger(): Logger;

package/tsdown.config.ts

@@ -1,3 +1,13 @@
 import { defineConfig } from 'tsdown';
 
-export default defineConfig({});
+export default defineConfig({
+	entry: ['src/index.ts', 'src/context.ts', 'src/trpc.ts', 'src/middy.ts'],
+	clean: true,
+	outDir: 'dist',
+	format: ['cjs', 'esm'],
+	sourcemap: true,
+	dts: true,
+	outExtensions: (ctx) => ({
+		js: ctx.format === 'es' ? '.mjs' : '.cjs',
+	}),
+});

package/dist/ServiceDiscovery.cjs

@@ -1,4 +0,0 @@
-require('./context-CoyHq8lH.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-C5x1wcN1.cjs');
-
-exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;

package/dist/ServiceDiscovery.d.cts

@@ -1,3 +0,0 @@
-import "./types-D7d_yeU5.cjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-Dvqa-Q1_.cjs";
-export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.d.mts

@@ -1,3 +0,0 @@
-import "./types-CcHmCx_U.mjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-ykolgkIj.mjs";
-export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.mjs

@@ -1,4 +0,0 @@
-import "./context-BpYagzpr.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-tZ6VKHIZ.mjs";
-
-export { ServiceDiscovery };

package/dist/context-BpYagzpr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-BpYagzpr.mjs","names":["serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * 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\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getLogger() 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.logger;\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;;;;;;AAOlC,MAAaA,iBAAiC;CAC7C,YAAY;EACX,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/context-CaeISj3o.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-CaeISj3o.d.cts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAkBA;AA2DgB,UA7EC,kBAAA,CA6EoB;EAAA,MAAA,EA5E5B,MA4E4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA9EH,cA8EsB,EA9EN,cA8Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/context-CoyHq8lH.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-CoyHq8lH.cjs","names":["AsyncLocalStorage","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * 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\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getLogger() 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.logger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAM,wBAAwB,IAAIA;;;;;;AAOlC,MAAaC,iBAAiC;CAC7C,YAAY;EACX,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/context-HGC2PJzv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-HGC2PJzv.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAkBA;AA2DgB,UA7EC,kBAAA,CA6EoB;EAAA,MAAA,EA5E5B,MA4E4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA9EH,cA8EsB,EA9EN,cA8Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types-CcHmCx_U.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AA8BA;;AAEY,UAhCK,cAAA,CAgCL;EAAiB;AAEL;AA8BxB;;EAAwB,SAIV,EAAA,EA/DA,MA+DA;EAAK;;;;EAO4C,YAAA,EAAA,EAAA,MAAA;;;;;;;;;;;;;;;;UA7C9C,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types-D7d_yeU5.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AA8BA;;AAEY,UAhCK,cAAA,CAgCL;EAAiB;AAEL;AA8BxB;;EAAwB,SAIV,EAAA,EA/DA,MA+DA;EAAK;;;;EAO4C,YAAA,EAAA,EAAA,MAAA;;;;;;;;;;;;;;;;UA7C9C,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/dist/types.d.cts

@@ -1,2 +0,0 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-D7d_yeU5.cjs";
-export { Service, ServiceContext, ServiceRegisterOptions };

package/dist/types.d.mts

@@ -1,2 +0,0 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-CcHmCx_U.mjs";
-export { Service, ServiceContext, ServiceRegisterOptions };