@geekmidas/services 1.0.3 → 1.1.0

package/dist/middy.cjs

@@ -0,0 +1,120 @@
+const require_context = require('./context-Cf2Ig5qr.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-m3XkNh32.cjs');
+
+//#region src/middy.ts
+function deriveRequestId(options, event, context) {
+	return options.getRequestId?.(event, context) ?? context.awsRequestId;
+}
+function buildLogger(baseLogger, options, requestId, event, context) {
+	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 }));
+* ```
+*/
+function requestContext(options) {
+	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);
+			require_context.enterRequestContext({
+				logger,
+				requestId,
+				startTime: Date.now()
+			});
+		},
+		after: () => {
+			require_context.exitRequestContext();
+		},
+		onError: () => {
+			require_context.exitRequestContext();
+		}
+	};
+}
+function resolveDiscovery(options) {
+	return options.serviceDiscovery ?? require_ServiceDiscovery.ServiceDiscovery.getInstance(options.envParser);
+}
+/**
+* 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 }));
+* ```
+*/
+function addServices(services, options) {
+	const discovery = resolveDiscovery(options);
+	return { before: async (request) => {
+		const resolved = await discovery.register(services);
+		const event = request.event;
+		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 }));
+* ```
+*/
+function withServices(services, options) {
+	return [requestContext(options), addServices(services, options)];
+}
+
+//#endregion
+exports.addServices = addServices;
+exports.requestContext = requestContext;
+exports.withServices = withServices;
+//# sourceMappingURL=middy.cjs.map

package/dist/middy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.cjs","names":["options: RequestContextOptions","event: unknown","context: Context","baseLogger: Logger","requestId: string","options: RequestContextOptions<TLogger>","options: ServiceResolverOptions","services: [...T]","options: ServiceMiddlewareOptions<TLogger>"],"sources":["../src/middy.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type { MiddlewareObj } from '@middy/core';\nimport type { Context } from 'aws-lambda';\nimport { enterRequestContext, exitRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Middy middleware helpers that bring `@geekmidas/services` request context and\n * service discovery to **standalone** Middy Lambda handlers — i.e. functions\n * that aren't built with the `@geekmidas/constructs` Function/Cron constructs\n * but still want `serviceContext.getLogger()` and resolved services.\n *\n * Why middleware (and not `runWithRequestContext`)? Middy runs `before → handler\n * → after` as sequential awaits in a single async context, so establishing the\n * context with `AsyncLocalStorage.enterWith` (via `enterRequestContext`) in a\n * `before` hook propagates to the handler. `after`/`onError` reset it.\n *\n * Teardown is best-effort: like `enterRequestContext`, the reset is observable\n * to code the handler reaches but not necessarily to the frame that invoked the\n * Middy handler. This is fine for Lambda, where each invocation runs in its own\n * fresh async context — `requestContext` always establishes a brand-new context\n * per invocation, so requests never inherit a previous invocation's logger.\n *\n * @module\n */\n\n/**\n * Options for {@link requestContext}. Generic over the logger type so a custom\n * logger that extends {@link Logger} is preserved rather than widened.\n */\nexport interface RequestContextOptions<TLogger extends Logger = Logger> {\n\t/**\n\t * Logger to derive the per-request child logger from. Required — the caller\n\t * decides which logger to use (there is no implicit default).\n\t */\n\tlogger: TLogger;\n\t/**\n\t * Derive the request id from the event/context.\n\t * Defaults to `context.awsRequestId` (always present in a Lambda invocation).\n\t */\n\tgetRequestId?: (event: unknown, context: Context) => string;\n\t/**\n\t * Extra bindings to attach to the per-request child logger.\n\t */\n\tbindings?: (event: unknown, context: Context) => Record<string, unknown>;\n}\n\n/**\n * Options for {@link addServices} — how services are resolved. No logger is\n * needed because resolving services doesn't establish a request context.\n */\nexport interface ServiceResolverOptions {\n\t/**\n\t * Environment parser used to build the {@link ServiceDiscovery}. Required —\n\t * the caller supplies the parser (there is no implicit `process.env` default).\n\t */\n\tenvParser: EnvironmentParser<{}>;\n\t/**\n\t * Explicit {@link ServiceDiscovery} to resolve services from. Takes\n\t * precedence over `envParser`.\n\t */\n\tserviceDiscovery?: ServiceDiscovery;\n}\n\n/**\n * Options for {@link withServices}: request context (logger) + service resolution.\n */\nexport type ServiceMiddlewareOptions<TLogger extends Logger = Logger> =\n\tRequestContextOptions<TLogger> & ServiceResolverOptions;\n\nfunction deriveRequestId(\n\toptions: RequestContextOptions,\n\tevent: unknown,\n\tcontext: Context,\n): string {\n\t// Lambda always populates context.awsRequestId; getRequestId can override it.\n\treturn options.getRequestId?.(event, context) ?? context.awsRequestId;\n}\n\nfunction buildLogger(\n\tbaseLogger: Logger,\n\toptions: RequestContextOptions,\n\trequestId: string,\n\tevent: unknown,\n\tcontext: Context,\n): Logger {\n\treturn baseLogger.child({\n\t\trequestId,\n\t\t...(options.bindings?.(event, context) ?? {}),\n\t});\n}\n\n/**\n * Middy middleware that establishes a request context for the handler so any\n * code it reaches — including `@geekmidas/services` service methods — can call\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * Use this on standalone functions that need request-scoped logging. To also\n * resolve services, pair it with {@link addServices}, or use\n * {@link withServices} which bundles both.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { serviceContext } from '@geekmidas/services';\n * import { requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async () => {\n *   serviceContext.getLogger().info('tick');\n * }).use(requestContext({ logger }));\n * ```\n */\nexport function requestContext<TLogger extends Logger = Logger>(\n\toptions: RequestContextOptions<TLogger>,\n): MiddlewareObj<unknown, unknown, Error, Context> {\n\tconst baseLogger = options.logger;\n\treturn {\n\t\tbefore: (request) => {\n\t\t\tconst { event, context } = request;\n\t\t\tconst requestId = deriveRequestId(options, event, context);\n\t\t\tconst logger = buildLogger(\n\t\t\t\tbaseLogger,\n\t\t\t\toptions,\n\t\t\t\trequestId,\n\t\t\t\tevent,\n\t\t\t\tcontext,\n\t\t\t);\n\t\t\tenterRequestContext({ logger, requestId, startTime: Date.now() });\n\t\t},\n\t\tafter: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t\tonError: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t};\n}\n\nfunction resolveDiscovery(options: ServiceResolverOptions): ServiceDiscovery {\n\treturn (\n\t\toptions.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser)\n\t);\n}\n\n/**\n * Event augmentation applied by {@link addServices} / {@link withServices}:\n * resolved services keyed by `serviceName`. Intersect it with your own event\n * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.\n */\nexport type EventServices<T extends Service[]> = {\n\tservices: ServiceRecord<T>;\n};\n\n/**\n * Middy middleware that resolves an array of {@link Service}s via\n * {@link ServiceDiscovery} and attaches the resolved record to `event.services`\n * (keyed by each service's `serviceName`), matching how the `Function`/`Cron`\n * constructs expose services on the event.\n *\n * This middleware only resolves services; it does **not** establish a request\n * context. If your services read `serviceContext` (e.g. `getLogger()`), pair it\n * with {@link requestContext}, or use {@link withServices} which bundles both.\n *\n * Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto\n * `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { addServices, requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * })\n *   .use(requestContext())\n *   .use(addServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function addServices<const T extends Service[]>(\n\tservices: [...T],\n\toptions: ServiceResolverOptions,\n): MiddlewareObj<EventServices<T>, unknown, Error, Context> {\n\tconst discovery = resolveDiscovery(options);\n\n\treturn {\n\t\tbefore: async (request) => {\n\t\t\tconst resolved = await discovery.register(services);\n\t\t\tconst event = request.event as { services?: Record<string, unknown> };\n\t\t\t// Merge so chained addServices(...) calls accumulate on event.services.\n\t\t\tevent.services = { ...(event.services ?? {}), ...resolved };\n\t\t},\n\t};\n}\n\n/**\n * Batteries-included Middy setup for service-backed handlers: returns a pair of\n * middlewares — {@link requestContext} followed by {@link addServices} — so a\n * single `.use(withServices([...]))` gives the handler both a request context\n * and the resolved services on `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { withServices } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * }).use(withServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function withServices<\n\tconst T extends Service[],\n\tTLogger extends Logger = Logger,\n>(\n\tservices: [...T],\n\toptions: ServiceMiddlewareOptions<TLogger>,\n): [\n\tMiddlewareObj<unknown, unknown, Error, Context>,\n\tMiddlewareObj<EventServices<T>, unknown, Error, Context>,\n] {\n\treturn [requestContext(options), addServices(services, options)];\n}\n"],"mappings":";;;;AAwEA,SAAS,gBACRA,SACAC,OACAC,SACS;AAET,QAAO,QAAQ,eAAe,OAAO,QAAQ,IAAI,QAAQ;AACzD;AAED,SAAS,YACRC,YACAH,SACAI,WACAH,OACAC,SACS;AACT,QAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,QAAQ,IAAI,CAAE;CAC5C,EAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,eACfG,SACkD;CAClD,MAAM,aAAa,QAAQ;AAC3B,QAAO;EACN,QAAQ,CAAC,YAAY;GACpB,MAAM,EAAE,OAAO,SAAS,GAAG;GAC3B,MAAM,YAAY,gBAAgB,SAAS,OAAO,QAAQ;GAC1D,MAAM,SAAS,YACd,YACA,SACA,WACA,OACA,QACA;AACD,uCAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,KAAK;GAAE,EAAC;EACjE;EACD,OAAO,MAAM;AACZ,uCAAoB;EACpB;EACD,SAAS,MAAM;AACd,uCAAoB;EACpB;CACD;AACD;AAED,SAAS,iBAAiBC,SAAmD;AAC5E,QACC,QAAQ,oBAAoB,0CAAiB,YAAY,QAAQ,UAAU;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCD,SAAgB,YACfC,UACAD,SAC2D;CAC3D,MAAM,YAAY,iBAAiB,QAAQ;AAE3C,QAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;EACnD,MAAM,QAAQ,QAAQ;AAEtB,QAAM,WAAW;GAAE,GAAI,MAAM,YAAY,CAAE;GAAG,GAAG;EAAU;CAC3D,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAgB,aAIfC,UACAC,SAIC;AACD,QAAO,CAAC,eAAe,QAAQ,EAAE,YAAY,UAAU,QAAQ,AAAC;AAChE"}

package/dist/middy.d.cts

@@ -0,0 +1,146 @@
+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 { MiddlewareObj } from "@middy/core";
+import { Context } from "aws-lambda";
+
+//#region src/middy.d.ts
+
+/**
+ * Middy middleware helpers that bring `@geekmidas/services` request context and
+ * service discovery to **standalone** Middy Lambda handlers — i.e. functions
+ * 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.
+ */
+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.
+ */
+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.
+ */
+type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
+/**
+ * Middy middleware that establishes a request context for the handler so any
+ * code it reaches — including `@geekmidas/services` service methods — can call
+ * `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 }));
+ * ```
+ */
+declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
+/**
+ * Event augmentation applied by {@link addServices} / {@link withServices}:
+ * resolved services keyed by `serviceName`. Intersect it with your own event
+ * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.
+ */
+type EventServices<T extends Service[]> = {
+  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 }));
+ * ```
+ */
+declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
+/**
+ * Batteries-included Middy setup for service-backed handlers: returns a pair of
+ * middlewares — {@link requestContext} followed by {@link addServices} — so a
+ * 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 }));
+ * ```
+ */
+declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
+//# sourceMappingURL=middy.d.ts.map
+//#endregion
+export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, ServiceResolverOptions, addServices, requestContext, withServices };
+//# sourceMappingURL=middy.d.cts.map

package/dist/middy.d.cts.map

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

package/dist/middy.d.mts

@@ -0,0 +1,146 @@
+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 { MiddlewareObj } from "@middy/core";
+import { Context } from "aws-lambda";
+
+//#region src/middy.d.ts
+
+/**
+ * Middy middleware helpers that bring `@geekmidas/services` request context and
+ * service discovery to **standalone** Middy Lambda handlers — i.e. functions
+ * 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.
+ */
+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.
+ */
+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.
+ */
+type ServiceMiddlewareOptions<TLogger extends Logger = Logger> = RequestContextOptions<TLogger> & ServiceResolverOptions;
+/**
+ * Middy middleware that establishes a request context for the handler so any
+ * code it reaches — including `@geekmidas/services` service methods — can call
+ * `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 }));
+ * ```
+ */
+declare function requestContext<TLogger extends Logger = Logger>(options: RequestContextOptions<TLogger>): MiddlewareObj<unknown, unknown, Error, Context>;
+/**
+ * Event augmentation applied by {@link addServices} / {@link withServices}:
+ * resolved services keyed by `serviceName`. Intersect it with your own event
+ * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.
+ */
+type EventServices<T extends Service[]> = {
+  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 }));
+ * ```
+ */
+declare function addServices<const T extends Service[]>(services: [...T], options: ServiceResolverOptions): MiddlewareObj<EventServices<T>, unknown, Error, Context>;
+/**
+ * Batteries-included Middy setup for service-backed handlers: returns a pair of
+ * middlewares — {@link requestContext} followed by {@link addServices} — so a
+ * 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 }));
+ * ```
+ */
+declare function withServices<const T extends Service[], TLogger extends Logger = Logger>(services: [...T], options: ServiceMiddlewareOptions<TLogger>): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
+//# sourceMappingURL=middy.d.ts.map
+//#endregion
+export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, ServiceResolverOptions, addServices, requestContext, withServices };
+//# sourceMappingURL=middy.d.mts.map

package/dist/middy.d.mts.map

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

package/dist/middy.mjs

@@ -0,0 +1,118 @@
+import { enterRequestContext, exitRequestContext } from "./context-C9DCrFWA.mjs";
+import { ServiceDiscovery } from "./ServiceDiscovery-DO_uDfuG.mjs";
+
+//#region src/middy.ts
+function deriveRequestId(options, event, context) {
+	return options.getRequestId?.(event, context) ?? context.awsRequestId;
+}
+function buildLogger(baseLogger, options, requestId, event, context) {
+	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 }));
+* ```
+*/
+function requestContext(options) {
+	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) {
+	return options.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser);
+}
+/**
+* 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 }));
+* ```
+*/
+function addServices(services, options) {
+	const discovery = resolveDiscovery(options);
+	return { before: async (request) => {
+		const resolved = await discovery.register(services);
+		const event = request.event;
+		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 }));
+* ```
+*/
+function withServices(services, options) {
+	return [requestContext(options), addServices(services, options)];
+}
+
+//#endregion
+export { addServices, requestContext, withServices };
+//# sourceMappingURL=middy.mjs.map

package/dist/middy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.mjs","names":["options: RequestContextOptions","event: unknown","context: Context","baseLogger: Logger","requestId: string","options: RequestContextOptions<TLogger>","options: ServiceResolverOptions","services: [...T]","options: ServiceMiddlewareOptions<TLogger>"],"sources":["../src/middy.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type { MiddlewareObj } from '@middy/core';\nimport type { Context } from 'aws-lambda';\nimport { enterRequestContext, exitRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Middy middleware helpers that bring `@geekmidas/services` request context and\n * service discovery to **standalone** Middy Lambda handlers — i.e. functions\n * that aren't built with the `@geekmidas/constructs` Function/Cron constructs\n * but still want `serviceContext.getLogger()` and resolved services.\n *\n * Why middleware (and not `runWithRequestContext`)? Middy runs `before → handler\n * → after` as sequential awaits in a single async context, so establishing the\n * context with `AsyncLocalStorage.enterWith` (via `enterRequestContext`) in a\n * `before` hook propagates to the handler. `after`/`onError` reset it.\n *\n * Teardown is best-effort: like `enterRequestContext`, the reset is observable\n * to code the handler reaches but not necessarily to the frame that invoked the\n * Middy handler. This is fine for Lambda, where each invocation runs in its own\n * fresh async context — `requestContext` always establishes a brand-new context\n * per invocation, so requests never inherit a previous invocation's logger.\n *\n * @module\n */\n\n/**\n * Options for {@link requestContext}. Generic over the logger type so a custom\n * logger that extends {@link Logger} is preserved rather than widened.\n */\nexport interface RequestContextOptions<TLogger extends Logger = Logger> {\n\t/**\n\t * Logger to derive the per-request child logger from. Required — the caller\n\t * decides which logger to use (there is no implicit default).\n\t */\n\tlogger: TLogger;\n\t/**\n\t * Derive the request id from the event/context.\n\t * Defaults to `context.awsRequestId` (always present in a Lambda invocation).\n\t */\n\tgetRequestId?: (event: unknown, context: Context) => string;\n\t/**\n\t * Extra bindings to attach to the per-request child logger.\n\t */\n\tbindings?: (event: unknown, context: Context) => Record<string, unknown>;\n}\n\n/**\n * Options for {@link addServices} — how services are resolved. No logger is\n * needed because resolving services doesn't establish a request context.\n */\nexport interface ServiceResolverOptions {\n\t/**\n\t * Environment parser used to build the {@link ServiceDiscovery}. Required —\n\t * the caller supplies the parser (there is no implicit `process.env` default).\n\t */\n\tenvParser: EnvironmentParser<{}>;\n\t/**\n\t * Explicit {@link ServiceDiscovery} to resolve services from. Takes\n\t * precedence over `envParser`.\n\t */\n\tserviceDiscovery?: ServiceDiscovery;\n}\n\n/**\n * Options for {@link withServices}: request context (logger) + service resolution.\n */\nexport type ServiceMiddlewareOptions<TLogger extends Logger = Logger> =\n\tRequestContextOptions<TLogger> & ServiceResolverOptions;\n\nfunction deriveRequestId(\n\toptions: RequestContextOptions,\n\tevent: unknown,\n\tcontext: Context,\n): string {\n\t// Lambda always populates context.awsRequestId; getRequestId can override it.\n\treturn options.getRequestId?.(event, context) ?? context.awsRequestId;\n}\n\nfunction buildLogger(\n\tbaseLogger: Logger,\n\toptions: RequestContextOptions,\n\trequestId: string,\n\tevent: unknown,\n\tcontext: Context,\n): Logger {\n\treturn baseLogger.child({\n\t\trequestId,\n\t\t...(options.bindings?.(event, context) ?? {}),\n\t});\n}\n\n/**\n * Middy middleware that establishes a request context for the handler so any\n * code it reaches — including `@geekmidas/services` service methods — can call\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * Use this on standalone functions that need request-scoped logging. To also\n * resolve services, pair it with {@link addServices}, or use\n * {@link withServices} which bundles both.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { serviceContext } from '@geekmidas/services';\n * import { requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async () => {\n *   serviceContext.getLogger().info('tick');\n * }).use(requestContext({ logger }));\n * ```\n */\nexport function requestContext<TLogger extends Logger = Logger>(\n\toptions: RequestContextOptions<TLogger>,\n): MiddlewareObj<unknown, unknown, Error, Context> {\n\tconst baseLogger = options.logger;\n\treturn {\n\t\tbefore: (request) => {\n\t\t\tconst { event, context } = request;\n\t\t\tconst requestId = deriveRequestId(options, event, context);\n\t\t\tconst logger = buildLogger(\n\t\t\t\tbaseLogger,\n\t\t\t\toptions,\n\t\t\t\trequestId,\n\t\t\t\tevent,\n\t\t\t\tcontext,\n\t\t\t);\n\t\t\tenterRequestContext({ logger, requestId, startTime: Date.now() });\n\t\t},\n\t\tafter: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t\tonError: () => {\n\t\t\texitRequestContext();\n\t\t},\n\t};\n}\n\nfunction resolveDiscovery(options: ServiceResolverOptions): ServiceDiscovery {\n\treturn (\n\t\toptions.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser)\n\t);\n}\n\n/**\n * Event augmentation applied by {@link addServices} / {@link withServices}:\n * resolved services keyed by `serviceName`. Intersect it with your own event\n * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.\n */\nexport type EventServices<T extends Service[]> = {\n\tservices: ServiceRecord<T>;\n};\n\n/**\n * Middy middleware that resolves an array of {@link Service}s via\n * {@link ServiceDiscovery} and attaches the resolved record to `event.services`\n * (keyed by each service's `serviceName`), matching how the `Function`/`Cron`\n * constructs expose services on the event.\n *\n * This middleware only resolves services; it does **not** establish a request\n * context. If your services read `serviceContext` (e.g. `getLogger()`), pair it\n * with {@link requestContext}, or use {@link withServices} which bundles both.\n *\n * Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto\n * `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { addServices, requestContext } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * })\n *   .use(requestContext())\n *   .use(addServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function addServices<const T extends Service[]>(\n\tservices: [...T],\n\toptions: ServiceResolverOptions,\n): MiddlewareObj<EventServices<T>, unknown, Error, Context> {\n\tconst discovery = resolveDiscovery(options);\n\n\treturn {\n\t\tbefore: async (request) => {\n\t\t\tconst resolved = await discovery.register(services);\n\t\t\tconst event = request.event as { services?: Record<string, unknown> };\n\t\t\t// Merge so chained addServices(...) calls accumulate on event.services.\n\t\t\tevent.services = { ...(event.services ?? {}), ...resolved };\n\t\t},\n\t};\n}\n\n/**\n * Batteries-included Middy setup for service-backed handlers: returns a pair of\n * middlewares — {@link requestContext} followed by {@link addServices} — so a\n * single `.use(withServices([...]))` gives the handler both a request context\n * and the resolved services on `event.services`.\n *\n * @example\n * ```ts\n * import middy from '@middy/core';\n * import { withServices } from '@geekmidas/services/middy';\n *\n * export const handler = middy(async (event) => {\n *   await event.services.database.users.deletePast();\n *   event.services.cache.clear();\n * }).use(withServices([databaseService, cacheService], { envParser }));\n * ```\n */\nexport function withServices<\n\tconst T extends Service[],\n\tTLogger extends Logger = Logger,\n>(\n\tservices: [...T],\n\toptions: ServiceMiddlewareOptions<TLogger>,\n): [\n\tMiddlewareObj<unknown, unknown, Error, Context>,\n\tMiddlewareObj<EventServices<T>, unknown, Error, Context>,\n] {\n\treturn [requestContext(options), addServices(services, options)];\n}\n"],"mappings":";;;;AAwEA,SAAS,gBACRA,SACAC,OACAC,SACS;AAET,QAAO,QAAQ,eAAe,OAAO,QAAQ,IAAI,QAAQ;AACzD;AAED,SAAS,YACRC,YACAH,SACAI,WACAH,OACAC,SACS;AACT,QAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,QAAQ,IAAI,CAAE;CAC5C,EAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,eACfG,SACkD;CAClD,MAAM,aAAa,QAAQ;AAC3B,QAAO;EACN,QAAQ,CAAC,YAAY;GACpB,MAAM,EAAE,OAAO,SAAS,GAAG;GAC3B,MAAM,YAAY,gBAAgB,SAAS,OAAO,QAAQ;GAC1D,MAAM,SAAS,YACd,YACA,SACA,WACA,OACA,QACA;AACD,uBAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,KAAK;GAAE,EAAC;EACjE;EACD,OAAO,MAAM;AACZ,uBAAoB;EACpB;EACD,SAAS,MAAM;AACd,uBAAoB;EACpB;CACD;AACD;AAED,SAAS,iBAAiBC,SAAmD;AAC5E,QACC,QAAQ,oBAAoB,iBAAiB,YAAY,QAAQ,UAAU;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCD,SAAgB,YACfC,UACAD,SAC2D;CAC3D,MAAM,YAAY,iBAAiB,QAAQ;AAE3C,QAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;EACnD,MAAM,QAAQ,QAAQ;AAEtB,QAAM,WAAW;GAAE,GAAI,MAAM,YAAY,CAAE;GAAG,GAAG;EAAU;CAC3D,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAgB,aAIfC,UACAC,SAIC;AACD,QAAO,CAAC,eAAe,QAAQ,EAAE,YAAY,UAAU,QAAQ,AAAC;AAChE"}

package/dist/trpc.cjs

@@ -0,0 +1,66 @@
+const require_context = require('./context-Cf2Ig5qr.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-m3XkNh32.cjs');
+const node_crypto = require_context.__toESM(require("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 ?? require_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 ?? (0, node_crypto.randomUUID)();
+			const startTime = ctx.startTime ?? Date.now();
+			return require_context.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 ?? (0, node_crypto.randomUUID)();
+		const startTime = ctx.startTime ?? Date.now();
+		return require_context.runWithRequestContext({
+			logger: ctx.logger,
+			requestId,
+			startTime
+		}, () => opts.next());
+	});
+}
+
+//#endregion
+exports.createRequestContextMiddleware = createRequestContextMiddleware;
+exports.createServicesMiddleware = createServicesMiddleware;
+//# sourceMappingURL=trpc.cjs.map