@geekmidas/constructs 3.0.13 → 3.1.0

package/dist/adaptors/middy.d.cts

@@ -0,0 +1,139 @@
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Logger } from "@geekmidas/logger";
+import { Service, ServiceDiscovery, ServiceRecord } from "@geekmidas/services";
+import { Context } from "aws-lambda";
+import { MiddlewareObj } from "@middy/core";
+
+//#region src/adaptors/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 shared by the request-context-aware middlewares.
+ */
+interface RequestContextOptions {
+  /**
+   * Base logger to derive the per-request child logger from.
+   * Defaults to a new {@link ConsoleLogger}.
+   */
+  logger?: Logger;
+  /**
+   * Derive the request id from the event/context.
+   * Defaults to `context.awsRequestId`, falling back to `crypto.randomUUID()`.
+   */
+  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 the service-resolving middlewares.
+ */
+interface ServiceMiddlewareOptions extends RequestContextOptions {
+  /**
+   * Environment parser used to build the default {@link ServiceDiscovery}.
+   * Defaults to `new EnvironmentParser({ ...process.env })`.
+   */
+  envParser?: EnvironmentParser<{}>;
+  /**
+   * Explicit {@link ServiceDiscovery} to resolve services from. Takes
+   * precedence over `envParser`.
+   */
+  serviceDiscovery?: ServiceDiscovery;
+}
+/**
+ * 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/constructs/middy';
+ *
+ * export const handler = middy(async () => {
+ *   serviceContext.getLogger().info('tick');
+ * }).use(requestContext());
+ * ```
+ */
+declare function requestContext(options?: RequestContextOptions): 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/constructs/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?: ServiceMiddlewareOptions): 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/constructs/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[]>(services: [...T], options?: ServiceMiddlewareOptions): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
+//# sourceMappingURL=middy.d.ts.map
+//#endregion
+export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, addServices, requestContext, withServices };
+//# sourceMappingURL=middy.d.cts.map

package/dist/adaptors/middy.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.d.cts","names":[],"sources":["../../src/adaptors/middy.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqCA;;;;;;AAcwD;AAMxD;;;;;AAAuE;AA0DvE;;;;;;AAEgB;AAsCJ,UAtHK,qBAAA,CAsHQ;EAAA;;;;EACD,MAAA,CAAA,EAlHd,MAkHc;EA6BR;;;;EACA,YACN,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA5IgC,OA4IhC,EAAA,GAAA,MAAA;EAA6B;;;EACU,QAAE,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EAzIb,OAyIa,EAAA,GAzID,MAyIC,CAAA,MAAA,EAAA,OAAA,CAAA;;AAAnC;AA4BhB;;AAA6C,UA/J5B,wBAAA,SAAiC,qBA+JL,CAAA;EAAO;;;;EAIL,SAA9C,CAAA,EA9JY,iBA8JZ,CAAA,CAAA,CAAA,CAAA;EAAa;;;;EAC0C,gBAAvD,CAAA,EA1JmB,gBA0JnB;AAAa;;;;;;;;;;;;;;;;;;;;;iBA1GE,cAAA,WACN,wBACP,gCAAgC,OAAO;;;;;;KAsC9B,wBAAwB;YACzB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BT,4BAA4B,yBAC7B,cACL,2BACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;iBA4BnC,6BAA6B,yBAC9B,cACL,4BAET,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}

package/dist/adaptors/middy.d.mts

@@ -0,0 +1,139 @@
+import { Service, ServiceDiscovery, ServiceRecord } from "@geekmidas/services";
+import { MiddlewareObj } from "@middy/core";
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Logger } from "@geekmidas/logger";
+import { Context } from "aws-lambda";
+
+//#region src/adaptors/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 shared by the request-context-aware middlewares.
+ */
+interface RequestContextOptions {
+  /**
+   * Base logger to derive the per-request child logger from.
+   * Defaults to a new {@link ConsoleLogger}.
+   */
+  logger?: Logger;
+  /**
+   * Derive the request id from the event/context.
+   * Defaults to `context.awsRequestId`, falling back to `crypto.randomUUID()`.
+   */
+  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 the service-resolving middlewares.
+ */
+interface ServiceMiddlewareOptions extends RequestContextOptions {
+  /**
+   * Environment parser used to build the default {@link ServiceDiscovery}.
+   * Defaults to `new EnvironmentParser({ ...process.env })`.
+   */
+  envParser?: EnvironmentParser<{}>;
+  /**
+   * Explicit {@link ServiceDiscovery} to resolve services from. Takes
+   * precedence over `envParser`.
+   */
+  serviceDiscovery?: ServiceDiscovery;
+}
+/**
+ * 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/constructs/middy';
+ *
+ * export const handler = middy(async () => {
+ *   serviceContext.getLogger().info('tick');
+ * }).use(requestContext());
+ * ```
+ */
+declare function requestContext(options?: RequestContextOptions): 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/constructs/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?: ServiceMiddlewareOptions): 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/constructs/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[]>(services: [...T], options?: ServiceMiddlewareOptions): [MiddlewareObj<unknown, unknown, Error, Context>, MiddlewareObj<EventServices<T>, unknown, Error, Context>];
+//# sourceMappingURL=middy.d.ts.map
+//#endregion
+export { EventServices, RequestContextOptions, ServiceMiddlewareOptions, addServices, requestContext, withServices };
+//# sourceMappingURL=middy.d.mts.map

package/dist/adaptors/middy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.d.mts","names":[],"sources":["../../src/adaptors/middy.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAqCA;;;;;;AAcwD;AAMxD;;;;;AAAuE;AA0DvE;;;;;;AAEgB;AAsCJ,UAtHK,qBAAA,CAsHQ;EAAA;;;;EACD,MAAA,CAAA,EAlHd,MAkHc;EA6BR;;;;EACA,YACN,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EA5IgC,OA4IhC,EAAA,GAAA,MAAA;EAA6B;;;EACU,QAAE,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EAzIb,OAyIa,EAAA,GAzID,MAyIC,CAAA,MAAA,EAAA,OAAA,CAAA;;AAAnC;AA4BhB;;AAA6C,UA/J5B,wBAAA,SAAiC,qBA+JL,CAAA;EAAO;;;;EAIL,SAA9C,CAAA,EA9JY,iBA8JZ,CAAA,CAAA,CAAA,CAAA;EAAa;;;;EAC0C,gBAAvD,CAAA,EA1JmB,gBA0JnB;AAAa;;;;;;;;;;;;;;;;;;;;;iBA1GE,cAAA,WACN,wBACP,gCAAgC,OAAO;;;;;;KAsC9B,wBAAwB;YACzB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BT,4BAA4B,yBAC7B,cACL,2BACP,cAAc,cAAc,aAAa,OAAO;;;;;;;;;;;;;;;;;;iBA4BnC,6BAA6B,yBAC9B,cACL,4BAET,gCAAgC,OAAO,UACvC,cAAc,cAAc,aAAa,OAAO"}

package/dist/adaptors/middy.mjs

@@ -0,0 +1,118 @@
+import { __toESM } from "../chunk-B4qE4VCv.mjs";
+import { require_lodash } from "../lodash-DiUeLbQy.mjs";
+import { ServiceDiscovery, enterRequestContext, exitRequestContext } from "@geekmidas/services";
+import { ConsoleLogger } from "@geekmidas/logger/console";
+import { EnvironmentParser } from "@geekmidas/envkit";
+
+//#region src/adaptors/middy.ts
+var import_lodash = __toESM(require_lodash(), 1);
+function deriveRequestId(options, event, context) {
+	return options.getRequestId?.(event, context) ?? context?.awsRequestId ?? crypto.randomUUID();
+}
+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/constructs/middy';
+*
+* export const handler = middy(async () => {
+*   serviceContext.getLogger().info('tick');
+* }).use(requestContext());
+* ```
+*/
+function requestContext(options = {}) {
+	const baseLogger = options.logger ?? new ConsoleLogger();
+	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 ?? new EnvironmentParser({ ...process.env }));
+}
+/**
+* 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/constructs/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);
+		(0, import_lodash.default)(request, "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/constructs/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/adaptors/middy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middy.mjs","names":["options: RequestContextOptions","event: unknown","context: Context | undefined","baseLogger: Logger","requestId: string","options: ServiceMiddlewareOptions","services: [...T]"],"sources":["../../src/adaptors/middy.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport { ConsoleLogger } from '@geekmidas/logger/console';\nimport {\n\tenterRequestContext,\n\texitRequestContext,\n\ttype Service,\n\tServiceDiscovery,\n\ttype ServiceRecord,\n} from '@geekmidas/services';\nimport type { MiddlewareObj } from '@middy/core';\nimport type { Context } from 'aws-lambda';\nimport set from 'lodash.set';\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 shared by the request-context-aware middlewares.\n */\nexport interface RequestContextOptions {\n\t/**\n\t * Base logger to derive the per-request child logger from.\n\t * Defaults to a new {@link ConsoleLogger}.\n\t */\n\tlogger?: Logger;\n\t/**\n\t * Derive the request id from the event/context.\n\t * Defaults to `context.awsRequestId`, falling back to `crypto.randomUUID()`.\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 the service-resolving middlewares.\n */\nexport interface ServiceMiddlewareOptions extends RequestContextOptions {\n\t/**\n\t * Environment parser used to build the default {@link ServiceDiscovery}.\n\t * Defaults to `new EnvironmentParser({ ...process.env })`.\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\nfunction deriveRequestId(\n\toptions: RequestContextOptions,\n\tevent: unknown,\n\tcontext: Context | undefined,\n): string {\n\treturn (\n\t\toptions.getRequestId?.(event, context as Context) ??\n\t\tcontext?.awsRequestId ??\n\t\tcrypto.randomUUID()\n\t);\n}\n\nfunction buildLogger(\n\tbaseLogger: Logger,\n\toptions: RequestContextOptions,\n\trequestId: string,\n\tevent: unknown,\n\tcontext: Context | undefined,\n): Logger {\n\treturn baseLogger.child({\n\t\trequestId,\n\t\t...(options.bindings?.(event, context as 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/constructs/middy';\n *\n * export const handler = middy(async () => {\n *   serviceContext.getLogger().info('tick');\n * }).use(requestContext());\n * ```\n */\nexport function requestContext(\n\toptions: RequestContextOptions = {},\n): MiddlewareObj<unknown, unknown, Error, Context> {\n\tconst baseLogger = options.logger ?? new ConsoleLogger();\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: ServiceMiddlewareOptions): ServiceDiscovery {\n\treturn (\n\t\toptions.serviceDiscovery ??\n\t\tServiceDiscovery.getInstance(\n\t\t\toptions.envParser ?? new EnvironmentParser({ ...process.env }),\n\t\t)\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/constructs/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: ServiceMiddlewareOptions = {},\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\tset(request, '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/constructs/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<const T extends Service[]>(\n\tservices: [...T],\n\toptions: ServiceMiddlewareOptions = {},\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":";;;;;;;;AAsEA,SAAS,gBACRA,SACAC,OACAC,SACS;AACT,QACC,QAAQ,eAAe,OAAO,QAAmB,IACjD,SAAS,gBACT,OAAO,YAAY;AAEpB;AAED,SAAS,YACRC,YACAH,SACAI,WACAH,OACAC,SACS;AACT,QAAO,WAAW,MAAM;EACvB;EACA,GAAI,QAAQ,WAAW,OAAO,QAAmB,IAAI,CAAE;CACvD,EAAC;AACF;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,eACfF,UAAiC,CAAE,GACe;CAClD,MAAM,aAAa,QAAQ,UAAU,IAAI;AACzC,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,iBAAiBK,SAAqD;AAC9E,QACC,QAAQ,oBACR,iBAAiB,YAChB,QAAQ,aAAa,IAAI,kBAAkB,EAAE,GAAG,QAAQ,IAAK,GAC7D;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCD,SAAgB,YACfC,UACAD,UAAoC,CAAE,GACqB;CAC3D,MAAM,YAAY,iBAAiB,QAAQ;AAE3C,QAAO,EACN,QAAQ,OAAO,YAAY;EAC1B,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;AACnD,6BAAI,SAAS,kBAAkB,SAAS;CACxC,EACD;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAgB,aACfC,UACAD,UAAoC,CAAE,GAIrC;AACD,QAAO,CAAC,eAAe,QAAQ,EAAE,YAAY,UAAU,QAAQ,AAAC;AAChE"}

package/dist/adaptors/testing.cjs

@@ -1,9 +1,11 @@
 const require_chunk = require('../chunk-DWy1uDak.cjs');
 require('../Construct-DXfLPGwg.cjs');
-const require_lazyAccessors = require('../lazyAccessors-zNy6P6Cg.cjs');
-const require_functions = require('../functions-CX21wstW.cjs');
-const require_processAudits = require('../processAudits-B_a9bDPs.cjs');
-const require_HonoEndpointAdaptor = require('../HonoEndpointAdaptor-DFdgCwYU.cjs');
+const require_functions = require('../functions-_OAiwGYh.cjs');
+const require_publisher = require('../publisher-BZgcrVPy.cjs');
+require('../lodash-CM4k4sZD.cjs');
+const require_lazyAccessors = require('../lazyAccessors-B4rtX68K.cjs');
+const require_processAudits = require('../processAudits-CPcACKCA.cjs');
+const require_HonoEndpointAdaptor = require('../HonoEndpointAdaptor-CNIsjEw-.cjs');
 const __geekmidas_errors = require_chunk.__toESM(require("@geekmidas/errors"));
 const __geekmidas_services = require_chunk.__toESM(require("@geekmidas/services"));
 const __geekmidas_audit = require_chunk.__toESM(require("@geekmidas/audit"));
@@ -253,7 +255,7 @@ var TestEndpointAdaptor = class TestEndpointAdaptor {
 			}, { db: rawDb });
 			const { output, metadata } = result;
 			ctx.publisher && await this.serviceDiscovery.register([ctx.publisher]);
-			await require_lazyAccessors.publishConstructEvents(this.endpoint, output, this.serviceDiscovery);
+			await require_publisher.publishConstructEvents(this.endpoint, output, this.serviceDiscovery);
 			const headers = { ...metadata.headers || {} };
 			if (metadata.cookies && metadata.cookies.size > 0) {
 				const setCookieValues = [];
@@ -334,7 +336,7 @@ var TestFunctionAdaptor = class TestFunctionAdaptor {
 					await auditor.flush();
 				}
 			}
-			await require_lazyAccessors.publishEvents(logger, this.serviceDiscovery, this.fn.events, output, this.fn.publisherService);
+			await require_publisher.publishEvents(logger, this.serviceDiscovery, this.fn.events, output, this.fn.publisherService);
 			return output;
 		});
 	}
@@ -375,7 +377,7 @@ var TestSubscriberAdaptor = class TestSubscriberAdaptor {
 				if (validationResult.issues) throw new Error("Subscriber output validation failed");
 				output = validationResult.value;
 			}
-			await require_lazyAccessors.publishEvents(logger, this.serviceDiscovery, this.subscriber.events, output, this.subscriber.publisherService);
+			await require_publisher.publishEvents(logger, this.serviceDiscovery, this.subscriber.events, output, this.subscriber.publisherService);
 			return output;
 		});
 	}