lambda-reactor 1.0.0 → 1.0.1

package/{src/build-handlers.ts → dist/build-handlers.d.ts}

@@ -1,12 +1,9 @@
-import {join} from "path"
-
-import type {IFunction} from "aws-cdk-lib/aws-lambda"
+import type { IFunction } from "aws-cdk-lib/aws-lambda";
 /**
  * A factory function that constructs an AWS Lambda {@link IFunction} from a
  * source-file entry path and a logical identifier string.
  */
-export type FunctionFactory = (entry: string, id: string) => IFunction
-
+export type FunctionFactory = (entry: string, id: string) => IFunction;
 /**
  * Builds a map of route paths to Lambda functions by invoking `factory` for
  * each path.
@@ -17,14 +14,4 @@ export type FunctionFactory = (entry: string, id: string) => IFunction
  * @param paths   - Array of route path strings (e.g. `["/users", "/items"]`).
  * @param factory - {@link FunctionFactory} used to construct each Lambda function.
  */
-export function buildHandlers<TPaths extends string>(
-    paths: TPaths[],
-    factory: FunctionFactory,
-): Record<TPaths, IFunction> {
-    return Object.fromEntries(
-        paths.map((path) => [
-            path,
-            factory(join(process.cwd(), "src", `${path}.ts`), path),
-        ]),
-    ) as Record<TPaths, IFunction>
-}
+export declare function buildHandlers<TPaths extends string>(paths: TPaths[], factory: FunctionFactory): Record<TPaths, IFunction>;

package/dist/build-handlers.js

@@ -0,0 +1,13 @@
+// src/build-handlers.ts
+import { join } from "path";
+function buildHandlers(paths, factory) {
+  return Object.fromEntries(paths.map((path) => [
+    path,
+    factory(join(process.cwd(), "src", `${path}.ts`), path)
+  ]));
+}
+export {
+  buildHandlers
+};
+
+//# debugId=824ABC51E353D52E64756E2164756E21

package/dist/build-handlers.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/build-handlers.ts"],
+  "sourcesContent": [
+    "import {join} from \"path\"\n\nimport type {IFunction} from \"aws-cdk-lib/aws-lambda\"\n/**\n * A factory function that constructs an AWS Lambda {@link IFunction} from a\n * source-file entry path and a logical identifier string.\n */\nexport type FunctionFactory = (entry: string, id: string) => IFunction\n\n/**\n * Builds a map of route paths to Lambda functions by invoking `factory` for\n * each path.\n *\n * The `entry` passed to `factory` is the absolute path\n * `<cwd>/src/<path>.ts`, and the `id` is the route path string itself.\n *\n * @param paths   - Array of route path strings (e.g. `[\"/users\", \"/items\"]`).\n * @param factory - {@link FunctionFactory} used to construct each Lambda function.\n */\nexport function buildHandlers<TPaths extends string>(\n    paths: TPaths[],\n    factory: FunctionFactory,\n): Record<TPaths, IFunction> {\n    return Object.fromEntries(\n        paths.map((path) => [\n            path,\n            factory(join(process.cwd(), \"src\", `${path}.ts`), path),\n        ]),\n    ) as Record<TPaths, IFunction>\n}\n"
+  ],
+  "mappings": ";AAAA;AAmBO,SAAS,aAAoC,CAChD,OACA,SACyB;AAAA,EACzB,OAAO,OAAO,YACV,MAAM,IAAI,CAAC,SAAS;AAAA,IAChB;AAAA,IACA,QAAQ,KAAK,QAAQ,IAAI,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI;AAAA,EAC1D,CAAC,CACL;AAAA;",
+  "debugId": "824ABC51E353D52E64756E2164756E21",
+  "names": []
+}

package/dist/dispatch.d.ts

@@ -0,0 +1,21 @@
+import { RouteHandler } from "#src/method";
+import type { APIGatewayProxyEvent, Context } from "aws-lambda";
+/**
+ * Executes a single {@link RouteHandler} for an incoming Lambda proxy event.
+ *
+ * Processing order:
+ * 1. Parse `event.body` as JSON when possible.
+ * 2. Validate the body against `route.bodySchema` (Zod); return `400` on
+ *    failure.
+ * 3. Invoke `route.callback` with the validated body, event, and context.
+ * 4. If the callback returns a {@link Response}, optionally validate its body
+ *    against `route.outputSchema`; return `500` on failure.
+ * 5. If the callback returns a plain value, wrap it in a `200 JSON` response,
+ *    optionally validating against `route.outputSchema`.
+ * 6. Apply all middlewares left-to-right before returning.
+ *
+ * @param route   - The route handler to execute.
+ * @param event   - Raw API Gateway proxy event.
+ * @param context - Lambda execution context.
+ */
+export declare function dispatch(route: RouteHandler, event: APIGatewayProxyEvent, context: Context): Promise<import("aws-lambda").APIGatewayProxyResult>;

package/dist/dispatch.js

@@ -0,0 +1,58 @@
+// src/dispatch.ts
+import { logError } from "#src/logger";
+import { Response } from "#src/response";
+import { z } from "zod";
+import { applyMiddlewares } from "./middleware";
+async function dispatch(route, event, context) {
+  let body;
+  try {
+    body = event.body ? JSON.parse(event.body) : undefined;
+  } catch (error) {
+    if (error instanceof Error) {
+      return Response.text(400, error.message).toAPIGatewayProxyResult();
+    }
+    throw error;
+  }
+  if (route.bodySchema) {
+    const parsed = route.bodySchema.safeParse(body);
+    if (!parsed.success) {
+      return Response.text(400, z.treeifyError(parsed.error).errors.join(`
+`)).toAPIGatewayProxyResult();
+    }
+    body = parsed.data;
+  }
+  if (!route.callback) {
+    const err = new Error("Route has no handler defined");
+    logError(err);
+    return Response.text(500, err.message).toAPIGatewayProxyResult();
+  }
+  const cb = route.callback;
+  const result = await cb({ body, event, context });
+  if (result instanceof Response) {
+    if (route.outputSchema) {
+      const parsed = route.outputSchema.safeParse(result.body);
+      if (!parsed.success) {
+        logError(parsed.error);
+        return Response.text(500, z.treeifyError(parsed.error).errors.join(`
+`)).toAPIGatewayProxyResult();
+      }
+      result.body = parsed.data;
+    }
+    return applyMiddlewares(result.toAPIGatewayProxyResult(), route);
+  }
+  if (route.outputSchema) {
+    const parsed = route.outputSchema.safeParse(result);
+    if (!parsed.success) {
+      logError(parsed.error);
+      return Response.text(500, z.treeifyError(parsed.error).errors.join(`
+`)).toAPIGatewayProxyResult();
+    }
+    return applyMiddlewares(Response.json(200, parsed.data).toAPIGatewayProxyResult(), route);
+  }
+  return applyMiddlewares(Response.json(200, result).toAPIGatewayProxyResult(), route);
+}
+export {
+  dispatch
+};
+
+//# debugId=618322748EAF9B8C64756E2164756E21

package/dist/dispatch.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/dispatch.ts"],
+  "sourcesContent": [
+    "import {logError} from \"#src/logger\"\nimport {RouteHandler} from \"#src/method\"\nimport {Response} from \"#src/response\"\nimport type {APIGatewayProxyEvent, Context} from \"aws-lambda\"\nimport {z} from \"zod\"\n\nimport {applyMiddlewares} from \"./middleware\"\n\n/**\n * Executes a single {@link RouteHandler} for an incoming Lambda proxy event.\n *\n * Processing order:\n * 1. Parse `event.body` as JSON when possible.\n * 2. Validate the body against `route.bodySchema` (Zod); return `400` on\n *    failure.\n * 3. Invoke `route.callback` with the validated body, event, and context.\n * 4. If the callback returns a {@link Response}, optionally validate its body\n *    against `route.outputSchema`; return `500` on failure.\n * 5. If the callback returns a plain value, wrap it in a `200 JSON` response,\n *    optionally validating against `route.outputSchema`.\n * 6. Apply all middlewares left-to-right before returning.\n *\n * @param route   - The route handler to execute.\n * @param event   - Raw API Gateway proxy event.\n * @param context - Lambda execution context.\n */\nexport async function dispatch(\n    route: RouteHandler,\n    event: APIGatewayProxyEvent,\n    context: Context,\n) {\n    let body\n    try {\n        body = event.body ? JSON.parse(event.body) : undefined\n    } catch (error) {\n        if (error instanceof Error) {\n            return Response.text(400, error.message).toAPIGatewayProxyResult()\n        }\n        throw error\n    }\n    if (route.bodySchema) {\n        const parsed = route.bodySchema.safeParse(body)\n        if (!parsed.success) {\n            return Response.text(\n                400,\n                z.treeifyError(parsed.error).errors.join(\"\\n\"),\n            ).toAPIGatewayProxyResult()\n        }\n        body = parsed.data\n    }\n    if (!route.callback) {\n        const err = new Error(\"Route has no handler defined\")\n        logError(err)\n        return Response.text(500, err.message).toAPIGatewayProxyResult()\n    }\n    const cb = route.callback as (props: {\n        body: unknown\n        event: APIGatewayProxyEvent\n        context: Context\n    }) => Promise<unknown>\n    const result = await cb({body, event, context})\n    if (result instanceof Response) {\n        if (route.outputSchema) {\n            const parsed = route.outputSchema.safeParse(result.body)\n            if (!parsed.success) {\n                logError(parsed.error)\n                return Response.text(\n                    500,\n                    z.treeifyError(parsed.error).errors.join(\"\\n\"),\n                ).toAPIGatewayProxyResult()\n            }\n            result.body = parsed.data\n        }\n        return applyMiddlewares(result.toAPIGatewayProxyResult(), route)\n    }\n    if (route.outputSchema) {\n        const parsed = route.outputSchema.safeParse(result)\n        if (!parsed.success) {\n            logError(parsed.error)\n            return Response.text(\n                500,\n                z.treeifyError(parsed.error).errors.join(\"\\n\"),\n            ).toAPIGatewayProxyResult()\n        }\n        return applyMiddlewares(\n            Response.json(200, parsed.data).toAPIGatewayProxyResult(),\n            route,\n        )\n    }\n    return applyMiddlewares(Response.json(200, result).toAPIGatewayProxyResult(), route)\n}\n"
+  ],
+  "mappings": ";AAAA;AAEA;AAEA;AAEA;AAoBA,eAAsB,QAAQ,CAC1B,OACA,OACA,SACF;AAAA,EACE,IAAI;AAAA,EACJ,IAAI;AAAA,IACA,OAAO,MAAM,OAAO,KAAK,MAAM,MAAM,IAAI,IAAI;AAAA,IAC/C,OAAO,OAAO;AAAA,IACZ,IAAI,iBAAiB,OAAO;AAAA,MACxB,OAAO,SAAS,KAAK,KAAK,MAAM,OAAO,EAAE,wBAAwB;AAAA,IACrE;AAAA,IACA,MAAM;AAAA;AAAA,EAEV,IAAI,MAAM,YAAY;AAAA,IAClB,MAAM,SAAS,MAAM,WAAW,UAAU,IAAI;AAAA,IAC9C,IAAI,CAAC,OAAO,SAAS;AAAA,MACjB,OAAO,SAAS,KACZ,KACA,EAAE,aAAa,OAAO,KAAK,EAAE,OAAO,KAAK;AAAA,CAAI,CACjD,EAAE,wBAAwB;AAAA,IAC9B;AAAA,IACA,OAAO,OAAO;AAAA,EAClB;AAAA,EACA,IAAI,CAAC,MAAM,UAAU;AAAA,IACjB,MAAM,MAAM,IAAI,MAAM,8BAA8B;AAAA,IACpD,SAAS,GAAG;AAAA,IACZ,OAAO,SAAS,KAAK,KAAK,IAAI,OAAO,EAAE,wBAAwB;AAAA,EACnE;AAAA,EACA,MAAM,KAAK,MAAM;AAAA,EAKjB,MAAM,SAAS,MAAM,GAAG,EAAC,MAAM,OAAO,QAAO,CAAC;AAAA,EAC9C,IAAI,kBAAkB,UAAU;AAAA,IAC5B,IAAI,MAAM,cAAc;AAAA,MACpB,MAAM,SAAS,MAAM,aAAa,UAAU,OAAO,IAAI;AAAA,MACvD,IAAI,CAAC,OAAO,SAAS;AAAA,QACjB,SAAS,OAAO,KAAK;AAAA,QACrB,OAAO,SAAS,KACZ,KACA,EAAE,aAAa,OAAO,KAAK,EAAE,OAAO,KAAK;AAAA,CAAI,CACjD,EAAE,wBAAwB;AAAA,MAC9B;AAAA,MACA,OAAO,OAAO,OAAO;AAAA,IACzB;AAAA,IACA,OAAO,iBAAiB,OAAO,wBAAwB,GAAG,KAAK;AAAA,EACnE;AAAA,EACA,IAAI,MAAM,cAAc;AAAA,IACpB,MAAM,SAAS,MAAM,aAAa,UAAU,MAAM;AAAA,IAClD,IAAI,CAAC,OAAO,SAAS;AAAA,MACjB,SAAS,OAAO,KAAK;AAAA,MACrB,OAAO,SAAS,KACZ,KACA,EAAE,aAAa,OAAO,KAAK,EAAE,OAAO,KAAK;AAAA,CAAI,CACjD,EAAE,wBAAwB;AAAA,IAC9B;AAAA,IACA,OAAO,iBACH,SAAS,KAAK,KAAK,OAAO,IAAI,EAAE,wBAAwB,GACxD,KACJ;AAAA,EACJ;AAAA,EACA,OAAO,iBAAiB,SAAS,KAAK,KAAK,MAAM,EAAE,wBAAwB,GAAG,KAAK;AAAA;",
+  "debugId": "618322748EAF9B8C64756E2164756E21",
+  "names": []
+}

package/dist/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `true` when any of the conventional environment variables
+ * (`NODE_ENV`, `STAGE`, `ENV`, `ENVIRONMENT`) indicate a production
+ * deployment.
+ */
+export declare function isProduction(): boolean;

package/dist/env.js

@@ -0,0 +1,13 @@
+// src/env.ts
+var PROD_VALUES = new Set(["production", "prod"]);
+function isProductionValue(value) {
+  return value !== undefined && PROD_VALUES.has(value.toLowerCase());
+}
+function isProduction() {
+  return isProductionValue(process.env["NODE_ENV"]) || isProductionValue(process.env["STAGE"]) || isProductionValue(process.env["ENV"]) || isProductionValue(process.env["ENVIRONMENT"]);
+}
+export {
+  isProduction
+};
+
+//# debugId=B04BC044C8E167A264756E2164756E21

package/dist/env.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/env.ts"],
+  "sourcesContent": [
+    "const PROD_VALUES = new Set([\"production\", \"prod\"])\n\n/**\n * Returns `true` if the given environment variable value represents a\n * production environment (`\"production\"` or `\"prod\"`, case-insensitive).\n */\nfunction isProductionValue(value: string | undefined): boolean {\n    return value !== undefined && PROD_VALUES.has(value.toLowerCase())\n}\n\n/**\n * Returns `true` when any of the conventional environment variables\n * (`NODE_ENV`, `STAGE`, `ENV`, `ENVIRONMENT`) indicate a production\n * deployment.\n */\nexport function isProduction(): boolean {\n    return (\n        isProductionValue(process.env[\"NODE_ENV\"]) ||\n        isProductionValue(process.env[\"STAGE\"]) ||\n        isProductionValue(process.env[\"ENV\"]) ||\n        isProductionValue(process.env[\"ENVIRONMENT\"])\n    )\n}\n"
+  ],
+  "mappings": ";AAAA,IAAM,cAAc,IAAI,IAAI,CAAC,cAAc,MAAM,CAAC;AAMlD,SAAS,iBAAiB,CAAC,OAAoC;AAAA,EAC3D,OAAO,UAAU,aAAa,YAAY,IAAI,MAAM,YAAY,CAAC;AAAA;AAQ9D,SAAS,YAAY,GAAY;AAAA,EACpC,OACI,kBAAkB,QAAQ,IAAI,WAAW,KACzC,kBAAkB,QAAQ,IAAI,QAAQ,KACtC,kBAAkB,QAAQ,IAAI,MAAM,KACpC,kBAAkB,QAAQ,IAAI,cAAc;AAAA;",
+  "debugId": "B04BC044C8E167A264756E2164756E21",
+  "names": []
+}

package/dist/handler.d.ts

@@ -0,0 +1,26 @@
+import { RouteHandler } from "#src/method";
+import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from "aws-lambda";
+/**
+ * Creates an AWS Lambda handler function from a map of HTTP-method names to
+ * {@link RouteHandler} instances.
+ *
+ * The returned handler:
+ * - Returns `405 Method Not Allowed` (with an `Allow` header) for any HTTP
+ *   method not present in `routes`.
+ * - Delegates matching requests to {@link dispatch}.
+ * - Catches any `Error` thrown by `dispatch`, logs it, and returns
+ *   `500 Internal Server Error`.  In non-production environments the error
+ *   message and stack trace are included in the response body.
+ * - Re-throws non-`Error` throwables so they propagate to the Lambda runtime.
+ *
+ * @param routes - Map of upper-case HTTP method names (e.g. `"GET"`, `"POST"`)
+ *   to their corresponding {@link RouteHandler}.
+ *
+ * @example
+ * ```ts
+ * export const handler = createHandler({
+ *   GET: method().handle(async () => Response.json(200, {ok: true})),
+ * })
+ * ```
+ */
+export declare function createHandler<T extends Record<string, RouteHandler>>(routes: T): (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;

package/dist/handler.js

@@ -0,0 +1,29 @@
+// src/handler.ts
+import { dispatch } from "#src/dispatch";
+import { isProduction } from "#src/env";
+import { formatError, logError } from "#src/logger";
+import { Response } from "#src/response";
+import { install } from "source-map-support";
+install();
+function createHandler(routes) {
+  return async (event, context) => {
+    const route = routes[event.httpMethod];
+    if (!route) {
+      return Response.text(405, "Method Not Allowed").header("Allow", Object.keys(routes).join(", ")).toAPIGatewayProxyResult();
+    }
+    try {
+      return await dispatch(route, event, context);
+    } catch (error) {
+      if (error instanceof Error) {
+        logError(error);
+        return Response.text(500, isProduction() ? "Internal Server Error" : formatError(error)).toAPIGatewayProxyResult();
+      }
+      throw error;
+    }
+  };
+}
+export {
+  createHandler
+};
+
+//# debugId=BD00AEC1624B40DE64756E2164756E21

package/dist/handler.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/handler.ts"],
+  "sourcesContent": [
+    "import {dispatch} from \"#src/dispatch\"\nimport {isProduction} from \"#src/env\"\nimport {formatError, logError} from \"#src/logger\"\nimport {RouteHandler} from \"#src/method\"\nimport {Response} from \"#src/response\"\nimport type {APIGatewayProxyEvent, APIGatewayProxyResult, Context} from \"aws-lambda\"\nimport {install} from \"source-map-support\"\n\ninstall()\n\n/**\n * Creates an AWS Lambda handler function from a map of HTTP-method names to\n * {@link RouteHandler} instances.\n *\n * The returned handler:\n * - Returns `405 Method Not Allowed` (with an `Allow` header) for any HTTP\n *   method not present in `routes`.\n * - Delegates matching requests to {@link dispatch}.\n * - Catches any `Error` thrown by `dispatch`, logs it, and returns\n *   `500 Internal Server Error`.  In non-production environments the error\n *   message and stack trace are included in the response body.\n * - Re-throws non-`Error` throwables so they propagate to the Lambda runtime.\n *\n * @param routes - Map of upper-case HTTP method names (e.g. `\"GET\"`, `\"POST\"`)\n *   to their corresponding {@link RouteHandler}.\n *\n * @example\n * ```ts\n * export const handler = createHandler({\n *   GET: method().handle(async () => Response.json(200, {ok: true})),\n * })\n * ```\n */\nexport function createHandler<T extends Record<string, RouteHandler>>(routes: T) {\n    return async (\n        event: APIGatewayProxyEvent,\n        context: Context,\n    ): Promise<APIGatewayProxyResult> => {\n        const route = routes[event.httpMethod as keyof T]\n        if (!route) {\n            return Response.text(405, \"Method Not Allowed\")\n                .header(\"Allow\", Object.keys(routes).join(\", \"))\n                .toAPIGatewayProxyResult()\n        }\n        try {\n            return await dispatch(route, event, context)\n        } catch (error) {\n            if (error instanceof Error) {\n                logError(error)\n                return Response.text(\n                    500,\n                    isProduction() ? \"Internal Server Error\" : formatError(error),\n                ).toAPIGatewayProxyResult()\n            }\n            throw error\n        }\n    }\n}\n"
+  ],
+  "mappings": ";AAAA;AACA;AACA;AAEA;AAEA;AAEA,QAAQ;AAyBD,SAAS,aAAqD,CAAC,QAAW;AAAA,EAC7E,OAAO,OACH,OACA,YACiC;AAAA,IACjC,MAAM,QAAQ,OAAO,MAAM;AAAA,IAC3B,IAAI,CAAC,OAAO;AAAA,MACR,OAAO,SAAS,KAAK,KAAK,oBAAoB,EACzC,OAAO,SAAS,OAAO,KAAK,MAAM,EAAE,KAAK,IAAI,CAAC,EAC9C,wBAAwB;AAAA,IACjC;AAAA,IACA,IAAI;AAAA,MACA,OAAO,MAAM,SAAS,OAAO,OAAO,OAAO;AAAA,MAC7C,OAAO,OAAO;AAAA,MACZ,IAAI,iBAAiB,OAAO;AAAA,QACxB,SAAS,KAAK;AAAA,QACd,OAAO,SAAS,KACZ,KACA,aAAa,IAAI,0BAA0B,YAAY,KAAK,CAChE,EAAE,wBAAwB;AAAA,MAC9B;AAAA,MACA,MAAM;AAAA;AAAA;AAAA;",
+  "debugId": "BD00AEC1624B40DE64756E2164756E21",
+  "names": []
+}

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Formats an `Error` into a human-readable string that includes the error
+ * name, message, an optional Zod validation detail block, and the stack
+ * trace when available.
+ */
+export declare function formatError(error: Error): string;
+/** Writes a formatted error to `stderr` via `console.error`. */
+export declare function logError(error: Error): void;

package/dist/logger.js

@@ -0,0 +1,21 @@
+// src/logger.ts
+import * as z from "zod";
+function formatError(error) {
+  let detail;
+  if (error instanceof z.ZodError) {
+    detail = z.treeifyError(error).errors.join(`
+`);
+  }
+  return `${error.name}: ${error.message}${detail ? `
+${detail}` : ""}${error.stack ? `
+${error.stack}` : ""}`;
+}
+function logError(error) {
+  console.error(formatError(error));
+}
+export {
+  logError,
+  formatError
+};
+
+//# debugId=FB33B340A398C49564756E2164756E21

package/dist/logger.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/logger.ts"],
+  "sourcesContent": [
+    "import * as z from \"zod\"\n\n/**\n * Formats an `Error` into a human-readable string that includes the error\n * name, message, an optional Zod validation detail block, and the stack\n * trace when available.\n */\nexport function formatError(error: Error): string {\n    let detail\n    if (error instanceof z.ZodError) {\n        detail = z.treeifyError(error).errors.join(\"\\n\")\n    }\n    return `${error.name}: ${error.message}${detail ? `\\n${detail}` : \"\"}${error.stack ? `\\n${error.stack}` : \"\"}`\n}\n\n/** Writes a formatted error to `stderr` via `console.error`. */\nexport function logError(error: Error): void {\n    console.error(formatError(error))\n}\n"
+  ],
+  "mappings": ";AAAA;AAOO,SAAS,WAAW,CAAC,OAAsB;AAAA,EAC9C,IAAI;AAAA,EACJ,IAAI,iBAAmB,YAAU;AAAA,IAC7B,SAAW,eAAa,KAAK,EAAE,OAAO,KAAK;AAAA,CAAI;AAAA,EACnD;AAAA,EACA,OAAO,GAAG,MAAM,SAAS,MAAM,UAAU,SAAS;AAAA,EAAK,WAAW,KAAK,MAAM,QAAQ;AAAA,EAAK,MAAM,UAAU;AAAA;AAIvG,SAAS,QAAQ,CAAC,OAAoB;AAAA,EACzC,QAAQ,MAAM,YAAY,KAAK,CAAC;AAAA;",
+  "debugId": "FB33B340A398C49564756E2164756E21",
+  "names": []
+}

package/dist/method.d.ts

@@ -0,0 +1,53 @@
+import { type Middleware } from "#src/middleware";
+import { EndpointCallback, RouteHandler } from "#src/route-handler";
+import type { ZodType } from "zod";
+export type { EndpointCallback, RouteHandler };
+/**
+ * Fluent, immutable builder for a single HTTP-method handler.
+ *
+ * Every method returns a new `Method` instance, leaving the original
+ * unchanged.  Build a method with the following chain:
+ *
+ * ```ts
+ * method().use(cors()).input(schema).output(schema).handle(async ({body}) => …)
+ * ```
+ *
+ * @typeParam TInput  - Shape of the validated request body.
+ * @typeParam TOutput - Return type of the handler callback.
+ */
+export declare class Method<TInput = unknown, TOutput = unknown> {
+    middlewares: Middleware[];
+    bodySchema?: ZodType<TInput>;
+    outputSchema?: ZodType<TOutput>;
+    callback?: EndpointCallback<TInput, TOutput>;
+    /**
+     * Appends a middleware to the chain.  Middlewares are applied
+     * left-to-right after the callback resolves.
+     *
+     * @param middleware - The {@link Middleware} to append.
+     */
+    use(middleware: Middleware): Method<TInput, TOutput>;
+    /**
+     * Attaches a Zod schema used to validate (and narrow) the request body.
+     * When validation fails, `dispatch` returns a `400` response automatically.
+     *
+     * @param bodySchema - Zod schema for the request body.
+     */
+    input<U>(bodySchema: ZodType<U>): Method<U, TOutput>;
+    /**
+     * Attaches a Zod schema that describes the expected response shape.
+     * Currently stored for documentation / code-generation purposes.
+     *
+     * @param schema - Zod schema for the response body.
+     */
+    output<U>(schema: ZodType<U>): Method<TInput, U>;
+    /**
+     * Registers the async handler callback for this method.
+     *
+     * @param callback - Function that receives the validated body, the raw
+     *   Lambda event, and the Lambda context, and returns the response.
+     */
+    handle(callback: EndpointCallback<TInput, TOutput>): Method<TInput, TOutput>;
+}
+/** Creates a new, empty {@link Method} builder. */
+export declare function method(): Method;

package/dist/method.js

@@ -0,0 +1,57 @@
+// src/method.ts
+class Method {
+  middlewares = [];
+  bodySchema;
+  outputSchema;
+  callback;
+  use(middleware) {
+    const r = new Method;
+    r.middlewares = [...this.middlewares, middleware];
+    if (this.bodySchema)
+      r.bodySchema = this.bodySchema;
+    if (this.outputSchema)
+      r.outputSchema = this.outputSchema;
+    if (this.callback)
+      r.callback = this.callback;
+    return r;
+  }
+  input(bodySchema) {
+    const r = new Method;
+    r.middlewares = this.middlewares;
+    r.bodySchema = bodySchema;
+    if (this.outputSchema)
+      r.outputSchema = this.outputSchema;
+    if (this.callback)
+      r.callback = this.callback;
+    return r;
+  }
+  output(schema) {
+    const r = new Method;
+    r.middlewares = this.middlewares;
+    if (this.bodySchema)
+      r.bodySchema = this.bodySchema;
+    r.outputSchema = schema;
+    if (this.callback)
+      r.callback = this.callback;
+    return r;
+  }
+  handle(callback) {
+    const r = new Method;
+    r.middlewares = this.middlewares;
+    if (this.bodySchema)
+      r.bodySchema = this.bodySchema;
+    if (this.outputSchema)
+      r.outputSchema = this.outputSchema;
+    r.callback = callback;
+    return r;
+  }
+}
+function method() {
+  return new Method;
+}
+export {
+  method,
+  Method
+};
+
+//# debugId=5EADB1A7B72CB4BE64756E2164756E21

package/dist/method.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/method.ts"],
+  "sourcesContent": [
+    "import {type Middleware} from \"#src/middleware\"\nimport {EndpointCallback, RouteHandler} from \"#src/route-handler\"\nimport type {ZodType} from \"zod\"\n\nexport type {EndpointCallback, RouteHandler}\n\n/**\n * Fluent, immutable builder for a single HTTP-method handler.\n *\n * Every method returns a new `Method` instance, leaving the original\n * unchanged.  Build a method with the following chain:\n *\n * ```ts\n * method().use(cors()).input(schema).output(schema).handle(async ({body}) => …)\n * ```\n *\n * @typeParam TInput  - Shape of the validated request body.\n * @typeParam TOutput - Return type of the handler callback.\n */\nexport class Method<TInput = unknown, TOutput = unknown> {\n    middlewares: Middleware[] = []\n    bodySchema?: ZodType<TInput>\n    outputSchema?: ZodType<TOutput>\n    callback?: EndpointCallback<TInput, TOutput>\n\n    /**\n     * Appends a middleware to the chain.  Middlewares are applied\n     * left-to-right after the callback resolves.\n     *\n     * @param middleware - The {@link Middleware} to append.\n     */\n    use(middleware: Middleware): Method<TInput, TOutput> {\n        const r = new Method<TInput, TOutput>()\n        r.middlewares = [...this.middlewares, middleware]\n        if (this.bodySchema) r.bodySchema = this.bodySchema\n        if (this.outputSchema) r.outputSchema = this.outputSchema\n        if (this.callback) r.callback = this.callback\n        return r\n    }\n\n    /**\n     * Attaches a Zod schema used to validate (and narrow) the request body.\n     * When validation fails, `dispatch` returns a `400` response automatically.\n     *\n     * @param bodySchema - Zod schema for the request body.\n     */\n    input<U>(bodySchema: ZodType<U>): Method<U, TOutput> {\n        const r = new Method<U, TOutput>()\n        r.middlewares = this.middlewares\n        r.bodySchema = bodySchema\n        if (this.outputSchema) r.outputSchema = this.outputSchema as ZodType<TOutput>\n        if (this.callback)\n            r.callback = this.callback as unknown as EndpointCallback<U, TOutput>\n        return r\n    }\n\n    /**\n     * Attaches a Zod schema that describes the expected response shape.\n     * Currently stored for documentation / code-generation purposes.\n     *\n     * @param schema - Zod schema for the response body.\n     */\n    output<U>(schema: ZodType<U>): Method<TInput, U> {\n        const r = new Method<TInput, U>()\n        r.middlewares = this.middlewares\n        if (this.bodySchema) r.bodySchema = this.bodySchema\n        r.outputSchema = schema\n        if (this.callback)\n            r.callback = this.callback as unknown as EndpointCallback<TInput, U>\n        return r\n    }\n\n    /**\n     * Registers the async handler callback for this method.\n     *\n     * @param callback - Function that receives the validated body, the raw\n     *   Lambda event, and the Lambda context, and returns the response.\n     */\n    handle(callback: EndpointCallback<TInput, TOutput>): Method<TInput, TOutput> {\n        const r = new Method<TInput, TOutput>()\n        r.middlewares = this.middlewares\n        if (this.bodySchema) r.bodySchema = this.bodySchema\n        if (this.outputSchema) r.outputSchema = this.outputSchema\n        r.callback = callback\n        return r\n    }\n}\n\n/** Creates a new, empty {@link Method} builder. */\nexport function method(): Method {\n    return new Method()\n}\n"
+  ],
+  "mappings": ";AAmBO,MAAM,OAA4C;AAAA,EACrD,cAA4B,CAAC;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EAQA,GAAG,CAAC,YAAiD;AAAA,IACjD,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,cAAc,CAAC,GAAG,KAAK,aAAa,UAAU;AAAA,IAChD,IAAI,KAAK;AAAA,MAAY,EAAE,aAAa,KAAK;AAAA,IACzC,IAAI,KAAK;AAAA,MAAc,EAAE,eAAe,KAAK;AAAA,IAC7C,IAAI,KAAK;AAAA,MAAU,EAAE,WAAW,KAAK;AAAA,IACrC,OAAO;AAAA;AAAA,EASX,KAAQ,CAAC,YAA4C;AAAA,IACjD,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,cAAc,KAAK;AAAA,IACrB,EAAE,aAAa;AAAA,IACf,IAAI,KAAK;AAAA,MAAc,EAAE,eAAe,KAAK;AAAA,IAC7C,IAAI,KAAK;AAAA,MACL,EAAE,WAAW,KAAK;AAAA,IACtB,OAAO;AAAA;AAAA,EASX,MAAS,CAAC,QAAuC;AAAA,IAC7C,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,cAAc,KAAK;AAAA,IACrB,IAAI,KAAK;AAAA,MAAY,EAAE,aAAa,KAAK;AAAA,IACzC,EAAE,eAAe;AAAA,IACjB,IAAI,KAAK;AAAA,MACL,EAAE,WAAW,KAAK;AAAA,IACtB,OAAO;AAAA;AAAA,EASX,MAAM,CAAC,UAAsE;AAAA,IACzE,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,cAAc,KAAK;AAAA,IACrB,IAAI,KAAK;AAAA,MAAY,EAAE,aAAa,KAAK;AAAA,IACzC,IAAI,KAAK;AAAA,MAAc,EAAE,eAAe,KAAK;AAAA,IAC7C,EAAE,WAAW;AAAA,IACb,OAAO;AAAA;AAEf;AAGO,SAAS,MAAM,GAAW;AAAA,EAC7B,OAAO,IAAI;AAAA;",
+  "debugId": "5EADB1A7B72CB4BE64756E2164756E21",
+  "names": []
+}

package/{src/middleware.ts → dist/middleware.d.ts}

@@ -1,14 +1,11 @@
-import type {APIGatewayProxyResult} from "aws-lambda"
-
-import {RouteHandler} from "./route-handler"
-
+import type { APIGatewayProxyResult } from "aws-lambda";
+import { RouteHandler } from "./route-handler";
 /**
  * A pure function that receives an {@link APIGatewayProxyResult} and returns
  * a (possibly modified) copy of it.  Middlewares are composed left-to-right
  * by {@link dispatch}.
  */
-export type Middleware = (result: APIGatewayProxyResult) => APIGatewayProxyResult
-
+export type Middleware = (result: APIGatewayProxyResult) => APIGatewayProxyResult;
 /**
  * Creates a middleware that injects CORS response headers.
  *
@@ -19,23 +16,9 @@ export type Middleware = (result: APIGatewayProxyResult) => APIGatewayProxyResul
  * @param headers - Map of unprefixed CORS header names to their values.
  *   Defaults to an empty object (no CORS headers added).
  */
-export function cors(headers: Record<string, string> = {}): Middleware {
-    return (result) => {
-        const corsHeaders: Record<string, string> = {}
-        for (const [key, value] of Object.entries(headers)) {
-            corsHeaders[`Access-Control-${key}`] = value
-        }
-        return {...result, headers: {...result.headers, ...corsHeaders}}
-    }
-}
-
+export declare function cors(headers?: Record<string, string>): Middleware;
 /**
  * Folds all middlewares registered on `route` over `result`, applying them
  * left-to-right, and returns the final {@link APIGatewayProxyResult}.
  */
-export function applyMiddlewares(
-    result: APIGatewayProxyResult,
-    route: RouteHandler,
-): APIGatewayProxyResult {
-    return route.middlewares.reduce((r, middleware) => middleware(r), result)
-}
+export declare function applyMiddlewares(result: APIGatewayProxyResult, route: RouteHandler): APIGatewayProxyResult;

package/dist/middleware.js

@@ -0,0 +1,19 @@
+// src/middleware.ts
+function cors(headers = {}) {
+  return (result) => {
+    const corsHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+      corsHeaders[`Access-Control-${key}`] = value;
+    }
+    return { ...result, headers: { ...result.headers, ...corsHeaders } };
+  };
+}
+function applyMiddlewares(result, route) {
+  return route.middlewares.reduce((r, middleware) => middleware(r), result);
+}
+export {
+  cors,
+  applyMiddlewares
+};
+
+//# debugId=235C7399F968D7AF64756E2164756E21

package/dist/middleware.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/middleware.ts"],
+  "sourcesContent": [
+    "import type {APIGatewayProxyResult} from \"aws-lambda\"\n\nimport {RouteHandler} from \"./route-handler\"\n\n/**\n * A pure function that receives an {@link APIGatewayProxyResult} and returns\n * a (possibly modified) copy of it.  Middlewares are composed left-to-right\n * by {@link dispatch}.\n */\nexport type Middleware = (result: APIGatewayProxyResult) => APIGatewayProxyResult\n\n/**\n * Creates a middleware that injects CORS response headers.\n *\n * Each key in `headers` is prefixed with `\"Access-Control-\"` before being\n * merged into the response, so passing `{\"Allow-Origin\": \"*\"}` produces the\n * `Access-Control-Allow-Origin: *` header.\n *\n * @param headers - Map of unprefixed CORS header names to their values.\n *   Defaults to an empty object (no CORS headers added).\n */\nexport function cors(headers: Record<string, string> = {}): Middleware {\n    return (result) => {\n        const corsHeaders: Record<string, string> = {}\n        for (const [key, value] of Object.entries(headers)) {\n            corsHeaders[`Access-Control-${key}`] = value\n        }\n        return {...result, headers: {...result.headers, ...corsHeaders}}\n    }\n}\n\n/**\n * Folds all middlewares registered on `route` over `result`, applying them\n * left-to-right, and returns the final {@link APIGatewayProxyResult}.\n */\nexport function applyMiddlewares(\n    result: APIGatewayProxyResult,\n    route: RouteHandler,\n): APIGatewayProxyResult {\n    return route.middlewares.reduce((r, middleware) => middleware(r), result)\n}\n"
+  ],
+  "mappings": ";AAqBO,SAAS,IAAI,CAAC,UAAkC,CAAC,GAAe;AAAA,EACnE,OAAO,CAAC,WAAW;AAAA,IACf,MAAM,cAAsC,CAAC;AAAA,IAC7C,YAAY,KAAK,UAAU,OAAO,QAAQ,OAAO,GAAG;AAAA,MAChD,YAAY,kBAAkB,SAAS;AAAA,IAC3C;AAAA,IACA,OAAO,KAAI,QAAQ,SAAS,KAAI,OAAO,YAAY,YAAW,EAAC;AAAA;AAAA;AAQhE,SAAS,gBAAgB,CAC5B,QACA,OACqB;AAAA,EACrB,OAAO,MAAM,YAAY,OAAO,CAAC,GAAG,eAAe,WAAW,CAAC,GAAG,MAAM;AAAA;",
+  "debugId": "235C7399F968D7AF64756E2164756E21",
+  "names": []
+}

package/dist/response.d.ts

@@ -0,0 +1,48 @@
+import type { APIGatewayProxyResult } from "aws-lambda";
+/**
+ * Immutable builder for AWS Lambda proxy responses.
+ *
+ * All mutation methods return a new `Response` instance so that existing
+ * instances are never modified.  Construct instances through the static
+ * factory methods {@link Response.text} and {@link Response.json}.
+ */
+export declare class Response {
+    status?: number;
+    body?: unknown;
+    text?: string;
+    headers?: Record<string, string>;
+    private constructor();
+    /**
+     * Creates a plain-text response.
+     *
+     * @param status - HTTP status code.
+     * @param text - Response body as a plain string.
+     */
+    static text(status: number, text: string): Response;
+    /**
+     * Creates a JSON response.
+     *
+     * @param status - HTTP status code.
+     * @param body - Value to be serialised with `JSON.stringify`.
+     */
+    static json(status: number, body: unknown): Response;
+    /**
+     * Returns a new `Response` with an additional HTTP response header.
+     *
+     * @param name - Header name (e.g. `"Allow"`).
+     * @param value - Header value.
+     */
+    header(name: string, value: string): Response;
+    /**
+     * Serialises this `Response` into the shape expected by the AWS Lambda
+     * proxy integration.
+     *
+     * - When constructed via {@link Response.json} the body is JSON-encoded
+     *   and `Content-Type` is set to `application/json; charset=utf-8`.
+     * - When constructed via {@link Response.text} the body is returned as-is
+     *   and `Content-Type` is set to `text/plain; charset=utf-8`.
+     * - Additional headers set via {@link Response.header} are merged last and
+     *   therefore take precedence over the defaults above.
+     */
+    toAPIGatewayProxyResult(): APIGatewayProxyResult;
+}

package/dist/response.js

@@ -0,0 +1,46 @@
+// src/response.ts
+class Response {
+  status;
+  body;
+  text;
+  headers;
+  constructor() {}
+  static text(status, text) {
+    const r = new Response;
+    r.status = status;
+    r.text = text;
+    return r;
+  }
+  static json(status, body) {
+    const r = new Response;
+    r.status = status;
+    r.body = body;
+    return r;
+  }
+  header(name, value) {
+    const r = new Response;
+    if (this.status !== undefined)
+      r.status = this.status;
+    if (this.body !== undefined)
+      r.body = this.body;
+    if (this.text !== undefined)
+      r.text = this.text;
+    r.headers = { ...this.headers, [name]: value };
+    return r;
+  }
+  toAPIGatewayProxyResult() {
+    return {
+      statusCode: this.status ?? 200,
+      body: this.text === undefined ? JSON.stringify(this.body) ?? "null" : this.text,
+      headers: {
+        "Content-Type": this.text === undefined ? "application/json; charset=utf-8" : "text/plain; charset=utf-8",
+        ...this.headers
+      }
+    };
+  }
+}
+export {
+  Response
+};
+
+//# debugId=908F48F107B3C11764756E2164756E21

package/dist/response.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/response.ts"],
+  "sourcesContent": [
+    "import type {APIGatewayProxyResult} from \"aws-lambda\"\n\n/**\n * Immutable builder for AWS Lambda proxy responses.\n *\n * All mutation methods return a new `Response` instance so that existing\n * instances are never modified.  Construct instances through the static\n * factory methods {@link Response.text} and {@link Response.json}.\n */\nexport class Response {\n    status?: number\n    body?: unknown\n    text?: string\n    headers?: Record<string, string>\n\n    private constructor() {}\n\n    /**\n     * Creates a plain-text response.\n     *\n     * @param status - HTTP status code.\n     * @param text - Response body as a plain string.\n     */\n    static text(status: number, text: string) {\n        const r = new Response()\n        r.status = status\n        r.text = text\n        return r\n    }\n\n    /**\n     * Creates a JSON response.\n     *\n     * @param status - HTTP status code.\n     * @param body - Value to be serialised with `JSON.stringify`.\n     */\n    static json(status: number, body: unknown) {\n        const r = new Response()\n        r.status = status\n        r.body = body\n        return r\n    }\n\n    /**\n     * Returns a new `Response` with an additional HTTP response header.\n     *\n     * @param name - Header name (e.g. `\"Allow\"`).\n     * @param value - Header value.\n     */\n    header(name: string, value: string): Response {\n        const r = new Response()\n        if (this.status !== undefined) r.status = this.status\n        if (this.body !== undefined) r.body = this.body\n        if (this.text !== undefined) r.text = this.text\n        r.headers = {...this.headers, [name]: value}\n        return r\n    }\n\n    /**\n     * Serialises this `Response` into the shape expected by the AWS Lambda\n     * proxy integration.\n     *\n     * - When constructed via {@link Response.json} the body is JSON-encoded\n     *   and `Content-Type` is set to `application/json; charset=utf-8`.\n     * - When constructed via {@link Response.text} the body is returned as-is\n     *   and `Content-Type` is set to `text/plain; charset=utf-8`.\n     * - Additional headers set via {@link Response.header} are merged last and\n     *   therefore take precedence over the defaults above.\n     */\n    toAPIGatewayProxyResult(): APIGatewayProxyResult {\n        return {\n            statusCode: this.status ?? 200,\n            body:\n                this.text === undefined ?\n                    (JSON.stringify(this.body) ?? \"null\")\n                :   this.text,\n            headers: {\n                \"Content-Type\":\n                    this.text === undefined ?\n                        \"application/json; charset=utf-8\"\n                    :   \"text/plain; charset=utf-8\",\n                ...this.headers,\n            },\n        }\n    }\n}\n"
+  ],
+  "mappings": ";AASO,MAAM,SAAS;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEQ,WAAW,GAAG;AAAA,SAQf,IAAI,CAAC,QAAgB,MAAc;AAAA,IACtC,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,SAAS;AAAA,IACX,EAAE,OAAO;AAAA,IACT,OAAO;AAAA;AAAA,SASJ,IAAI,CAAC,QAAgB,MAAe;AAAA,IACvC,MAAM,IAAI,IAAI;AAAA,IACd,EAAE,SAAS;AAAA,IACX,EAAE,OAAO;AAAA,IACT,OAAO;AAAA;AAAA,EASX,MAAM,CAAC,MAAc,OAAyB;AAAA,IAC1C,MAAM,IAAI,IAAI;AAAA,IACd,IAAI,KAAK,WAAW;AAAA,MAAW,EAAE,SAAS,KAAK;AAAA,IAC/C,IAAI,KAAK,SAAS;AAAA,MAAW,EAAE,OAAO,KAAK;AAAA,IAC3C,IAAI,KAAK,SAAS;AAAA,MAAW,EAAE,OAAO,KAAK;AAAA,IAC3C,EAAE,UAAU,KAAI,KAAK,UAAU,OAAO,MAAK;AAAA,IAC3C,OAAO;AAAA;AAAA,EAcX,uBAAuB,GAA0B;AAAA,IAC7C,OAAO;AAAA,MACH,YAAY,KAAK,UAAU;AAAA,MAC3B,MACI,KAAK,SAAS,YACT,KAAK,UAAU,KAAK,IAAI,KAAK,SAC9B,KAAK;AAAA,MACb,SAAS;AAAA,QACL,gBACI,KAAK,SAAS,YACV,oCACA;AAAA,WACL,KAAK;AAAA,MACZ;AAAA,IACJ;AAAA;AAER;",
+  "debugId": "908F48F107B3C11764756E2164756E21",
+  "names": []
+}