@jaypie/express 1.2.3 → 1.2.4-rc1

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

@@ -0,0 +1,53 @@
+import type { IncomingHttpHeaders } from "node:http";
+import { Readable } from "node:stream";
+import type { LambdaContext, LambdaEvent } from "./types.js";
+interface LambdaRequestOptions {
+    body?: Buffer | null;
+    headers: Record<string, string>;
+    lambdaContext: LambdaContext;
+    lambdaEvent: LambdaEvent;
+    method: string;
+    protocol: string;
+    remoteAddress: string;
+    url: string;
+}
+interface MockSocket {
+    destroy: () => void;
+    encrypted: boolean;
+    remoteAddress: string;
+}
+/**
+ * Mock IncomingMessage that extends Readable stream.
+ * Provides Express-compatible request interface from Lambda Function URL events.
+ */
+export declare class LambdaRequest extends Readable {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: IncomingHttpHeaders;
+    readonly httpVersion: string;
+    readonly httpVersionMajor: number;
+    readonly httpVersionMinor: number;
+    complete: boolean;
+    readonly socket: MockSocket;
+    readonly connection: MockSocket;
+    readonly originalUrl: string;
+    readonly path: string;
+    baseUrl: string;
+    body: unknown;
+    params: Record<string, string>;
+    query: Record<string, unknown>;
+    readonly _lambdaContext: LambdaContext;
+    readonly _lambdaEvent: LambdaEvent;
+    private bodyBuffer;
+    private bodyPushed;
+    constructor(options: LambdaRequestOptions);
+    _read(): void;
+    get(headerName: string): string | undefined;
+    header(headerName: string): string | undefined;
+    private normalizeHeaders;
+}
+/**
+ * Create a LambdaRequest from a Lambda event (Function URL, HTTP API v2, or REST API v1).
+ */
+export declare function createLambdaRequest(event: LambdaEvent, context: LambdaContext): LambdaRequest;
+export default LambdaRequest;

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

@@ -0,0 +1,37 @@
+import type { OutgoingHttpHeaders } from "node:http";
+import { Writable } from "node:stream";
+import type { LambdaResponse } from "./types.js";
+/**
+ * Mock ServerResponse that buffers the response.
+ * Collects status, headers, and body chunks, then returns a Lambda response.
+ */
+export declare class LambdaResponseBuffered extends Writable {
+    statusCode: number;
+    statusMessage: string;
+    readonly socket: {
+        remoteAddress: string;
+    };
+    private _chunks;
+    private _headers;
+    private _headersSent;
+    private _resolve;
+    constructor();
+    getResult(): Promise<LambdaResponse>;
+    setHeader(name: string, value: number | string | string[]): this;
+    getHeader(name: string): number | string | string[] | undefined;
+    removeHeader(name: string): void;
+    getHeaders(): OutgoingHttpHeaders;
+    hasHeader(name: string): boolean;
+    getHeaderNames(): string[];
+    writeHead(statusCode: number, statusMessageOrHeaders?: OutgoingHttpHeaders | string, headers?: OutgoingHttpHeaders): this;
+    get headersSent(): boolean;
+    status(code: number): this;
+    json(data: unknown): this;
+    send(body?: Buffer | object | string): this;
+    _write(chunk: Buffer | string, encoding: BufferEncoding, // eslint-disable-line no-undef
+    callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    private buildResult;
+    private isBinaryContentType;
+}
+export default LambdaResponseBuffered;

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

@@ -0,0 +1,36 @@
+import type { OutgoingHttpHeaders } from "node:http";
+import { Writable } from "node:stream";
+import type { ResponseStream } from "./types.js";
+/**
+ * Mock ServerResponse that streams directly to Lambda responseStream.
+ * Uses awslambda.HttpResponseStream.from() to set status and headers.
+ */
+export declare class LambdaResponseStreaming extends Writable {
+    statusCode: number;
+    statusMessage: string;
+    readonly socket: {
+        remoteAddress: string;
+    };
+    private _headers;
+    private _headersSent;
+    private _pendingWrites;
+    private _responseStream;
+    private _wrappedStream;
+    constructor(responseStream: ResponseStream);
+    setHeader(name: string, value: number | string | string[]): this;
+    getHeader(name: string): number | string | string[] | undefined;
+    removeHeader(name: string): void;
+    getHeaders(): OutgoingHttpHeaders;
+    hasHeader(name: string): boolean;
+    getHeaderNames(): string[];
+    writeHead(statusCode: number, statusMessageOrHeaders?: OutgoingHttpHeaders | string, headers?: OutgoingHttpHeaders): this;
+    get headersSent(): boolean;
+    flushHeaders(): void;
+    status(code: number): this;
+    json(data: unknown): this;
+    send(body?: Buffer | object | string): this;
+    _write(chunk: Buffer | string, encoding: BufferEncoding, // eslint-disable-line no-undef
+    callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+}
+export default LambdaResponseStreaming;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/cjs/adapter/__tests__/LambdaResponseStreaming.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/adapter/__tests__/integration.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,50 @@
+import type { Application } from "express";
+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: LambdaEvent;
+} | null;
+/**
+ * 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);
+ * ```
+ */
+export declare function createLambdaHandler(app: Application, _options?: CreateLambdaHandlerOptions): LambdaHandler;
+/**
+ * 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);
+ * ```
+ */
+export declare function createLambdaStreamHandler(app: Application, _options?: CreateLambdaHandlerOptions): LambdaStreamHandler;
+export { LambdaRequest, createLambdaRequest } from "./LambdaRequest.js";
+export { LambdaResponseBuffered } from "./LambdaResponseBuffered.js";
+export { LambdaResponseStreaming } from "./LambdaResponseStreaming.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

@@ -0,0 +1,107 @@
+import type { Application } from "express";
+export interface LambdaContext {
+    awsRequestId: string;
+    callbackWaitsForEmptyEventLoop?: boolean;
+    functionName?: string;
+    functionVersion?: string;
+    invokedFunctionArn?: string;
+    logGroupName?: string;
+    logStreamName?: string;
+    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[];
+    headers: Record<string, string>;
+    isBase64Encoded: boolean;
+    rawPath: string;
+    rawQueryString: string;
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        domainName: string;
+        domainPrefix: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+            sourceIp: string;
+            userAgent: string;
+        };
+        requestId: string;
+        routeKey: string;
+        stage: string;
+        time: string;
+        timeEpoch: number;
+    };
+    routeKey: string;
+    version: "2.0";
+}
+export type LambdaEvent = ApiGatewayV1Event | FunctionUrlEvent;
+export interface LambdaResponse {
+    body: string;
+    cookies?: string[];
+    headers: Record<string, string>;
+    isBase64Encoded: boolean;
+    statusCode: number;
+}
+export interface ResponseStream {
+    end(): void;
+    write(chunk: string | Uint8Array): void;
+}
+export interface HttpResponseStreamMetadata {
+    headers: Record<string, string>;
+    statusCode: number;
+}
+/**
+ * Global awslambda object provided by Lambda runtime.
+ * This is only available when running in AWS Lambda.
+ */
+export interface AwsLambdaGlobal {
+    HttpResponseStream: {
+        from(stream: ResponseStream, metadata: HttpResponseStreamMetadata): ResponseStream;
+    };
+    streamifyResponse<TEvent = unknown>(handler: (event: TEvent, responseStream: ResponseStream, context: LambdaContext) => Promise<void>): (event: TEvent, 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
+     */
+    name?: string;
+};
+export type LambdaHandlerFactory = (app: Application, options?: CreateLambdaHandlerOptions) => LambdaHandler;
+export type LambdaStreamHandlerFactory = (app: Application, options?: CreateLambdaHandlerOptions) => LambdaStreamHandler;

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

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