@geekmidas/services 1.0.4 → 1.1.0

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

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"}