@jaypie/express 1.2.2 → 1.2.4-rc0

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

@@ -0,0 +1,53 @@
+import type { IncomingHttpHeaders } from "node:http";
+import { Readable } from "node:stream";
+import type { FunctionUrlEvent, LambdaContext } from "./types.js";
+interface LambdaRequestOptions {
+    body?: Buffer | null;
+    headers: Record<string, string>;
+    lambdaContext: LambdaContext;
+    lambdaEvent: FunctionUrlEvent;
+    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: FunctionUrlEvent;
+    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 Function URL event.
+ */
+export declare function createLambdaRequest(event: FunctionUrlEvent, context: LambdaContext): LambdaRequest;
+export default LambdaRequest;

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

@@ -0,0 +1,41 @@
+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: {
+        cork: () => void;
+        destroy: () => void;
+        remoteAddress: string;
+        uncork: () => void;
+        writable: boolean;
+    };
+    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,40 @@
+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: {
+        cork: () => void;
+        destroy: () => void;
+        remoteAddress: string;
+        uncork: () => void;
+        writable: boolean;
+    };
+    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, FunctionUrlEvent, LambdaContext, 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;
+} | 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 { AwsLambdaGlobal, CreateLambdaHandlerOptions, FunctionUrlEvent, HttpResponseStreamMetadata, LambdaContext, LambdaHandler, LambdaHandlerFactory, LambdaResponse, LambdaStreamHandler, LambdaStreamHandlerFactory, ResponseStream, } from "./types.js";

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

@@ -0,0 +1,75 @@
+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 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 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: FunctionUrlEvent, context: LambdaContext) => Promise<LambdaResponse>;
+export type LambdaStreamHandler = (event: FunctionUrlEvent, 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/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 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
+ */
+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;