@geekmidas/services 1.0.4 → 1.1.0

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-B99KrvXR.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
 
@@ -90,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-B99KrvXR.d.mts.map
+//# sourceMappingURL=types-Bgk-0NOO.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types-B99KrvXR.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"}
+{"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-BY9yrY6Y.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
 
@@ -90,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-BY9yrY6Y.d.cts.map
+//# sourceMappingURL=types-BoyOCa57.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types-BY9yrY6Y.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"}
+{"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

@@ -151,3 +151,17 @@ Regression coverage lives in
 - `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.4",
+  "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"
   },

package/src/__tests__/middy.spec.ts

@@ -0,0 +1,218 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import middy from '@middy/core';
+import type { Context } from 'aws-lambda';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { serviceContext } from '../context';
+import { addServices, requestContext, withServices } from '../middy';
+import { ServiceDiscovery } from '../ServiceDiscovery';
+import type { Service } from '../types';
+
+const createMockContext = (): Context =>
+	({
+		functionName: 'standalone',
+		functionVersion: '1',
+		invokedFunctionArn:
+			'arn:aws:lambda:us-east-1:123456789012:function:standalone',
+		memoryLimitInMB: '128',
+		awsRequestId: 'aws-req-1',
+		logGroupName: '/aws/lambda/standalone',
+		logStreamName: 'stream',
+		getRemainingTimeInMillis: () => 30000,
+		done: vi.fn(),
+		fail: vi.fn(),
+		succeed: vi.fn(),
+		callbackWaitsForEmptyEventLoop: true,
+	}) as unknown as Context;
+
+/**
+ * Invoke a Middy-wrapped handler with a mock Lambda context. The service
+ * middlewares augment the context type to require `services`, but at runtime
+ * they populate it before the handler runs — so the mock starts without it and
+ * we invoke through a loosely-typed shim.
+ */
+const invoke = (
+	handler: (event: any, context: any) => any,
+	event: unknown = {},
+): Promise<unknown> => Promise.resolve(handler(event, createMockContext()));
+
+function makeSpyLogger(): Logger {
+	const logger: Logger = {
+		trace: vi.fn(),
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
+}
+
+interface Greeter {
+	greet(): string;
+	registeredRequestId: string;
+}
+
+class GreeterService implements Service<'greeter', Greeter> {
+	serviceName = 'greeter' as const;
+	async register(): Promise<Greeter> {
+		// Service code can read the request context during registration.
+		const registeredRequestId = serviceContext.getRequestId();
+		return {
+			registeredRequestId,
+			greet() {
+				serviceContext.getLogger().info('greeting');
+				return 'hello';
+			},
+		};
+	}
+}
+
+interface Counter {
+	next(): number;
+}
+
+class CounterService implements Service<'counter', Counter> {
+	serviceName = 'counter' as const;
+	async register(): Promise<Counter> {
+		let n = 0;
+		return { next: () => ++n };
+	}
+}
+
+describe('middy adaptor', () => {
+	beforeEach(() => {
+		// ServiceDiscovery is a process-wide singleton that caches resolved
+		// instances; reset so each test starts clean.
+		ServiceDiscovery.reset();
+	});
+
+	describe('requestContext', () => {
+		it('makes serviceContext available inside a plain handler', async () => {
+			const logger = makeSpyLogger();
+			let seenRequestId: string | undefined;
+			let hadContext = false;
+
+			const handler = middy(async () => {
+				hadContext = serviceContext.hasContext();
+				seenRequestId = serviceContext.getRequestId();
+				serviceContext.getLogger().info('tick');
+			}).use(requestContext({ logger }));
+
+			await invoke(handler);
+
+			expect(hadContext).toBe(true);
+			expect(seenRequestId).toBe('aws-req-1');
+			expect(logger.info).toHaveBeenCalledWith('tick');
+		});
+
+		it('gives each invocation its own fresh context', async () => {
+			const seen: string[] = [];
+			let counter = 0;
+			const handler = middy(async () => {
+				seen.push(serviceContext.getRequestId());
+			}).use(
+				requestContext({
+					logger: makeSpyLogger(),
+					getRequestId: () => `req-${++counter}`,
+				}),
+			);
+
+			await invoke(handler);
+			await invoke(handler);
+
+			// The second invocation must not inherit the first's request id.
+			expect(seen).toEqual(['req-1', 'req-2']);
+		});
+
+		it('propagates handler errors', async () => {
+			const handler = middy(async () => {
+				throw new Error('boom');
+			}).use(requestContext({ logger: makeSpyLogger() }));
+
+			await expect(invoke(handler)).rejects.toThrow('boom');
+		});
+
+		it('derives the request id via getRequestId override', async () => {
+			let seen: string | undefined;
+			const handler = middy(async () => {
+				seen = serviceContext.getRequestId();
+			}).use(
+				requestContext({
+					logger: makeSpyLogger(),
+					getRequestId: () => 'custom-id',
+				}),
+			);
+
+			await invoke(handler);
+			expect(seen).toBe('custom-id');
+		});
+	});
+
+	describe('addServices', () => {
+		it('resolves services onto event.services (paired with requestContext)', async () => {
+			const envParser = new EnvironmentParser({});
+			const logger = makeSpyLogger();
+			let greeting: string | undefined;
+			let counted: number | undefined;
+			let registeredRequestId: string | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				registeredRequestId = event.services.greeter.registeredRequestId;
+				greeting = event.services.greeter.greet();
+				counted = event.services.counter.next();
+			})
+				.use(requestContext({ logger, getRequestId: () => 'shared-id' }))
+				.use(
+					addServices([new GreeterService(), new CounterService()], {
+						envParser,
+					}),
+				);
+
+			await invoke(handler);
+
+			expect(greeting).toBe('hello');
+			expect(counted).toBe(1);
+			// register() and the service method ran inside the requestContext.
+			expect(registeredRequestId).toBe('shared-id');
+			expect(logger.info).toHaveBeenCalledWith('greeting');
+		});
+
+		it('resolves context-free services without a requestContext', async () => {
+			const envParser = new EnvironmentParser({});
+			let counted: number | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				counted = event.services.counter.next();
+			}).use(addServices([new CounterService()], { envParser }));
+
+			await invoke(handler);
+
+			expect(counted).toBe(1);
+		});
+	});
+
+	describe('withServices', () => {
+		it('establishes context and resolves services out of the box', async () => {
+			const envParser = new EnvironmentParser({});
+			let greeting: string | undefined;
+			let registeredRequestId: string | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				registeredRequestId = event.services.greeter.registeredRequestId;
+				greeting = event.services.greeter.greet();
+			}).use(
+				withServices([new GreeterService()], {
+					logger: makeSpyLogger(),
+					envParser,
+				}),
+			);
+
+			await invoke(handler);
+
+			expect(greeting).toBe('hello');
+			expect(registeredRequestId).toBe('aws-req-1');
+		});
+	});
+});