@jaypie/express 1.2.2 → 1.2.3

package/dist/cjs/createServer.d.ts

@@ -0,0 +1,60 @@
+import type { Application, RequestHandler } from "express";
+import type { Server } from "http";
+import type { CorsConfig } from "./cors.helper.js";
+export interface CreateServerOptions {
+    /**
+     * CORS configuration. Pass false to disable CORS middleware.
+     */
+    cors?: CorsConfig | false;
+    /**
+     * JSON body parser limit. Defaults to "1mb".
+     */
+    jsonLimit?: string;
+    /**
+     * Additional middleware to apply before routes.
+     */
+    middleware?: RequestHandler[];
+    /**
+     * Port to listen on. Defaults to PORT env var or 8080.
+     */
+    port?: number | string;
+}
+export interface ServerResult {
+    /**
+     * The HTTP server instance.
+     */
+    server: Server;
+    /**
+     * The port the server is listening on.
+     */
+    port: number;
+}
+/**
+ * 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
+ */
+declare function createServer(app: Application, options?: CreateServerOptions): Promise<ServerResult>;
+export default createServer;

package/dist/cjs/getCurrentInvokeUuid.adapter.d.ts

@@ -1,2 +1,11 @@
-declare const getCurrentInvokeUuid: () => string | undefined;
+import type { Request } from "express";
+/**
+ * Get the current invoke UUID from Lambda context.
+ * Works in both serverless-express mode and Lambda Web Adapter mode.
+ *
+ * @param req - Optional Express request object. Required for Web Adapter mode
+ *              to extract the x-amzn-request-id header.
+ * @returns The AWS request ID or undefined if not in Lambda context
+ */
+declare function getCurrentInvokeUuid(req?: Request): string | undefined;
 export default getCurrentInvokeUuid;

package/dist/cjs/getCurrentInvokeUuid.webadapter.d.ts

@@ -0,0 +1,12 @@
+import type { Request } from "express";
+/**
+ * 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
+ */
+declare function getWebAdapterUuid(req?: Request): string | undefined;
+export default getWebAdapterUuid;

package/dist/cjs/index.cjs

@@ -3,8 +3,8 @@
 var errors = require('@jaypie/errors');
 var kit = require('@jaypie/kit');
 var expressCors = require('cors');
-var aws = require('@jaypie/aws');
 var logger$2 = require('@jaypie/logger');
+var aws = require('@jaypie/aws');
 var datadog = require('@jaypie/datadog');
 var serverlessExpress = require('@codegenie/serverless-express');
 
@@ -94,7 +94,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) => {
@@ -109,11 +109,157 @@ 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;
+                logger$2.log.info(`Server listening on port ${actualPort}`);
+                resolve({ port: actualPort, server });
+            });
+            server.on("error", (error) => {
+                logger$2.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
+/**
+ * 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;
+}
+/**
+ * Adapter for the "@codegenie/serverless-express" uuid
+ */
 function getServerlessExpressUuid() {
     const currentInvoke = serverlessExpress.getCurrentInvoke();
     if (currentInvoke &&
@@ -127,7 +273,27 @@ function getServerlessExpressUuid() {
 //
 // Main
 //
-const getCurrentInvokeUuid = () => getServerlessExpressUuid();
+/**
+ * Get the current invoke UUID from Lambda context.
+ * Works in both serverless-express mode and Lambda Web Adapter mode.
+ *
+ * @param req - Optional Express request object. Required for Web Adapter mode
+ *              to extract the x-amzn-request-id header.
+ * @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
+    if (isWebAdapterMode(req)) {
+        return getWebAdapterUuid(req);
+    }
+    // Try serverless-express mode first
+    const serverlessExpressUuid = getServerlessExpressUuid();
+    if (serverlessExpressUuid) {
+        return serverlessExpressUuid;
+    }
+    // If no request but we might be in Web Adapter mode, try env var fallback
+    return getWebAdapterUuid();
+}
 
 //
 //
@@ -289,7 +455,7 @@ function expressHandler(handlerOrOptions, optionsOrHandler) {
             lib: kit.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) });
@@ -611,7 +777,7 @@ function expressStreamHandler(handlerOrOptions, optionsOrHandler) {
             lib: kit.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) });
@@ -868,12 +1034,14 @@ const notImplementedRoute = routes.notImplementedRoute;
 
 exports.EXPRESS = EXPRESS;
 exports.badRequestRoute = badRequestRoute;
-exports.cors = cors_helper;
+exports.cors = cors;
+exports.createServer = createServer;
 exports.echoRoute = echoRoute;
 exports.expressHandler = expressHandler;
 exports.expressHttpCodeHandler = httpHandler;
 exports.expressStreamHandler = expressStreamHandler;
 exports.forbiddenRoute = forbiddenRoute;
+exports.getCurrentInvokeUuid = getCurrentInvokeUuid;
 exports.goneRoute = goneRoute;
 exports.methodNotAllowedRoute = methodNotAllowedRoute;
 exports.noContentRoute = noContentRoute;