@jaypie/express 1.2.4-rc0 → 1.2.4-rc2

package/dist/esm/adapter/LambdaResponseStreaming.d.ts

@@ -9,11 +9,7 @@ export declare class LambdaResponseStreaming extends Writable {
     statusCode: number;
     statusMessage: string;
     readonly socket: {
-        cork: () => void;
-        destroy: () => void;
         remoteAddress: string;
-        uncork: () => void;
-        writable: boolean;
     };
     private _headers;
     private _headersSent;

package/dist/esm/adapter/index.d.ts

@@ -1,12 +1,12 @@
 import type { Application } from "express";
-import type { CreateLambdaHandlerOptions, FunctionUrlEvent, LambdaContext, LambdaHandler, LambdaStreamHandler } from "./types.js";
+import type { CreateLambdaHandlerOptions, LambdaContext, LambdaEvent, LambdaHandler, LambdaStreamHandler } from "./types.js";
 /**
  * Get the current Lambda invoke context.
  * Used by getCurrentInvokeUuid adapter to get the request ID.
  */
 export declare function getCurrentInvoke(): {
     context: LambdaContext;
-    event: FunctionUrlEvent;
+    event: LambdaEvent;
 } | null;
 /**
  * Create a Lambda handler that buffers the Express response.
@@ -47,4 +47,4 @@ export declare function createLambdaStreamHandler(app: Application, _options?: C
 export { LambdaRequest, createLambdaRequest } from "./LambdaRequest.js";
 export { LambdaResponseBuffered } from "./LambdaResponseBuffered.js";
 export { LambdaResponseStreaming } from "./LambdaResponseStreaming.js";
-export type { AwsLambdaGlobal, CreateLambdaHandlerOptions, FunctionUrlEvent, HttpResponseStreamMetadata, LambdaContext, LambdaHandler, LambdaHandlerFactory, LambdaResponse, LambdaStreamHandler, LambdaStreamHandlerFactory, ResponseStream, } from "./types.js";
+export type { ApiGatewayV1Event, AwsLambdaGlobal, CreateLambdaHandlerOptions, FunctionUrlEvent, HttpResponseStreamMetadata, LambdaContext, LambdaEvent, LambdaHandler, LambdaHandlerFactory, LambdaResponse, LambdaStreamHandler, LambdaStreamHandlerFactory, ResponseStream, } from "./types.js";

package/dist/esm/adapter/types.d.ts

@@ -10,6 +10,37 @@ export interface LambdaContext {
     memoryLimitInMB?: string;
     [key: string]: unknown;
 }
+export interface ApiGatewayV1Event {
+    body?: string | null;
+    headers: Record<string, string>;
+    httpMethod: string;
+    isBase64Encoded: boolean;
+    multiValueHeaders?: Record<string, string[]>;
+    multiValueQueryStringParameters?: Record<string, string[]> | null;
+    path: string;
+    pathParameters?: Record<string, string> | null;
+    queryStringParameters?: Record<string, string> | null;
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        domainName?: string;
+        httpMethod: string;
+        identity: {
+            sourceIp: string;
+            userAgent?: string;
+        };
+        path: string;
+        protocol: string;
+        requestId: string;
+        requestTime?: string;
+        requestTimeEpoch?: number;
+        resourceId?: string;
+        resourcePath?: string;
+        stage: string;
+    };
+    resource?: string;
+    stageVariables?: Record<string, string> | null;
+}
 export interface FunctionUrlEvent {
     body?: string;
     cookies?: string[];
@@ -38,6 +69,7 @@ export interface FunctionUrlEvent {
     routeKey: string;
     version: "2.0";
 }
+export type LambdaEvent = ApiGatewayV1Event | FunctionUrlEvent;
 export interface LambdaResponse {
     body: string;
     cookies?: string[];
@@ -63,8 +95,8 @@ export interface AwsLambdaGlobal {
     };
     streamifyResponse<TEvent = unknown>(handler: (event: TEvent, responseStream: ResponseStream, context: LambdaContext) => Promise<void>): (event: TEvent, context: LambdaContext) => Promise<void>;
 }
-export type LambdaHandler = (event: FunctionUrlEvent, context: LambdaContext) => Promise<LambdaResponse>;
-export type LambdaStreamHandler = (event: FunctionUrlEvent, context: LambdaContext) => Promise<void>;
+export type LambdaHandler = (event: LambdaEvent, context: LambdaContext) => Promise<LambdaResponse>;
+export type LambdaStreamHandler = (event: LambdaEvent, context: LambdaContext) => Promise<void>;
 export type CreateLambdaHandlerOptions = {
     /**
      * Optional name for logging and debugging

package/dist/esm/index.d.ts

@@ -1,5 +1,5 @@
 export { createLambdaHandler, createLambdaStreamHandler, getCurrentInvoke, LambdaRequest, LambdaResponseBuffered, LambdaResponseStreaming, } from "./adapter/index.js";
-export type { CreateLambdaHandlerOptions, FunctionUrlEvent, LambdaHandler, LambdaResponse, LambdaStreamHandler, } from "./adapter/index.js";
+export type { ApiGatewayV1Event, CreateLambdaHandlerOptions, FunctionUrlEvent, LambdaContext, LambdaEvent, LambdaHandler, LambdaResponse, LambdaStreamHandler, ResponseStream, } from "./adapter/index.js";
 export { EXPRESS } from "./constants.js";
 export { default as cors } from "./cors.helper.js";
 export type { CorsConfig } from "./cors.helper.js";

package/dist/esm/index.js

@@ -79,16 +79,63 @@ class LambdaRequest extends Readable {
 }
 //
 //
+// 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 Function URL event.
+ * Create a LambdaRequest from a Lambda event (Function URL, HTTP API v2, or REST API v1).
  */
 function createLambdaRequest(event, context) {
-    // Build URL with query string
-    const url = event.rawQueryString
-        ? `${event.rawPath}?${event.rawQueryString}`
-        : event.rawPath;
+    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) {
@@ -96,19 +143,14 @@ function createLambdaRequest(event, context) {
             ? 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,
+        method,
+        protocol,
+        remoteAddress,
         url,
     });
 }
@@ -141,11 +183,7 @@ class LambdaResponseBuffered extends Writable {
         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();
@@ -313,11 +351,7 @@ class LambdaResponseStreaming extends Writable {
         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;