@jaypie/express 1.2.4-rc0 → 1.2.4-rc2

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

@@ -1,11 +1,11 @@
 import type { IncomingHttpHeaders } from "node:http";
 import { Readable } from "node:stream";
-import type { FunctionUrlEvent, LambdaContext } from "./types.js";
+import type { LambdaContext, LambdaEvent } from "./types.js";
 interface LambdaRequestOptions {
     body?: Buffer | null;
     headers: Record<string, string>;
     lambdaContext: LambdaContext;
-    lambdaEvent: FunctionUrlEvent;
+    lambdaEvent: LambdaEvent;
     method: string;
     protocol: string;
     remoteAddress: string;
@@ -37,7 +37,7 @@ export declare class LambdaRequest extends Readable {
     params: Record<string, string>;
     query: Record<string, unknown>;
     readonly _lambdaContext: LambdaContext;
-    readonly _lambdaEvent: FunctionUrlEvent;
+    readonly _lambdaEvent: LambdaEvent;
     private bodyBuffer;
     private bodyPushed;
     constructor(options: LambdaRequestOptions);
@@ -47,7 +47,7 @@ export declare class LambdaRequest extends Readable {
     private normalizeHeaders;
 }
 /**
- * Create a LambdaRequest from a Function URL event.
+ * Create a LambdaRequest from a Lambda event (Function URL, HTTP API v2, or REST API v1).
  */
-export declare function createLambdaRequest(event: FunctionUrlEvent, context: LambdaContext): LambdaRequest;
+export declare function createLambdaRequest(event: LambdaEvent, context: LambdaContext): LambdaRequest;
 export default LambdaRequest;

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

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

package/dist/cjs/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/cjs/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/cjs/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/cjs/index.cjs

@@ -81,16 +81,63 @@ class LambdaRequest extends node_stream.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) {
@@ -98,19 +145,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,
     });
 }
@@ -143,11 +185,7 @@ class LambdaResponseBuffered extends node_stream.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();
@@ -315,11 +353,7 @@ class LambdaResponseStreaming extends node_stream.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;