itty-lambda 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Evan Kaufman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# `itty-lambda` - AWS Lambda support for [itty-router]
+
+[
+  ![ci status](https://github.com/EvanK/itty-lambda/actions/workflows/ci.yaml/badge.svg)
+](https://github.com/EvanK/itty-lambda/actions/workflows/ci.yaml)
+[
+  ![node.js support as of v20](https://img.shields.io/badge/Node.js-v20-yellow)
+](https://nodejs.org/docs/latest-v20.x/api/)
+
+
+AWS Lambda functions can respond to HTTP requests via one of the following invocation types:
+- [Function urls][lambda-function-urls]
+- [API gateways][api-gateways]
+- [Application load balancers][albs].
+
+This library aims to maintain support for running [itty-router] in any such environment.
+
+
+## Example
+
+```js
+// supports CJS -or- ESM
+// const { url, ag, alb } = require('itty-lambda');
+// import { url, ag, alb } from 'itty-lambda';
+
+// for just API Gateway support, use 'itty-lambda/ag'
+// for just Application Load Balancer support, use 'itty-lambda/alb'
+// for just Lambda function url support, use 'itty-lambda/url'
+
+import { AutoRouter } from 'itty-router';
+
+// using an app load balancer...
+import { eventToRequest, responseToResult } from 'itty-lambda/alb';
+
+export async function handler (event) {
+    const router = AutoRouter();
+    router.get('/foo', () => ({ success: true }));
+
+    const request = await eventToRequest(event);
+    // { path: string, httpMethod: string, headers: object, ... }
+    // ->
+    // { url: string, method: string, headers: Headers, ... }
+
+    const response = await router.fetch(request);
+
+    const result = await responseToResult(response);
+    // { status: number, headers: Headers, body: ReadableStream, ... }
+    // ->
+    // { statusCode: number, body: string, headers: object, ... }
+
+    return result;
+}
+```
+
+Each implementation provides these two named exports, for you to plug in before and after routing...
+
+For more information, see [the documentation](https://EvanK.github.io/itty-lambda/).
+
+## eventToRequest
+
+Accepts an AWS Lambda event for the invocation type, and resolves to a well formed `RequestLike`.
+
+```ts
+eventToRequest(
+    event: APIGatewayProxyEvent | ALBEvent | LambdaFunctionURLEvent,
+    options: EventOptions | undefined
+) : Promise<RequestLike>
+```
+
+### EventOptions
+
+| Name | Type(s) | Default Value | Description |
+| -- | -- | -- | -- |
+| **defaultMethod** | `string` | `GET` | HTTP method if none provided from event |
+
+
+## responseToResult
+
+Accepts a router `Response`, and resolves to a result for the invocation type.
+
+```ts
+responseToResult(
+    response: Response | undefined,
+    options : ResponseOptions | undefined
+) : Promise<APIGatewayProxyResult | ALBResult | LambdaFunctionURLResult>
+```
+
+### ResponseOptions
+
+| Name | Type(s) | Default Value | Description |
+| -- | -- | -- | -- |
+| **base64Encode** | `boolean` | `false` | Encode response body |
+| **fallbackStatus** | `number` | `404` | Status if no response provided from router |
+| **multiValueHeaders** | `boolean` | `false` | Split response headers with multiple values |
+
+
+<!-- footnotes and urls -->
+[itty-router]: https://itty.dev/itty-router/
+[lambda-function-urls]: https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html
+[api-gateways]: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-integrations.html
+[albs]: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html

package/build/cjs/ag.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * API gateway implemention
+ *
+ * @module ag
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/ag';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of an
+ * API gateway proxy integration, and formats it into a request suitable
+ * for routing through itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Ag, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to an API gateway proxy integration.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Ag, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/build/cjs/alb.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Application load balancer implemention
+ *
+ * @module alb
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/alb';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of an
+ * application load balancer target, and formats it into a request
+ * suitable for routing through itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Alb, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to an application load balancer.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Alb, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/build/cjs/common.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Common shared functionality between implementations.
+ *
+ * @module common
+ * @protected
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingMode = void 0;
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const consumers_1 = require("node:stream/consumers");
+const itty_router_1 = require("itty-router");
+/** @ignore */
+var RoutingMode;
+(function (RoutingMode) {
+    RoutingMode["Ag"] = "api-gateway";
+    RoutingMode["Alb"] = "application-load-balancer";
+    RoutingMode["Url"] = "lambda-function-url";
+})(RoutingMode || (exports.RoutingMode = RoutingMode = {}));
+/** @ignore */
+async function eventToRequest(mode, event, options) {
+    const output = { method: '', url: '' };
+    output.headers = objectsToHeaders(event?.headers, 
+    // account for lambda function urls not supporting multi values
+    (mode != RoutingMode.Url ? event.multiValueHeaders : undefined));
+    // infer protocol from headers when available
+    const proto = output.headers.get('x-forwarded-proto')
+        ?? output.headers.get('forwarded')?.match(/proto=(\w+)/)?.[1]
+        ?? 'http';
+    // infer host when available
+    const host = (
+    // ag or url may have requestContext.domainName
+    (mode != RoutingMode.Alb ? event.requestContext?.domainName : undefined))
+        ?? output.headers.get('host')
+        ?? output.headers.get('x-forwarded-host')
+        ?? output.headers.get('forwarded')?.match(/host=([^;]+)/)?.[1]
+        ?? 'localhost.localdomain';
+    // infer path when available
+    const path = (
+    // ag or alb may have path
+    (mode != RoutingMode.Url ? event.path : undefined))
+        ?? (
+        // url may have rawPath
+        (mode == RoutingMode.Url ? event.rawPath : undefined))
+        ?? (
+        // ag may have requestContext.path
+        (mode == RoutingMode.Ag ? event.requestContext?.path : undefined))
+        ?? (
+        // url may have requestContext.http.path
+        (mode == RoutingMode.Url ? event.requestContext?.http?.path : undefined))
+        ?? '';
+    // infer querystring and convert to string as necessary
+    const queryString = (
+    // url may have rawQueryString
+    (mode == RoutingMode.Url ? event.rawQueryString : undefined))
+        ?? objectsToQueryString(event?.queryStringParameters, (
+        // ag or alb may have multiValueQueryStringParameters
+        (mode != RoutingMode.Url ? event.multiValueQueryStringParameters : undefined)));
+    // assemble well-formed url from inferred values above
+    output.url = `${proto}://${host}${path}?${queryString}`;
+    // infer or default http method
+    output.method =
+        (
+        // ag or alb may have httpMethod
+        (mode != RoutingMode.Url ? event.httpMethod : undefined))
+            ?? (
+            // ag may have requestContext.httpMethod
+            (mode != RoutingMode.Ag ? event.requestContext?.httpMethod : undefined))
+            ?? (
+            // url may have requestContext.http.method
+            (mode == RoutingMode.Url ? event.requestContext?.http?.method : undefined))
+            ?? options?.defaultMethod
+            ?? 'GET';
+    // get and decode as necessary any request body
+    if (event?.body) {
+        output.body = event?.isBase64Encoded
+            ? Buffer.from(`${event?.body}`, 'base64').toString('ascii')
+            : event?.body;
+    }
+    return output;
+}
+/** @ignore */
+async function responseToResult(mode, response, options) {
+    options = Object.assign({ base64Encode: false, fallbackStatus: 404, multiValueHeaders: false }, options);
+    // function urls do not support multi values
+    if (options && mode === RoutingMode.Url) {
+        options.multiValueHeaders = false;
+    }
+    try {
+        return await parseResponseOrError(mode, response ?? (0, itty_router_1.error)(options.fallbackStatus, 'Response not found'), options);
+    }
+    catch (err) { // eslint-disable-line @typescript-eslint/no-explicit-any
+        return await parseResponseOrError(mode, (0, itty_router_1.error)(err), options);
+    }
+}
+async function parseResponseOrError(mode, input, options) {
+    let output;
+    switch (mode) {
+        case RoutingMode.Ag:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode, body: '' };
+            break;
+        case RoutingMode.Alb:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode };
+            break;
+        case RoutingMode.Url:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode };
+            break;
+    }
+    // destructure just what we need
+    const { status, headers, body } = input;
+    output.statusCode = status;
+    // handle single or multi headers
+    const { headers: singleHeaders, multiValueHeaders } = headersToObjects(headers, options.multiValueHeaders);
+    output.headers = {};
+    for (const [key, value] of Object.entries(singleHeaders)) {
+        if (undefined !== value)
+            output.headers[key] = value;
+    }
+    if (mode !== RoutingMode.Url) {
+        output.multiValueHeaders = {};
+        if ('multiValueHeaders' in output && output.multiValueHeaders) {
+            for (const [key, value] of Object.entries(multiValueHeaders)) {
+                if (undefined !== value)
+                    output.multiValueHeaders[key] = value;
+            }
+        }
+    }
+    // un-streamify body as necessary
+    if (body) {
+        output.body = await (0, consumers_1.text)(body);
+        if (options.base64Encode) {
+            output.body = Buffer.from(output.body, 'utf-8').toString('base64');
+        }
+    }
+    return output;
+}
+/**
+ * Combine single and multi value header objects and convert to standardized
+ * Headers instance.
+ */
+function objectsToHeaders(single, multi) {
+    const input = {};
+    // add each single value header, wrapped in array
+    if (single) {
+        for (const [key, value] of Object.entries(single)) {
+            if (value)
+                input[key] = [value];
+        }
+    }
+    // and each multi value header
+    if (multi) {
+        for (const [key, values] of Object.entries(multi)) {
+            if (values) {
+                // merge with any existing arrays of values
+                if (undefined === input?.[key]) {
+                    input[key] = values;
+                }
+                else {
+                    for (const value of values) {
+                        if (!input[key].includes(value))
+                            input[key].push(value);
+                    }
+                }
+            }
+        }
+    }
+    // append each normalized array to new Headers instance
+    const output = new Headers();
+    for (const [key, values] of Object.entries(input)) {
+        for (const value of values) {
+            output.append(key, value);
+        }
+    }
+    return output;
+}
+/**
+ * Split Headers instance into single and (when explicitly enabled) multi value
+ * header objects.
+ */
+function headersToObjects(headers, splitIntoMultiValues = false) {
+    const single = {};
+    const multi = {};
+    for (const [key, value] of headers.entries()) {
+        if (splitIntoMultiValues && value.includes(',')) {
+            multi[key] = value.split(/\s*,\s*/);
+        }
+        else {
+            single[key] = value;
+        }
+    }
+    return { headers: single, multiValueHeaders: multi };
+}
+/**
+ * Combine single and multi value query string parameters into a well formed
+ * query string, as produced by the URLSearchParams global.
+ */
+function objectsToQueryString(single, multi) {
+    const output = new URLSearchParams();
+    // include all single value query params by default
+    if (single) {
+        for (const [key, value] of Object.entries(single)) {
+            if (undefined !== value)
+                output.append(key, value);
+        }
+    }
+    // and all multi value query params that don't already contain same value
+    if (multi) {
+        for (const [key, value] of Object.entries(multi)) {
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    if (!output.has(key, v))
+                        output.append(key, v);
+                }
+            }
+        }
+    }
+    return output.toString();
+}

package/build/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Each implements the following functions:
+ *
+ * @see eventToRequest
+ * Expects an event as provided by the AWS Lambda service to an invoked
+ * function, and returns a request-like object for use by itty-router.
+ *
+ * @see responseToResult
+ * Expects a response as returned by itty-router (or undefined if no route
+ * match found), and returns a result as expected by the Lambda service.
+ *
+ * The format of each incoming event and outgoing result vary depending on
+ * how the Lambda has been invoked, hence the multiple implementations.
+ *
+ * @module index
+ * @ignore
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.url = exports.alb = exports.ag = void 0;
+// API Gateways
+const ag_1 = __importDefault(require("./ag"));
+exports.ag = ag_1.default;
+// Application Load Balancers
+const alb_1 = __importDefault(require("./alb"));
+exports.alb = alb_1.default;
+// Lambda function urls
+const url_1 = __importDefault(require("./url"));
+exports.url = url_1.default;

package/build/cjs/url.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Lambda function url implemention
+ *
+ * @module url
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/url';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of a
+ * function url, and formats it into a request suitable for routing through
+ * itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Url, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to the client invoking the function url.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Url, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/build/esm/ag.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * API gateway implemention
+ *
+ * @module ag
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/ag';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of an
+ * API gateway proxy integration, and formats it into a request suitable
+ * for routing through itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Ag, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to an API gateway proxy integration.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Ag, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/build/esm/alb.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Application load balancer implemention
+ *
+ * @module alb
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/alb';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of an
+ * application load balancer target, and formats it into a request
+ * suitable for routing through itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Alb, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to an application load balancer.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Alb, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/build/esm/common.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Common shared functionality between implementations.
+ *
+ * @module common
+ * @protected
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingMode = void 0;
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const consumers_1 = require("node:stream/consumers");
+const itty_router_1 = require("itty-router");
+/** @ignore */
+var RoutingMode;
+(function (RoutingMode) {
+    RoutingMode["Ag"] = "api-gateway";
+    RoutingMode["Alb"] = "application-load-balancer";
+    RoutingMode["Url"] = "lambda-function-url";
+})(RoutingMode || (exports.RoutingMode = RoutingMode = {}));
+/** @ignore */
+async function eventToRequest(mode, event, options) {
+    const output = { method: '', url: '' };
+    output.headers = objectsToHeaders(event?.headers, 
+    // account for lambda function urls not supporting multi values
+    (mode != RoutingMode.Url ? event.multiValueHeaders : undefined));
+    // infer protocol from headers when available
+    const proto = output.headers.get('x-forwarded-proto')
+        ?? output.headers.get('forwarded')?.match(/proto=(\w+)/)?.[1]
+        ?? 'http';
+    // infer host when available
+    const host = (
+    // ag or url may have requestContext.domainName
+    (mode != RoutingMode.Alb ? event.requestContext?.domainName : undefined))
+        ?? output.headers.get('host')
+        ?? output.headers.get('x-forwarded-host')
+        ?? output.headers.get('forwarded')?.match(/host=([^;]+)/)?.[1]
+        ?? 'localhost.localdomain';
+    // infer path when available
+    const path = (
+    // ag or alb may have path
+    (mode != RoutingMode.Url ? event.path : undefined))
+        ?? (
+        // url may have rawPath
+        (mode == RoutingMode.Url ? event.rawPath : undefined))
+        ?? (
+        // ag may have requestContext.path
+        (mode == RoutingMode.Ag ? event.requestContext?.path : undefined))
+        ?? (
+        // url may have requestContext.http.path
+        (mode == RoutingMode.Url ? event.requestContext?.http?.path : undefined))
+        ?? '';
+    // infer querystring and convert to string as necessary
+    const queryString = (
+    // url may have rawQueryString
+    (mode == RoutingMode.Url ? event.rawQueryString : undefined))
+        ?? objectsToQueryString(event?.queryStringParameters, (
+        // ag or alb may have multiValueQueryStringParameters
+        (mode != RoutingMode.Url ? event.multiValueQueryStringParameters : undefined)));
+    // assemble well-formed url from inferred values above
+    output.url = `${proto}://${host}${path}?${queryString}`;
+    // infer or default http method
+    output.method =
+        (
+        // ag or alb may have httpMethod
+        (mode != RoutingMode.Url ? event.httpMethod : undefined))
+            ?? (
+            // ag may have requestContext.httpMethod
+            (mode != RoutingMode.Ag ? event.requestContext?.httpMethod : undefined))
+            ?? (
+            // url may have requestContext.http.method
+            (mode == RoutingMode.Url ? event.requestContext?.http?.method : undefined))
+            ?? options?.defaultMethod
+            ?? 'GET';
+    // get and decode as necessary any request body
+    if (event?.body) {
+        output.body = event?.isBase64Encoded
+            ? Buffer.from(`${event?.body}`, 'base64').toString('ascii')
+            : event?.body;
+    }
+    return output;
+}
+/** @ignore */
+async function responseToResult(mode, response, options) {
+    options = Object.assign({ base64Encode: false, fallbackStatus: 404, multiValueHeaders: false }, options);
+    // function urls do not support multi values
+    if (options && mode === RoutingMode.Url) {
+        options.multiValueHeaders = false;
+    }
+    try {
+        return await parseResponseOrError(mode, response ?? (0, itty_router_1.error)(options.fallbackStatus, 'Response not found'), options);
+    }
+    catch (err) { // eslint-disable-line @typescript-eslint/no-explicit-any
+        return await parseResponseOrError(mode, (0, itty_router_1.error)(err), options);
+    }
+}
+async function parseResponseOrError(mode, input, options) {
+    let output;
+    switch (mode) {
+        case RoutingMode.Ag:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode, body: '' };
+            break;
+        case RoutingMode.Alb:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode };
+            break;
+        case RoutingMode.Url:
+            output = { statusCode: 200, isBase64Encoded: !!options.base64Encode };
+            break;
+    }
+    // destructure just what we need
+    const { status, headers, body } = input;
+    output.statusCode = status;
+    // handle single or multi headers
+    const { headers: singleHeaders, multiValueHeaders } = headersToObjects(headers, options.multiValueHeaders);
+    output.headers = {};
+    for (const [key, value] of Object.entries(singleHeaders)) {
+        if (undefined !== value)
+            output.headers[key] = value;
+    }
+    if (mode !== RoutingMode.Url) {
+        output.multiValueHeaders = {};
+        if ('multiValueHeaders' in output && output.multiValueHeaders) {
+            for (const [key, value] of Object.entries(multiValueHeaders)) {
+                if (undefined !== value)
+                    output.multiValueHeaders[key] = value;
+            }
+        }
+    }
+    // un-streamify body as necessary
+    if (body) {
+        output.body = await (0, consumers_1.text)(body);
+        if (options.base64Encode) {
+            output.body = Buffer.from(output.body, 'utf-8').toString('base64');
+        }
+    }
+    return output;
+}
+/**
+ * Combine single and multi value header objects and convert to standardized
+ * Headers instance.
+ */
+function objectsToHeaders(single, multi) {
+    const input = {};
+    // add each single value header, wrapped in array
+    if (single) {
+        for (const [key, value] of Object.entries(single)) {
+            if (value)
+                input[key] = [value];
+        }
+    }
+    // and each multi value header
+    if (multi) {
+        for (const [key, values] of Object.entries(multi)) {
+            if (values) {
+                // merge with any existing arrays of values
+                if (undefined === input?.[key]) {
+                    input[key] = values;
+                }
+                else {
+                    for (const value of values) {
+                        if (!input[key].includes(value))
+                            input[key].push(value);
+                    }
+                }
+            }
+        }
+    }
+    // append each normalized array to new Headers instance
+    const output = new Headers();
+    for (const [key, values] of Object.entries(input)) {
+        for (const value of values) {
+            output.append(key, value);
+        }
+    }
+    return output;
+}
+/**
+ * Split Headers instance into single and (when explicitly enabled) multi value
+ * header objects.
+ */
+function headersToObjects(headers, splitIntoMultiValues = false) {
+    const single = {};
+    const multi = {};
+    for (const [key, value] of headers.entries()) {
+        if (splitIntoMultiValues && value.includes(',')) {
+            multi[key] = value.split(/\s*,\s*/);
+        }
+        else {
+            single[key] = value;
+        }
+    }
+    return { headers: single, multiValueHeaders: multi };
+}
+/**
+ * Combine single and multi value query string parameters into a well formed
+ * query string, as produced by the URLSearchParams global.
+ */
+function objectsToQueryString(single, multi) {
+    const output = new URLSearchParams();
+    // include all single value query params by default
+    if (single) {
+        for (const [key, value] of Object.entries(single)) {
+            if (undefined !== value)
+                output.append(key, value);
+        }
+    }
+    // and all multi value query params that don't already contain same value
+    if (multi) {
+        for (const [key, value] of Object.entries(multi)) {
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    if (!output.has(key, v))
+                        output.append(key, v);
+                }
+            }
+        }
+    }
+    return output.toString();
+}

package/build/esm/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Each implements the following functions:
+ *
+ * @see eventToRequest
+ * Expects an event as provided by the AWS Lambda service to an invoked
+ * function, and returns a request-like object for use by itty-router.
+ *
+ * @see responseToResult
+ * Expects a response as returned by itty-router (or undefined if no route
+ * match found), and returns a result as expected by the Lambda service.
+ *
+ * The format of each incoming event and outgoing result vary depending on
+ * how the Lambda has been invoked, hence the multiple implementations.
+ *
+ * @module index
+ * @ignore
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.url = exports.alb = exports.ag = void 0;
+// API Gateways
+const ag_1 = __importDefault(require("./ag"));
+exports.ag = ag_1.default;
+// Application Load Balancers
+const alb_1 = __importDefault(require("./alb"));
+exports.alb = alb_1.default;
+// Lambda function urls
+const url_1 = __importDefault(require("./url"));
+exports.url = url_1.default;

package/build/esm/url.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Lambda function url implemention
+ *
+ * @module url
+ *
+ * @example
+ * import { eventToRequest, responseToResult } from 'itty-lambda/url';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToRequest = eventToRequest;
+exports.responseToResult = responseToResult;
+const common_1 = require("./common");
+/**
+ * Accepts an event from an AWS Lambda function invocation by way of a
+ * function url, and formats it into a request suitable for routing through
+ * itty-router.
+ *
+ * @param event
+ * @param options
+ */
+async function eventToRequest(event, options) {
+    return await (0, common_1.eventToRequest)(common_1.RoutingMode.Url, event, options);
+}
+/**
+ * Accepts a response from itty-router (or undefined if no route was matched),
+ * and formats it into a result suitable to return to the Lambda service and
+ * subsequently to the client invoking the function url.
+ *
+ * If no response was provided, an error response is built with the given
+ * fallback HTTP status, defaulting to 404.
+ *
+ * @param response
+ * @param options
+ */
+async function responseToResult(response, options) {
+    return (await (0, common_1.responseToResult)(common_1.RoutingMode.Url, response, options));
+}
+/** @ignore */
+exports.default = {
+    eventToRequest,
+    responseToResult,
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "itty-lambda",
+  "version": "1.0.1",
+  "description": "AWS Lambda support for itty-router",
+  "author": "Evan Kaufman <evan@evanskaufman.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvanK/itty-lambda.git"
+  },
+  "bugs": {
+    "url": "https://github.com/EvanK/itty-lambda/issues"
+  },
+  "homepage": "https://github.com/EvanK/itty-lambda",
+  "keywords": [
+    "itty-router",
+    "router",
+    "aws-lambda"
+  ],
+  "files": [
+    "build/**/*.js"
+  ],
+  "exports": {
+    ".": {
+      "require": "./build/cjs/index.js",
+      "import": "./build/esm/index.js"
+    },
+    "./url": {
+      "require": "./build/cjs/url.js",
+      "import": "./build/esm/url.js"
+    },
+    "./ag": {
+      "require": "./build/cjs/ag.js",
+      "import": "./build/esm/ag.js"
+    },
+    "./alb": {
+      "require": "./build/cjs/alb.js",
+      "import": "./build/esm/alb.js"
+    }
+  },
+  "scripts": {
+    "docs": "npm run docs-html && npm run docs-md",
+    "docs-html": "typedoc --options typedoc.html.json",
+    "docs-md": "typedoc --options typedoc.md.json",
+    "link": "npm link && npm link itty-lambda",
+    "lint": "eslint ./src/",
+    "test": "nyc mocha ./test/unit/*.test.*js",
+    "tsc": "npm run tsc-cjs && npm run tsc-esm",
+    "tsc-cjs": "tsc --module commonjs --outDir ./build/cjs/",
+    "tsc-esm": "tsc --module nodenext --outDir ./build/esm/"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/aws-lambda": "^8.10.150",
+    "@types/node": "^24.2.0",
+    "chai": "^5.2.1",
+    "eslint": "^9.29.0",
+    "mocha": "^11.7.1",
+    "nyc": "^17.1.0",
+    "sinon": "^21.0.0",
+    "typedoc": "^0.28.8",
+    "typedoc-github-theme": "^0.3.0",
+    "typedoc-plugin-markdown": "^4.8.0",
+    "typedoc-plugin-mdn-links": "^5.0.7",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1"
+  },
+  "dependencies": {
+    "itty-router": "^5.0.0"
+  }
+}