@jaypie/express 1.2.3 → 1.2.4-rc1

package/dist/cjs/index.cjs

@@ -1,12 +1,620 @@
 'use strict';
 
+var node_stream = require('node:stream');
 var errors = require('@jaypie/errors');
 var kit = require('@jaypie/kit');
 var expressCors = require('cors');
 var logger$2 = require('@jaypie/logger');
 var aws = require('@jaypie/aws');
 var datadog = require('@jaypie/datadog');
-var serverlessExpress = require('@codegenie/serverless-express');
+
+//
+//
+// LambdaRequest Class
+//
+/**
+ * Mock IncomingMessage that extends Readable stream.
+ * Provides Express-compatible request interface from Lambda Function URL events.
+ */
+class LambdaRequest extends node_stream.Readable {
+    constructor(options) {
+        super();
+        this.httpVersion = "1.1";
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 1;
+        this.complete = false;
+        this.baseUrl = "";
+        this.params = {};
+        this.query = {};
+        this.bodyPushed = false;
+        this.method = options.method;
+        this.url = options.url;
+        this.originalUrl = options.url;
+        this.path = options.url.split("?")[0];
+        this.headers = this.normalizeHeaders(options.headers);
+        this.bodyBuffer = options.body ?? null;
+        // Store Lambda context
+        this._lambdaContext = options.lambdaContext;
+        this._lambdaEvent = options.lambdaEvent;
+        // Create mock socket
+        this.socket = {
+            destroy: () => { },
+            encrypted: options.protocol === "https",
+            remoteAddress: options.remoteAddress,
+        };
+        this.connection = this.socket;
+    }
+    //
+    // Readable stream implementation
+    //
+    _read() {
+        if (!this.bodyPushed) {
+            if (this.bodyBuffer && this.bodyBuffer.length > 0) {
+                this.push(this.bodyBuffer);
+            }
+            this.push(null); // Signal end of stream
+            this.bodyPushed = true;
+            this.complete = true;
+        }
+    }
+    //
+    // Express helper methods
+    //
+    get(headerName) {
+        const key = headerName.toLowerCase();
+        const value = this.headers[key];
+        return Array.isArray(value) ? value[0] : value;
+    }
+    header(headerName) {
+        return this.get(headerName);
+    }
+    //
+    // Private helpers
+    //
+    normalizeHeaders(headers) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            normalized[key.toLowerCase()] = value;
+        }
+        return normalized;
+    }
+}
+//
+//
+// Type Guards
+//
+/**
+ * Check if event is a Function URL / HTTP API v2 event.
+ */
+function isFunctionUrlEvent(event) {
+    return "requestContext" in event && "http" in event.requestContext;
+}
+/**
+ * Check if event is an API Gateway REST API v1 event.
+ */
+function isApiGatewayV1Event(event) {
+    return "httpMethod" in event;
+}
+//
+//
+// Factory Function
+//
+/**
+ * Create a LambdaRequest from a Lambda event (Function URL, HTTP API v2, or REST API v1).
+ */
+function createLambdaRequest(event, context) {
+    let url;
+    let method;
+    let protocol;
+    let remoteAddress;
+    const headers = { ...event.headers };
+    if (isFunctionUrlEvent(event)) {
+        // Function URL / HTTP API v2 format
+        url = event.rawQueryString
+            ? `${event.rawPath}?${event.rawQueryString}`
+            : event.rawPath;
+        method = event.requestContext.http.method;
+        protocol = event.requestContext.http.protocol.split("/")[0].toLowerCase();
+        remoteAddress = event.requestContext.http.sourceIp;
+        // Normalize cookies into Cookie header if not already present
+        if (event.cookies && event.cookies.length > 0 && !headers.cookie) {
+            headers.cookie = event.cookies.join("; ");
+        }
+    }
+    else if (isApiGatewayV1Event(event)) {
+        // API Gateway REST API v1 format
+        const queryParams = event.queryStringParameters;
+        if (queryParams && Object.keys(queryParams).length > 0) {
+            const queryString = new URLSearchParams(queryParams).toString();
+            url = `${event.path}?${queryString}`;
+        }
+        else {
+            url = event.path;
+        }
+        method = event.httpMethod;
+        protocol = event.requestContext.protocol.split("/")[0].toLowerCase();
+        remoteAddress = event.requestContext.identity.sourceIp;
+    }
+    else {
+        throw new Error("Unsupported Lambda event format. Expected Function URL, HTTP API v2, or REST API v1 event.");
+    }
+    // Decode body if present
+    let body = null;
+    if (event.body) {
+        body = event.isBase64Encoded
+            ? Buffer.from(event.body, "base64")
+            : Buffer.from(event.body, "utf8");
+    }
+    return new LambdaRequest({
+        body,
+        headers,
+        lambdaContext: context,
+        lambdaEvent: event,
+        method,
+        protocol,
+        remoteAddress,
+        url,
+    });
+}
+
+//
+//
+// Constants
+//
+const BINARY_CONTENT_TYPE_PATTERNS = [
+    /^application\/octet-stream$/,
+    /^application\/pdf$/,
+    /^application\/zip$/,
+    /^audio\//,
+    /^font\//,
+    /^image\//,
+    /^video\//,
+];
+//
+//
+// LambdaResponseBuffered Class
+//
+/**
+ * Mock ServerResponse that buffers the response.
+ * Collects status, headers, and body chunks, then returns a Lambda response.
+ */
+class LambdaResponseBuffered extends node_stream.Writable {
+    constructor() {
+        super();
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        // Mock socket to satisfy Express/finalhandler checks
+        this.socket = {
+            remoteAddress: "127.0.0.1",
+        };
+        this._chunks = [];
+        this._headers = new Map();
+        this._headersSent = false;
+        this._resolve = null;
+    }
+    //
+    // Promise-based API for getting final result
+    //
+    getResult() {
+        return new Promise((resolve) => {
+            if (this.writableEnded) {
+                resolve(this.buildResult());
+            }
+            else {
+                this._resolve = resolve;
+            }
+        });
+    }
+    //
+    // Header management
+    //
+    setHeader(name, value) {
+        if (this._headersSent) {
+            // In production, log warning but don't throw to match Express behavior
+            return this;
+        }
+        this._headers.set(name.toLowerCase(), String(value));
+        return this;
+    }
+    getHeader(name) {
+        return this._headers.get(name.toLowerCase());
+    }
+    removeHeader(name) {
+        this._headers.delete(name.toLowerCase());
+    }
+    getHeaders() {
+        const headers = {};
+        for (const [key, value] of this._headers) {
+            headers[key] = value;
+        }
+        return headers;
+    }
+    hasHeader(name) {
+        return this._headers.has(name.toLowerCase());
+    }
+    getHeaderNames() {
+        return Array.from(this._headers.keys());
+    }
+    writeHead(statusCode, statusMessageOrHeaders, headers) {
+        this.statusCode = statusCode;
+        let headersToSet;
+        if (typeof statusMessageOrHeaders === "string") {
+            this.statusMessage = statusMessageOrHeaders;
+            headersToSet = headers;
+        }
+        else if (statusMessageOrHeaders &&
+            typeof statusMessageOrHeaders === "object") {
+            headersToSet = statusMessageOrHeaders;
+        }
+        if (headersToSet) {
+            for (const [key, value] of Object.entries(headersToSet)) {
+                if (value !== undefined) {
+                    this.setHeader(key, value);
+                }
+            }
+        }
+        this._headersSent = true;
+        return this;
+    }
+    get headersSent() {
+        return this._headersSent;
+    }
+    //
+    // Express compatibility methods
+    //
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    json(data) {
+        this.setHeader("content-type", "application/json");
+        this.end(JSON.stringify(data));
+        return this;
+    }
+    send(body) {
+        if (typeof body === "object" && !Buffer.isBuffer(body)) {
+            return this.json(body);
+        }
+        this.end(body);
+        return this;
+    }
+    //
+    // Writable stream implementation
+    //
+    _write(chunk, encoding, // eslint-disable-line no-undef
+    callback) {
+        const buffer = Buffer.isBuffer(chunk)
+            ? chunk
+            : Buffer.from(chunk, encoding);
+        this._chunks.push(buffer);
+        this._headersSent = true;
+        callback();
+    }
+    _final(callback) {
+        if (this._resolve) {
+            this._resolve(this.buildResult());
+        }
+        callback();
+    }
+    //
+    // Private helpers
+    //
+    buildResult() {
+        const body = Buffer.concat(this._chunks);
+        const contentType = this.getHeader("content-type") || "";
+        // Determine if response should be base64 encoded
+        const isBase64Encoded = this.isBinaryContentType(contentType);
+        // Build headers object
+        const headers = {};
+        const cookies = [];
+        for (const [key, value] of this._headers) {
+            if (key === "set-cookie") {
+                // Collect Set-Cookie headers for v2 response format
+                if (Array.isArray(value)) {
+                    cookies.push(...value);
+                }
+                else {
+                    cookies.push(value);
+                }
+            }
+            else {
+                headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+            }
+        }
+        const result = {
+            body: isBase64Encoded ? body.toString("base64") : body.toString("utf8"),
+            headers,
+            isBase64Encoded,
+            statusCode: this.statusCode,
+        };
+        // Only include cookies if present (v2 format)
+        if (cookies.length > 0) {
+            result.cookies = cookies;
+        }
+        return result;
+    }
+    isBinaryContentType(contentType) {
+        return BINARY_CONTENT_TYPE_PATTERNS.some((pattern) => pattern.test(contentType));
+    }
+}
+
+//
+//
+// LambdaResponseStreaming Class
+//
+/**
+ * Mock ServerResponse that streams directly to Lambda responseStream.
+ * Uses awslambda.HttpResponseStream.from() to set status and headers.
+ */
+class LambdaResponseStreaming extends node_stream.Writable {
+    constructor(responseStream) {
+        super();
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        // Mock socket to satisfy Express/finalhandler checks
+        this.socket = {
+            remoteAddress: "127.0.0.1",
+        };
+        this._headers = new Map();
+        this._headersSent = false;
+        this._pendingWrites = [];
+        this._wrappedStream = null;
+        this._responseStream = responseStream;
+    }
+    //
+    // Header management
+    //
+    setHeader(name, value) {
+        if (this._headersSent) {
+            // In streaming mode, log warning but don't throw
+            // Headers cannot be changed after body starts
+            return this;
+        }
+        this._headers.set(name.toLowerCase(), String(value));
+        return this;
+    }
+    getHeader(name) {
+        return this._headers.get(name.toLowerCase());
+    }
+    removeHeader(name) {
+        if (!this._headersSent) {
+            this._headers.delete(name.toLowerCase());
+        }
+    }
+    getHeaders() {
+        const headers = {};
+        for (const [key, value] of this._headers) {
+            headers[key] = value;
+        }
+        return headers;
+    }
+    hasHeader(name) {
+        return this._headers.has(name.toLowerCase());
+    }
+    getHeaderNames() {
+        return Array.from(this._headers.keys());
+    }
+    writeHead(statusCode, statusMessageOrHeaders, headers) {
+        if (this._headersSent) {
+            return this;
+        }
+        this.statusCode = statusCode;
+        let headersToSet;
+        if (typeof statusMessageOrHeaders === "string") {
+            this.statusMessage = statusMessageOrHeaders;
+            headersToSet = headers;
+        }
+        else if (statusMessageOrHeaders &&
+            typeof statusMessageOrHeaders === "object") {
+            headersToSet = statusMessageOrHeaders;
+        }
+        if (headersToSet) {
+            for (const [key, value] of Object.entries(headersToSet)) {
+                if (value !== undefined) {
+                    this.setHeader(key, value);
+                }
+            }
+        }
+        this.flushHeaders();
+        return this;
+    }
+    get headersSent() {
+        return this._headersSent;
+    }
+    flushHeaders() {
+        if (this._headersSent)
+            return;
+        const headers = {};
+        for (const [key, value] of this._headers) {
+            headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+        }
+        const metadata = {
+            headers,
+            statusCode: this.statusCode,
+        };
+        // Wrap the stream with metadata using awslambda global
+        this._wrappedStream = awslambda.HttpResponseStream.from(this._responseStream, metadata);
+        this._headersSent = true;
+        // Flush pending writes
+        for (const { callback, chunk } of this._pendingWrites) {
+            this._wrappedStream.write(chunk);
+            callback();
+        }
+        this._pendingWrites = [];
+    }
+    //
+    // Express compatibility methods
+    //
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    json(data) {
+        this.setHeader("content-type", "application/json");
+        this.end(JSON.stringify(data));
+        return this;
+    }
+    send(body) {
+        if (typeof body === "object" && !Buffer.isBuffer(body)) {
+            return this.json(body);
+        }
+        this.end(body);
+        return this;
+    }
+    //
+    // Writable stream implementation
+    //
+    _write(chunk, encoding, // eslint-disable-line no-undef
+    callback) {
+        const buffer = Buffer.isBuffer(chunk)
+            ? chunk
+            : Buffer.from(chunk, encoding);
+        if (!this._headersSent) {
+            // Buffer writes until headers are sent
+            this._pendingWrites.push({ callback: () => callback(), chunk: buffer });
+            // Auto-flush headers on first write
+            this.flushHeaders();
+        }
+        else {
+            this._wrappedStream.write(buffer);
+            callback();
+        }
+    }
+    _final(callback) {
+        if (!this._headersSent) {
+            this.flushHeaders();
+        }
+        this._wrappedStream?.end();
+        callback();
+    }
+}
+
+//
+//
+// Current Invoke Context
+//
+let currentInvoke = null;
+/**
+ * Get the current Lambda invoke context.
+ * Used by getCurrentInvokeUuid adapter to get the request ID.
+ */
+function getCurrentInvoke() {
+    return currentInvoke;
+}
+/**
+ * Set the current Lambda invoke context.
+ * Called at the start of each Lambda invocation.
+ */
+function setCurrentInvoke(event, context) {
+    currentInvoke = { context, event };
+}
+/**
+ * Clear the current Lambda invoke context.
+ * Called at the end of each Lambda invocation.
+ */
+function clearCurrentInvoke() {
+    currentInvoke = null;
+}
+//
+//
+// Express App Runner
+//
+/**
+ * Run Express app with mock request/response.
+ * Returns a promise that resolves when the response is complete.
+ */
+function runExpressApp(app, req, res) {
+    return new Promise((resolve, reject) => {
+        // Listen for response completion
+        res.on("finish", resolve);
+        res.on("error", reject);
+        // Run the Express app
+        // Cast to Express types since our mocks implement the required interface
+        app(req, res);
+    });
+}
+//
+//
+// Buffered Handler Factory
+//
+/**
+ * Create a Lambda handler that buffers the Express response.
+ * Returns the complete response as a Lambda response object.
+ *
+ * @example
+ * ```typescript
+ * import express from "express";
+ * import { createLambdaHandler } from "@jaypie/express";
+ *
+ * const app = express();
+ * app.get("/", (req, res) => res.json({ message: "Hello" }));
+ *
+ * export const handler = createLambdaHandler(app);
+ * ```
+ */
+function createLambdaHandler(app, _options) {
+    return async (event, context) => {
+        try {
+            // Set current invoke for getCurrentInvokeUuid
+            setCurrentInvoke(event, context);
+            // Create mock request from Lambda event
+            const req = createLambdaRequest(event, context);
+            // Create buffered response collector
+            const res = new LambdaResponseBuffered();
+            // Run Express app
+            await runExpressApp(app, req, res);
+            // Return Lambda response
+            return res.getResult();
+        }
+        finally {
+            // Clear current invoke context
+            clearCurrentInvoke();
+        }
+    };
+}
+//
+//
+// Streaming Handler Factory
+//
+/**
+ * Create a Lambda handler that streams the Express response.
+ * Uses awslambda.streamifyResponse() for Lambda response streaming.
+ *
+ * @example
+ * ```typescript
+ * import express from "express";
+ * import { createLambdaStreamHandler } from "@jaypie/express";
+ *
+ * const app = express();
+ * app.get("/stream", (req, res) => {
+ *   res.setHeader("Content-Type", "text/event-stream");
+ *   res.write("data: Hello\n\n");
+ *   res.end();
+ * });
+ *
+ * export const handler = createLambdaStreamHandler(app);
+ * ```
+ */
+function createLambdaStreamHandler(app, _options) {
+    // Wrap with awslambda.streamifyResponse for Lambda streaming
+    // @ts-expect-error awslambda is a Lambda runtime global
+    return awslambda.streamifyResponse(async (event, responseStream, context) => {
+        try {
+            // Set current invoke for getCurrentInvokeUuid
+            setCurrentInvoke(event, context);
+            // Create mock request from Lambda event
+            const req = createLambdaRequest(event, context);
+            // Create streaming response that pipes to Lambda responseStream
+            const res = new LambdaResponseStreaming(responseStream);
+            // Run Express app
+            await runExpressApp(app, req, res);
+        }
+        finally {
+            // Clear current invoke context
+            clearCurrentInvoke();
+        }
+    });
+}
 
 //
 //
@@ -258,40 +866,54 @@ function isWebAdapterMode(req) {
     return false;
 }
 /**
- * Adapter for the "@codegenie/serverless-express" uuid
+ * Get UUID from Jaypie Lambda adapter context.
+ * This is set by createLambdaHandler/createLambdaStreamHandler.
  */
-function getServerlessExpressUuid() {
-    const currentInvoke = serverlessExpress.getCurrentInvoke();
-    if (currentInvoke &&
-        currentInvoke.context &&
-        currentInvoke.context.awsRequestId) {
+function getJaypieAdapterUuid() {
+    const currentInvoke = getCurrentInvoke();
+    if (currentInvoke?.context?.awsRequestId) {
         return currentInvoke.context.awsRequestId;
     }
     return undefined;
 }
+/**
+ * Get UUID from request object if it has Lambda context attached.
+ * The Jaypie adapter attaches _lambdaContext to the request.
+ */
+function getRequestContextUuid(req) {
+    if (req && req._lambdaContext?.awsRequestId) {
+        return req._lambdaContext.awsRequestId;
+    }
+    return undefined;
+}
 //
 //
 // Main
 //
 /**
  * Get the current invoke UUID from Lambda context.
- * Works in both serverless-express mode and Lambda Web Adapter mode.
+ * Works with Jaypie Lambda adapter and Lambda Web Adapter mode.
  *
- * @param req - Optional Express request object. Required for Web Adapter mode
- *              to extract the x-amzn-request-id header.
+ * @param req - Optional Express request object. Used to extract context
+ *              from Web Adapter headers or Jaypie adapter's _lambdaContext.
  * @returns The AWS request ID or undefined if not in Lambda context
  */
 function getCurrentInvokeUuid(req) {
-    // If request is provided and has Web Adapter header, use Web Adapter mode
+    // Priority 1: Web Adapter mode (header-based)
     if (isWebAdapterMode(req)) {
         return getWebAdapterUuid(req);
     }
-    // Try serverless-express mode first
-    const serverlessExpressUuid = getServerlessExpressUuid();
-    if (serverlessExpressUuid) {
-        return serverlessExpressUuid;
+    // Priority 2: Request has Lambda context attached (Jaypie adapter)
+    const requestContextUuid = getRequestContextUuid(req);
+    if (requestContextUuid) {
+        return requestContextUuid;
+    }
+    // Priority 3: Global context from Jaypie adapter
+    const jaypieAdapterUuid = getJaypieAdapterUuid();
+    if (jaypieAdapterUuid) {
+        return jaypieAdapterUuid;
     }
-    // If no request but we might be in Web Adapter mode, try env var fallback
+    // Fallback: Web Adapter env var
     return getWebAdapterUuid();
 }
 
@@ -709,6 +1331,46 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
     };
 }
 
+//
+//
+// Main
+//
+const httpHandler = (statusCode = kit.HTTP.CODE.OK, context = {}) => {
+    // Give a default name if there isn't one
+    if (!context.name) {
+        context.name = "_http";
+    }
+    // Return a function that will be used as an express route
+    return expressHandler(async (req, res) => {
+        // Map the most throwable status codes to errors and throw them!
+        const error = {
+            [kit.HTTP.CODE.BAD_REQUEST]: errors.BadRequestError,
+            [kit.HTTP.CODE.UNAUTHORIZED]: errors.UnauthorizedError,
+            [kit.HTTP.CODE.FORBIDDEN]: errors.ForbiddenError,
+            [kit.HTTP.CODE.NOT_FOUND]: errors.NotFoundError,
+            [kit.HTTP.CODE.METHOD_NOT_ALLOWED]: errors.MethodNotAllowedError,
+            [kit.HTTP.CODE.GONE]: errors.GoneError,
+            [kit.HTTP.CODE.TEAPOT]: errors.TeapotError,
+            [kit.HTTP.CODE.INTERNAL_ERROR]: errors.InternalError,
+            [kit.HTTP.CODE.BAD_GATEWAY]: errors.BadGatewayError,
+            [kit.HTTP.CODE.UNAVAILABLE]: errors.UnavailableError,
+            [kit.HTTP.CODE.GATEWAY_TIMEOUT]: errors.GatewayTimeoutError,
+        };
+        // If this maps to an error, throw it
+        if (error[statusCode]) {
+            logger$2.log.trace(`@knowdev/express: gracefully throwing ${statusCode} up to projectHandler`);
+            throw new error[statusCode]();
+        }
+        // If this is an error and we didn't get thrown, log a warning
+        if (statusCode >= 400) {
+            logger$2.log.warn(`@knowdev/express: status code ${statusCode} not mapped as throwable`);
+        }
+        // Send the response
+        res.status(statusCode);
+        return statusCode === kit.HTTP.CODE.NO_CONTENT ? null : {};
+    }, context);
+};
+
 // Cast logger to extended interface for runtime features not in type definitions
 const logger = logger$2.log;
 //
@@ -939,46 +1601,6 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
     };
 }
 
-//
-//
-// Main
-//
-const httpHandler = (statusCode = kit.HTTP.CODE.OK, context = {}) => {
-    // Give a default name if there isn't one
-    if (!context.name) {
-        context.name = "_http";
-    }
-    // Return a function that will be used as an express route
-    return expressHandler(async (req, res) => {
-        // Map the most throwable status codes to errors and throw them!
-        const error = {
-            [kit.HTTP.CODE.BAD_REQUEST]: errors.BadRequestError,
-            [kit.HTTP.CODE.UNAUTHORIZED]: errors.UnauthorizedError,
-            [kit.HTTP.CODE.FORBIDDEN]: errors.ForbiddenError,
-            [kit.HTTP.CODE.NOT_FOUND]: errors.NotFoundError,
-            [kit.HTTP.CODE.METHOD_NOT_ALLOWED]: errors.MethodNotAllowedError,
-            [kit.HTTP.CODE.GONE]: errors.GoneError,
-            [kit.HTTP.CODE.TEAPOT]: errors.TeapotError,
-            [kit.HTTP.CODE.INTERNAL_ERROR]: errors.InternalError,
-            [kit.HTTP.CODE.BAD_GATEWAY]: errors.BadGatewayError,
-            [kit.HTTP.CODE.UNAVAILABLE]: errors.UnavailableError,
-            [kit.HTTP.CODE.GATEWAY_TIMEOUT]: errors.GatewayTimeoutError,
-        };
-        // If this maps to an error, throw it
-        if (error[statusCode]) {
-            logger$2.log.trace(`@knowdev/express: gracefully throwing ${statusCode} up to projectHandler`);
-            throw new error[statusCode]();
-        }
-        // If this is an error and we didn't get thrown, log a warning
-        if (statusCode >= 400) {
-            logger$2.log.warn(`@knowdev/express: status code ${statusCode} not mapped as throwable`);
-        }
-        // Send the response
-        res.status(statusCode);
-        return statusCode === kit.HTTP.CODE.NO_CONTENT ? null : {};
-    }, context);
-};
-
 //
 //
 // Main
@@ -1033,14 +1655,20 @@ const notFoundRoute = routes.notFoundRoute;
 const notImplementedRoute = routes.notImplementedRoute;
 
 exports.EXPRESS = EXPRESS;
+exports.LambdaRequest = LambdaRequest;
+exports.LambdaResponseBuffered = LambdaResponseBuffered;
+exports.LambdaResponseStreaming = LambdaResponseStreaming;
 exports.badRequestRoute = badRequestRoute;
 exports.cors = cors;
+exports.createLambdaHandler = createLambdaHandler;
+exports.createLambdaStreamHandler = createLambdaStreamHandler;
 exports.createServer = createServer;
 exports.echoRoute = echoRoute;
 exports.expressHandler = expressHandler;
 exports.expressHttpCodeHandler = httpHandler;
 exports.expressStreamHandler = expressStreamHandler;
 exports.forbiddenRoute = forbiddenRoute;
+exports.getCurrentInvoke = getCurrentInvoke;
 exports.getCurrentInvokeUuid = getCurrentInvokeUuid;
 exports.goneRoute = goneRoute;
 exports.methodNotAllowedRoute = methodNotAllowedRoute;