@jaypie/express 1.2.2 → 1.2.4-rc0

package/dist/esm/index.js

@@ -1,10 +1,584 @@
+import { Readable, Writable } from 'node:stream';
 import { CorsError, BadRequestError, UnhandledError, GatewayTimeoutError, UnavailableError, BadGatewayError, InternalError, TeapotError, GoneError, MethodNotAllowedError, NotFoundError, ForbiddenError, UnauthorizedError, NotImplementedError } from '@jaypie/errors';
 import { force, envBoolean, JAYPIE, HTTP, getHeaderFrom, jaypieHandler } from '@jaypie/kit';
 import expressCors from 'cors';
-import { loadEnvSecrets } from '@jaypie/aws';
 import { log } from '@jaypie/logger';
+import { loadEnvSecrets } from '@jaypie/aws';
 import { hasDatadogEnv, submitMetric, DATADOG } from '@jaypie/datadog';
-import { getCurrentInvoke } from '@codegenie/serverless-express';
+
+//
+//
+// LambdaRequest Class
+//
+/**
+ * Mock IncomingMessage that extends Readable stream.
+ * Provides Express-compatible request interface from Lambda Function URL events.
+ */
+class LambdaRequest extends 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;
+    }
+}
+//
+//
+// Factory Function
+//
+/**
+ * Create a LambdaRequest from a Function URL event.
+ */
+function createLambdaRequest(event, context) {
+    // Build URL with query string
+    const url = event.rawQueryString
+        ? `${event.rawPath}?${event.rawQueryString}`
+        : event.rawPath;
+    // Decode body if present
+    let body = null;
+    if (event.body) {
+        body = event.isBase64Encoded
+            ? Buffer.from(event.body, "base64")
+            : Buffer.from(event.body, "utf8");
+    }
+    // Normalize cookies into Cookie header if not already present
+    const headers = { ...event.headers };
+    if (event.cookies && event.cookies.length > 0 && !headers.cookie) {
+        headers.cookie = event.cookies.join("; ");
+    }
+    return new LambdaRequest({
+        body,
+        headers,
+        lambdaContext: context,
+        lambdaEvent: event,
+        method: event.requestContext.http.method,
+        protocol: event.requestContext.http.protocol.split("/")[0].toLowerCase(),
+        remoteAddress: event.requestContext.http.sourceIp,
+        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 Writable {
+    constructor() {
+        super();
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        // Mock socket to satisfy Express/finalhandler checks
+        this.socket = {
+            cork: () => { },
+            destroy: () => { },
+            remoteAddress: "127.0.0.1",
+            uncork: () => { },
+            writable: true,
+        };
+        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 Writable {
+    constructor(responseStream) {
+        super();
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        // Mock socket to satisfy Express/finalhandler checks
+        this.socket = {
+            cork: () => { },
+            destroy: () => { },
+            remoteAddress: "127.0.0.1",
+            uncork: () => { },
+            writable: true,
+        };
+        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();
+        }
+    });
+}
 
 //
 //
@@ -92,7 +666,7 @@ const corsHelper = (config = {}) => {
     };
     return expressCors(options);
 };
-var cors_helper = (config) => {
+var cors = (config) => {
     const cors = corsHelper(config);
     return (req, res, next) => {
         cors(req, res, (error) => {
@@ -107,25 +681,205 @@ var cors_helper = (config) => {
     };
 };
 
+//
+//
+// Constants
+//
+const DEFAULT_PORT = 8080;
+//
+//
+// Main
+//
+/**
+ * Creates and starts an Express server with standard Jaypie middleware.
+ *
+ * Features:
+ * - CORS handling (configurable)
+ * - JSON body parsing
+ * - Listens on PORT env var (default 8080)
+ *
+ * Usage:
+ * ```ts
+ * import express from "express";
+ * import { createServer, expressHandler } from "@jaypie/express";
+ *
+ * const app = express();
+ *
+ * app.get("/", expressHandler(async (req, res) => {
+ *   return { message: "Hello World" };
+ * }));
+ *
+ * const { server, port } = await createServer(app);
+ * console.log(`Server running on port ${port}`);
+ * ```
+ *
+ * @param app - Express application instance
+ * @param options - Server configuration options
+ * @returns Promise resolving to server instance and port
+ */
+async function createServer(app, options = {}) {
+    const { cors: corsConfig, jsonLimit = "1mb", middleware = [], port: portOption, } = options;
+    // Determine port
+    const port = typeof portOption === "string"
+        ? parseInt(portOption, 10)
+        : (portOption ?? parseInt(process.env.PORT || String(DEFAULT_PORT), 10));
+    // Apply CORS middleware (unless explicitly disabled)
+    if (corsConfig !== false) {
+        app.use(cors(corsConfig));
+    }
+    // Apply JSON body parser
+    // Note: We use dynamic import to avoid requiring express as a direct dependency
+    const express = await import('express');
+    app.use(express.json({ limit: jsonLimit }));
+    // Apply additional middleware
+    for (const mw of middleware) {
+        app.use(mw);
+    }
+    // Start server
+    return new Promise((resolve, reject) => {
+        try {
+            const server = app.listen(port, () => {
+                // Get the actual port (important when port 0 is passed to get an ephemeral port)
+                const address = server.address();
+                const actualPort = address?.port ?? port;
+                log.info(`Server listening on port ${actualPort}`);
+                resolve({ port: actualPort, server });
+            });
+            server.on("error", (error) => {
+                log.error("Server error", { error });
+                reject(error);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+
+//
+//
+// Constants
+//
+const HEADER_AMZN_REQUEST_ID$1 = "x-amzn-request-id";
+const ENV_AMZN_TRACE_ID = "_X_AMZN_TRACE_ID";
 //
 //
 // Helper Functions
 //
-// Adapter for the "@codegenie/serverless-express" uuid
-function getServerlessExpressUuid() {
+/**
+ * Extract request ID from X-Ray trace ID environment variable
+ * Format: Root=1-5e6b4a90-example;Parent=example;Sampled=1
+ * We extract the trace ID from the Root segment
+ */
+function parseTraceId(traceId) {
+    if (!traceId)
+        return undefined;
+    // Extract the Root segment (format: Root=1-{timestamp}-{uuid})
+    const rootMatch = traceId.match(/Root=([^;]+)/);
+    if (rootMatch && rootMatch[1]) {
+        return rootMatch[1];
+    }
+    return undefined;
+}
+//
+//
+// Main
+//
+/**
+ * Get the current invoke UUID from Lambda Web Adapter context.
+ * This function extracts the request ID from either:
+ * 1. The x-amzn-request-id header (set by Lambda Web Adapter)
+ * 2. The _X_AMZN_TRACE_ID environment variable (set by Lambda runtime)
+ *
+ * @param req - Optional Express request object to extract headers from
+ * @returns The AWS request ID or undefined if not in Lambda context
+ */
+function getWebAdapterUuid(req) {
+    // First, try to get from request headers
+    if (req && req.headers) {
+        const headerValue = req.headers[HEADER_AMZN_REQUEST_ID$1];
+        if (headerValue) {
+            return Array.isArray(headerValue) ? headerValue[0] : headerValue;
+        }
+    }
+    // Fall back to environment variable (X-Ray trace ID)
+    const traceId = process.env[ENV_AMZN_TRACE_ID];
+    if (traceId) {
+        return parseTraceId(traceId);
+    }
+    return undefined;
+}
+
+//
+//
+// Constants
+//
+const HEADER_AMZN_REQUEST_ID = "x-amzn-request-id";
+//
+//
+// Helper Functions
+//
+/**
+ * Detect if we're running in Lambda Web Adapter mode.
+ * Web Adapter sets the x-amzn-request-id header on requests.
+ */
+function isWebAdapterMode(req) {
+    if (req && req.headers && req.headers[HEADER_AMZN_REQUEST_ID]) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get UUID from Jaypie Lambda adapter context.
+ * This is set by createLambdaHandler/createLambdaStreamHandler.
+ */
+function getJaypieAdapterUuid() {
     const currentInvoke = getCurrentInvoke();
-    if (currentInvoke &&
-        currentInvoke.context &&
-        currentInvoke.context.awsRequestId) {
+    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
 //
-const getCurrentInvokeUuid = () => getServerlessExpressUuid();
+/**
+ * Get the current invoke UUID from Lambda context.
+ * Works with Jaypie Lambda adapter and Lambda Web Adapter mode.
+ *
+ * @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) {
+    // Priority 1: Web Adapter mode (header-based)
+    if (isWebAdapterMode(req)) {
+        return getWebAdapterUuid(req);
+    }
+    // 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;
+    }
+    // Fallback: Web Adapter env var
+    return getWebAdapterUuid();
+}
 
 //
 //
@@ -287,7 +1041,7 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
             lib: JAYPIE.LIB.EXPRESS,
         });
         // Update the public logger with the request ID
-        const invokeUuid = getCurrentInvokeUuid();
+        const invokeUuid = getCurrentInvokeUuid(req);
         if (invokeUuid) {
             logger$1.tag({ invoke: invokeUuid });
             logger$1.tag({ shortInvoke: invokeUuid.slice(0, 8) });
@@ -541,6 +1295,46 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
     };
 }
 
+//
+//
+// Main
+//
+const httpHandler = (statusCode = 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 = {
+            [HTTP.CODE.BAD_REQUEST]: BadRequestError,
+            [HTTP.CODE.UNAUTHORIZED]: UnauthorizedError,
+            [HTTP.CODE.FORBIDDEN]: ForbiddenError,
+            [HTTP.CODE.NOT_FOUND]: NotFoundError,
+            [HTTP.CODE.METHOD_NOT_ALLOWED]: MethodNotAllowedError,
+            [HTTP.CODE.GONE]: GoneError,
+            [HTTP.CODE.TEAPOT]: TeapotError,
+            [HTTP.CODE.INTERNAL_ERROR]: InternalError,
+            [HTTP.CODE.BAD_GATEWAY]: BadGatewayError,
+            [HTTP.CODE.UNAVAILABLE]: UnavailableError,
+            [HTTP.CODE.GATEWAY_TIMEOUT]: GatewayTimeoutError,
+        };
+        // If this maps to an error, throw it
+        if (error[statusCode]) {
+            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) {
+            log.warn(`@knowdev/express: status code ${statusCode} not mapped as throwable`);
+        }
+        // Send the response
+        res.status(statusCode);
+        return statusCode === HTTP.CODE.NO_CONTENT ? null : {};
+    }, context);
+};
+
 // Cast logger to extended interface for runtime features not in type definitions
 const logger = log;
 //
@@ -609,7 +1403,7 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
             lib: JAYPIE.LIB.EXPRESS,
         });
         // Update the public logger with the request ID
-        const invokeUuid = getCurrentInvokeUuid();
+        const invokeUuid = getCurrentInvokeUuid(req);
         if (invokeUuid) {
             logger.tag({ invoke: invokeUuid });
             logger.tag({ shortInvoke: invokeUuid.slice(0, 8) });
@@ -771,46 +1565,6 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
     };
 }
 
-//
-//
-// Main
-//
-const httpHandler = (statusCode = 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 = {
-            [HTTP.CODE.BAD_REQUEST]: BadRequestError,
-            [HTTP.CODE.UNAUTHORIZED]: UnauthorizedError,
-            [HTTP.CODE.FORBIDDEN]: ForbiddenError,
-            [HTTP.CODE.NOT_FOUND]: NotFoundError,
-            [HTTP.CODE.METHOD_NOT_ALLOWED]: MethodNotAllowedError,
-            [HTTP.CODE.GONE]: GoneError,
-            [HTTP.CODE.TEAPOT]: TeapotError,
-            [HTTP.CODE.INTERNAL_ERROR]: InternalError,
-            [HTTP.CODE.BAD_GATEWAY]: BadGatewayError,
-            [HTTP.CODE.UNAVAILABLE]: UnavailableError,
-            [HTTP.CODE.GATEWAY_TIMEOUT]: GatewayTimeoutError,
-        };
-        // If this maps to an error, throw it
-        if (error[statusCode]) {
-            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) {
-            log.warn(`@knowdev/express: status code ${statusCode} not mapped as throwable`);
-        }
-        // Send the response
-        res.status(statusCode);
-        return statusCode === HTTP.CODE.NO_CONTENT ? null : {};
-    }, context);
-};
-
 //
 //
 // Main
@@ -864,5 +1618,5 @@ const noContentRoute = routes.noContentRoute;
 const notFoundRoute = routes.notFoundRoute;
 const notImplementedRoute = routes.notImplementedRoute;
 
-export { EXPRESS, badRequestRoute, cors_helper as cors, echoRoute, expressHandler, httpHandler as expressHttpCodeHandler, expressStreamHandler, forbiddenRoute, goneRoute, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute };
+export { EXPRESS, LambdaRequest, LambdaResponseBuffered, LambdaResponseStreaming, badRequestRoute, cors, createLambdaHandler, createLambdaStreamHandler, createServer, echoRoute, expressHandler, httpHandler as expressHttpCodeHandler, expressStreamHandler, forbiddenRoute, getCurrentInvoke, getCurrentInvokeUuid, goneRoute, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute };
 //# sourceMappingURL=index.js.map