@geekmidas/services 1.0.3 → 1.1.0

package/dist/trpc.cjs.map

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

package/dist/trpc.d.cts

@@ -0,0 +1,86 @@
+import { Service } from "./types-Bgk-0NOO.cjs";
+import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-BO8W-RY8.cjs";
+import { Logger } from "@geekmidas/logger";
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
+
+//#region src/trpc.d.ts
+
+/**
+ * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
+ * initialized `t` object so callers retain ownership of their tRPC instance
+ * (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.
+ */
+type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+/**
+ * Context shape required by `createServicesMiddleware` overload 2.
+ * Procedures that pull services via context-stored discovery must expose it
+ * under `serviceDiscovery`.
+ */
+interface ContextWithServiceDiscovery {
+  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.
+ */
+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]),
+ * );
+ * ```
+ */
+declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+/**
+ * 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);
+ * ```
+ */
+declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+//#endregion
+export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
+//# sourceMappingURL=trpc.d.cts.map

package/dist/trpc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.cts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}

package/dist/trpc.d.mts

@@ -0,0 +1,86 @@
+import { Service } from "./types-BoyOCa57.mjs";
+import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CRq_bGbi.mjs";
+import { Logger } from "@geekmidas/logger";
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
+
+//#region src/trpc.d.ts
+
+/**
+ * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
+ * initialized `t` object so callers retain ownership of their tRPC instance
+ * (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.
+ */
+type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+/**
+ * Context shape required by `createServicesMiddleware` overload 2.
+ * Procedures that pull services via context-stored discovery must expose it
+ * under `serviceDiscovery`.
+ */
+interface ContextWithServiceDiscovery {
+  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.
+ */
+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]),
+ * );
+ * ```
+ */
+declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+/**
+ * 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);
+ * ```
+ */
+declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+//#endregion
+export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
+//# sourceMappingURL=trpc.d.mts.map

package/dist/trpc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}

package/dist/trpc.mjs

@@ -0,0 +1,65 @@
+import { runWithRequestContext } from "./context-C9DCrFWA.mjs";
+import { ServiceDiscovery } from "./ServiceDiscovery-DO_uDfuG.mjs";
+import { randomUUID } from "node:crypto";
+
+//#region src/trpc.ts
+function createServicesMiddleware(mw, envParser) {
+	return (services) => {
+		const builder = mw(async (opts) => {
+			const ctx = opts.ctx;
+			const discovery = ctx.serviceDiscovery ?? ServiceDiscovery.getInstance(envParser ?? (() => {
+				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
+				} });
+			});
+		});
+		const middlewares = builder._middlewares;
+		if (middlewares?.length) {
+			const last = middlewares[middlewares.length - 1];
+			if (last) last._services = services;
+		}
+		return builder;
+	};
+}
+/**
+* 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);
+* ```
+*/
+function createRequestContextMiddleware(mw) {
+	return mw(async (opts) => {
+		const ctx = opts.ctx;
+		const requestId = ctx.requestId ?? randomUUID();
+		const startTime = ctx.startTime ?? Date.now();
+		return runWithRequestContext({
+			logger: ctx.logger,
+			requestId,
+			startTime
+		}, () => opts.next());
+	});
+}
+
+//#endregion
+export { createRequestContextMiddleware, createServicesMiddleware };
+//# sourceMappingURL=trpc.mjs.map

package/dist/trpc.mjs.map

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

package/dist/{types-CcHmCx_U.d.mts → types-Bgk-0NOO.d.cts}

@@ -1,5 +1,5 @@
-import { EnvironmentParser } from "@geekmidas/envkit";
 import { Logger } from "@geekmidas/logger";
+import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/types.d.ts
 
@@ -11,6 +11,13 @@ import { Logger } from "@geekmidas/logger";
 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;
@@ -83,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-CcHmCx_U.d.mts.map
+//# sourceMappingURL=types-Bgk-0NOO.d.cts.map

package/dist/types-Bgk-0NOO.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Bgk-0NOO.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAqCA;;AAEY,UAvCK,cAAA,CAuCL;EAAiB;AAEL;AA8BxB;;;;;;;AAW+D;;eAtEjD;;;;;;;;;;;;;;;;;;;;;UAyBG,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/dist/{types-D7d_yeU5.d.cts → types-BoyOCa57.d.mts}

@@ -1,5 +1,5 @@
-import { EnvironmentParser } from "@geekmidas/envkit";
 import { Logger } from "@geekmidas/logger";
+import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/types.d.ts
 
@@ -11,6 +11,13 @@ import { Logger } from "@geekmidas/logger";
 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;
@@ -83,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-D7d_yeU5.d.cts.map
+//# sourceMappingURL=types-BoyOCa57.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-BoyOCa57.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAqCA;;AAEY,UAvCK,cAAA,CAuCL;EAAiB;AAEL;AA8BxB;;;;;;;AAW+D;;eAtEjD;;;;;;;;;;;;;;;;;;;;;UAyBG,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/docs/request-scoped-logging.md

@@ -0,0 +1,167 @@
+# Request-Scoped Logging in Singleton Services
+
+## Problem
+
+Services in `@geekmidas/services` are **singletons**. `ServiceDiscovery.register()`
+(and `get()`) instantiates a service **once**, caches the instance in an internal
+`Map`, and returns that same instance for every subsequent request:
+
+```ts
+// ServiceDiscovery.register()
+if (this.instances.has(name)) {
+  return this.instances.get(name); // cached — register() does NOT run again
+}
+const instance = await service.register({ envParser, context: serviceContext });
+this.instances.set(name, instance);
+```
+
+The per-request logger, on the other hand, is **not** a singleton. On every request
+an adaptor builds a fresh child logger with request-specific bindings and stores it
+in `AsyncLocalStorage` via `runWithRequestContext`:
+
+```ts
+// e.g. HonoEndpointAdaptor
+const logger = endpoint.logger.child({
+  requestId,          // unique per request
+  endpoint, route, host, method, path,
+});
+
+return runWithRequestContext({ logger, requestId, startTime }, async () => {
+  const services = await serviceDiscovery.register(endpoint.services);
+  // ...handle request...
+});
+```
+
+### The bug
+
+`service.register()` runs **inside the first request's context**. If a service reads
+the logger **at registration time** and stores the concrete reference:
+
+```ts
+const databaseService = {
+  serviceName: 'database' as const,
+  register({ context }) {
+    const logger = context.getLogger(); // ❌ resolved ONCE, during request #1
+
+    return {
+      async query(sql: string) {
+        logger.debug({ sql }, 'Executing query'); // always request #1's logger
+      },
+    };
+  },
+} satisfies Service<'database', Database>;
+```
+
+…then `logger` is frozen to the **first** request's logger forever, because
+`register()` never runs again. Every later request reuses the cached service
+instance, so its logs carry the **first** request's `requestId` (and any user/session
+bindings).
+
+**Symptom:** logs make it look like the user who made the *first* request after a
+cold start is responsible for actions actually performed by *other* users on later
+requests. Request correlation, per-user log filtering, and audit trails are all
+silently wrong.
+
+This is an easy mistake to make because `register()` is handed a `context` object,
+and "grab the logger once and reuse it" looks reasonable — but it is incompatible
+with the singleton lifecycle.
+
+## Solution
+
+`serviceContext.getLogger()` returns a **stable, request-scoped proxy logger**
+instead of the raw logger. The proxy holds no logger of its own — on **every** log
+call it re-resolves the current request's logger from `AsyncLocalStorage`:
+
+```
+proxy.info('x')  →  asyncLocalStorage.getStore().logger.info('x')   // resolved at call time
+```
+
+Because resolution happens per call (not at capture time), capturing the logger once
+during `register()` is now **safe**: the single captured reference routes each call
+to whichever request is currently executing.
+
+```ts
+register({ context }) {
+  const logger = context.getLogger(); // ✅ now safe to capture — it's a live proxy
+
+  return {
+    async query(sql: string) {
+      logger.debug({ sql }, 'Executing query'); // logs to the CURRENT request
+    },
+  };
+}
+```
+
+### Child loggers compose correctly too
+
+`proxy.child(bindings)` returns **another** proxy carrying the bindings, applied lazily
+on top of the current request's logger at call time:
+
+```ts
+register({ context }) {
+  // Captured once. `{ svc: 'db' }` is the static part; the per-request bindings
+  // (requestId, user, ...) come from whichever base logger is current.
+  const logger = context.getLogger().child({ svc: 'db' });
+
+  return {
+    async query(sql: string) {
+      // request A → loggerA.child({ svc: 'db' }).debug(...)
+      // request B → loggerB.child({ svc: 'db' }).debug(...)
+      logger.debug({ sql }, 'Executing query');
+    },
+  };
+}
+```
+
+### Implementation
+
+See `createRequestScopedLogger` in
+[`src/context.ts`](../src/context.ts):
+
+- `getLogger()` still **throws eagerly** if called with no active request context,
+  preserving the "catch bugs early" contract.
+- The returned object is a shared, process-wide proxy. It carries no request state,
+  so sharing it across requests is safe — `AsyncLocalStorage` provides correct
+  per-async-context isolation, and each resolve/log call is synchronous (no `await`
+  between resolving and using the logger), so it is concurrency-safe.
+- Each `child()` call returns a new proxy that remembers its bindings and rebuilds
+  the child chain off the current base logger, memoised per underlying logger to
+  avoid rebuilding the chain on every log line.
+
+## Guidance for service authors
+
+- ✅ You **may** capture `context.getLogger()` (or a `.child()` of it) once in
+  `register()` and reuse it — it stays correct per request.
+- ✅ You **may** also call `context.getLogger()` inside each method; behaviour is
+  identical.
+- ⚠️ Do **not** wrap the proxy in something that snapshots a concrete logger, e.g.
+  `const real = someConcreteLogger; ...` outside the proxy. Resolution only stays
+  live while you go through the proxy returned by `getLogger()`/`.child()`.
+- ⚠️ Calling a log method outside any request context throws
+  (`called outside request context`). Guard background work with
+  `serviceContext.hasContext()` if it may run detached from a request.
+
+## Tests
+
+Regression coverage lives in
+[`src/__tests__/context.spec.ts`](../src/__tests__/context.spec.ts):
+
+- `captured-once logger follows each request (singleton service fix)` — a logger
+  captured during the first request still logs to the second request's logger.
+- `child loggers also follow the current request` — the same guarantee for
+  `.child()` proxies.
+- `should delegate to the current request logger` — basic delegation.
+
+## Establishing the context
+
+The request context this relies on is established by the adaptors that run your
+code:
+
+- **Constructs** (`Endpoint`, `Function`, `Cron`, `Subscriber`) wrap each
+  invocation in `runWithRequestContext` automatically.
+- **Standalone Middy handlers** can opt in with the
+  `@geekmidas/services/middy` middlewares (`requestContext`, `addServices`,
+  `withServices`), which establish the context (and optionally resolve services)
+  before the handler runs.
+- **Tests** can use `@geekmidas/testkit`'s `runInRequestContext` /
+  `requestContextFixture`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/services",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -23,6 +23,26 @@
         "types": "./dist/context.d.cts",
         "default": "./dist/context.cjs"
       }
+    },
+    "./trpc": {
+      "import": {
+        "types": "./dist/trpc.d.mts",
+        "default": "./dist/trpc.mjs"
+      },
+      "require": {
+        "types": "./dist/trpc.d.cts",
+        "default": "./dist/trpc.cjs"
+      }
+    },
+    "./middy": {
+      "import": {
+        "types": "./dist/middy.d.mts",
+        "default": "./dist/middy.mjs"
+      },
+      "require": {
+        "types": "./dist/middy.d.cts",
+        "default": "./dist/middy.cjs"
+      }
     }
   },
   "repository": {
@@ -35,6 +55,9 @@
   },
   "dependencies": {},
   "peerDependencies": {
+    "@middy/core": ">=6.3.1",
+    "@trpc/server": ">=11.0.0",
+    "@types/aws-lambda": ">=8.10.92",
     "@geekmidas/envkit": "^1.0.7",
     "@geekmidas/logger": "^1.0.2"
   },
@@ -44,9 +67,22 @@
     },
     "@geekmidas/logger": {
       "optional": true
+    },
+    "@middy/core": {
+      "optional": true
+    },
+    "@trpc/server": {
+      "optional": true
+    },
+    "@types/aws-lambda": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@middy/core": "~6.3.2",
+    "@trpc/server": "~11.16.0",
+    "@types/aws-lambda": "~8.10.147",
+    "@types/node": "~24.9.1",
     "@geekmidas/envkit": "^1.0.7",
     "@geekmidas/logger": "^1.0.2"
   },