@geekmidas/constructs 3.1.0 → 4.0.0

package/dist/{types-j0ti0JTY.d.mts → types-BDNGr7pv.d.mts}

@@ -6,4 +6,4 @@ type LowerHttpMethod<T extends HttpMethod> = Lowercase<T>;
 
 //#endregion
 export { HttpMethod, LowerHttpMethod, RemoveUndefined };
-//# sourceMappingURL=types-j0ti0JTY.d.mts.map
+//# sourceMappingURL=types-BDNGr7pv.d.mts.map

package/dist/{types-j0ti0JTY.d.mts.map → types-BDNGr7pv.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-j0ti0JTY.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,6BAAA,MACC,CADD,IACM,CADS,CACP,CADO,CAAA,SAAA,SAAA,GAAA,KAAA,GACwB,CADxB,GAC4B,CAD5B,CAC8B,CAD9B,CAAA,EAAA;AACd,KAGD,UAAA,GAHC,KAAA,GAAA,MAAA,GAAA,KAAA,GAAA,OAAA,GAAA,QAAA,GAAA,SAAA;AAAK,KAWN,eAXM,CAAA,UAWoB,UAXpB,CAAA,GAWkC,SAXlC,CAW4C,CAX5C,CAAA"}
+{"version":3,"file":"types-BDNGr7pv.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,6BAAA,MACC,CADD,IACM,CADS,CACP,CADO,CAAA,SAAA,SAAA,GAAA,KAAA,GACwB,CADxB,GAC4B,CAD5B,CAC8B,CAD9B,CAAA,EAAA;AACd,KAGD,UAAA,GAHC,KAAA,GAAA,MAAA,GAAA,KAAA,GAAA,OAAA,GAAA,QAAA,GAAA,SAAA;AAAK,KAWN,eAXM,CAAA,UAWoB,UAXpB,CAAA,GAWkC,SAXlC,CAW4C,CAX5C,CAAA"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-j0ti0JTY.mjs";
+import { HttpMethod, LowerHttpMethod, RemoveUndefined } from "./types-BDNGr7pv.mjs";
 export { HttpMethod, LowerHttpMethod, RemoveUndefined };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/constructs",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -74,16 +74,6 @@
         "default": "./dist/adaptors/hono.cjs"
       }
     },
-    "./trpc": {
-      "import": {
-        "types": "./dist/adaptors/trpc.d.mts",
-        "default": "./dist/adaptors/trpc.mjs"
-      },
-      "require": {
-        "types": "./dist/adaptors/trpc.d.cts",
-        "default": "./dist/adaptors/trpc.cjs"
-      }
-    },
     "./aws": {
       "import": {
         "types": "./dist/adaptors/aws.d.mts",
@@ -103,16 +93,6 @@
         "types": "./dist/adaptors/testing.d.cts",
         "default": "./dist/adaptors/testing.cjs"
       }
-    },
-    "./middy": {
-      "import": {
-        "types": "./dist/adaptors/middy.d.mts",
-        "default": "./dist/adaptors/middy.mjs"
-      },
-      "require": {
-        "types": "./dist/adaptors/middy.d.cts",
-        "default": "./dist/adaptors/middy.cjs"
-      }
     }
   },
   "repository": {
@@ -141,7 +121,6 @@
     "@types/lodash.uniqby": "~4.7.9",
     "@types/pg": "~8.15.6",
     "@types/qs": "~6.15.0",
-    "@trpc/server": "~11.16.0",
     "better-auth": "~1.4.18",
     "kysely": "~0.28.8",
     "pg": "~8.16.3",
@@ -149,32 +128,31 @@
     "zod": "~4.1.13",
     "@geekmidas/audit": "^2.0.1",
     "@geekmidas/db": "^1.0.2",
-    "@geekmidas/events": "^1.1.4",
     "@geekmidas/cache": "^1.1.1",
-    "@geekmidas/logger": "^1.0.2",
-    "@geekmidas/schema": "^1.0.2",
-    "@geekmidas/rate-limit": "^2.0.1",
     "@geekmidas/envkit": "^1.0.7",
     "@geekmidas/errors": "^1.0.1",
-    "@geekmidas/testkit": "^1.0.9",
-    "@geekmidas/services": "^1.0.4"
+    "@geekmidas/events": "^1.1.4",
+    "@geekmidas/logger": "^1.0.2",
+    "@geekmidas/rate-limit": "^3.0.0",
+    "@geekmidas/schema": "^1.0.2",
+    "@geekmidas/services": "^1.1.0",
+    "@geekmidas/testkit": "^2.0.0"
   },
   "peerDependencies": {
     "@middy/core": ">=6.3.1",
-    "@trpc/server": ">=11.0.0",
     "@types/aws-lambda": ">=8.10.92",
     "hono": ">=4.8.2",
     "msw": ">=2.0.0",
-    "@geekmidas/db": "^1.0.2",
     "@geekmidas/audit": "^2.0.1",
     "@geekmidas/cache": "^1.1.1",
+    "@geekmidas/db": "^1.0.2",
     "@geekmidas/envkit": "^1.0.7",
-    "@geekmidas/events": "^1.1.4",
     "@geekmidas/errors": "^1.0.1",
+    "@geekmidas/events": "^1.1.4",
     "@geekmidas/logger": "^1.0.2",
+    "@geekmidas/rate-limit": "^3.0.0",
     "@geekmidas/schema": "^1.0.2",
-    "@geekmidas/rate-limit": "^2.0.1",
-    "@geekmidas/services": "^1.0.4"
+    "@geekmidas/services": "^1.1.0"
   },
   "peerDependenciesMeta": {
     "@geekmidas/audit": {
@@ -210,9 +188,6 @@
     "@middy/core": {
       "optional": true
     },
-    "@trpc/server": {
-      "optional": true
-    },
     "@types/aws-lambda": {
       "optional": true
     },

package/src/crons/AWSScheduledFunction.ts

@@ -54,6 +54,7 @@ export class AWSScheduledFunction<
 	TDatabase,
 	TDatabaseServiceName
 > {
+	// biome-ignore lint/complexity/noUselessConstructor: narrows the inherited `Function` parameter to `Cron` for a clearer public API
 	constructor(
 		envParser: EnvironmentParser<{}>,
 		cron: Cron<

package/src/endpoints/HonoEndpointAdaptor.ts

@@ -614,7 +614,6 @@ export class HonoEndpoint<
 							) {
 								c.header('content-type', endpoint.responseType);
 							}
-							// @ts-expect-error
 							return c.body(output as any, status);
 						} catch (validationError: any) {
 							logger.error(validationError, 'Output validation failed');

package/tsdown.config.ts

@@ -11,8 +11,6 @@ export default defineConfig({
 		'src/adaptors/hono.ts',
 		'src/adaptors/aws.ts',
 		'src/adaptors/testing.ts',
-		'src/adaptors/trpc.ts',
-		'src/adaptors/middy.ts',
 	],
 	clean: true,
 	outDir: 'dist',

package/dist/adaptors/middy.cjs

@@ -1,120 +0,0 @@
-const require_chunk = require('../chunk-DWy1uDak.cjs');
-const require_lodash$1 = require('../lodash-CM4k4sZD.cjs');
-const __geekmidas_services = require_chunk.__toESM(require("@geekmidas/services"));
-const __geekmidas_logger_console = require_chunk.__toESM(require("@geekmidas/logger/console"));
-const __geekmidas_envkit = require_chunk.__toESM(require("@geekmidas/envkit"));
-
-//#region src/adaptors/middy.ts
-var import_lodash = require_chunk.__toESM(require_lodash$1.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 __geekmidas_logger_console.ConsoleLogger();
-	return {
-		before: (request) => {
-			const { event, context } = request;
-			const requestId = deriveRequestId(options, event, context);
-			const logger = buildLogger(baseLogger, options, requestId, event, context);
-			(0, __geekmidas_services.enterRequestContext)({
-				logger,
-				requestId,
-				startTime: Date.now()
-			});
-		},
-		after: () => {
-			(0, __geekmidas_services.exitRequestContext)();
-		},
-		onError: () => {
-			(0, __geekmidas_services.exitRequestContext)();
-		}
-	};
-}
-function resolveDiscovery(options) {
-	return options.serviceDiscovery ?? __geekmidas_services.ServiceDiscovery.getInstance(options.envParser ?? new __geekmidas_envkit.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
-exports.addServices = addServices;
-exports.requestContext = requestContext;
-exports.withServices = withServices;
-//# sourceMappingURL=middy.cjs.map

package/dist/adaptors/middy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"middy.cjs","names":["options: RequestContextOptions","event: unknown","context: Context | undefined","baseLogger: Logger","requestId: string","ConsoleLogger","options: ServiceMiddlewareOptions","EnvironmentParser","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,IAAIK;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,iDAAoB;IAAE;IAAQ;IAAW,WAAW,KAAK,KAAK;GAAE,EAAC;EACjE;EACD,OAAO,MAAM;AACZ,iDAAoB;EACpB;EACD,SAAS,MAAM;AACd,iDAAoB;EACpB;CACD;AACD;AAED,SAAS,iBAAiBC,SAAqD;AAC9E,QACC,QAAQ,oBACR,sCAAiB,YAChB,QAAQ,aAAa,IAAIC,qCAAkB,EAAE,GAAG,QAAQ,IAAK,GAC7D;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCD,SAAgB,YACfC,UACAF,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,aACfE,UACAF,UAAoC,CAAE,GAIrC;AACD,QAAO,CAAC,eAAe,QAAQ,EAAE,YAAY,UAAU,QAAQ,AAAC;AAChE"}

package/dist/adaptors/middy.d.cts

@@ -1,139 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,139 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}