serverless-simple-middleware 0.0.73 → 0.0.75

package/.prettierignore

@@ -1,3 +1,3 @@
-tslint.json
-tsconfig.json
+tslint.json
+tsconfig.json
 package.json

package/README.md

@@ -1,3 +1,3 @@
-# Serverless simple middleware
-
-This is just simple middleware for me to translate the interface of lambda's handler to use `request => response`.
+# Serverless simple middleware
+
+This is just simple middleware for me to translate the interface of lambda's handler to use `request => response`.

package/dist/middleware/base.d.ts

@@ -9,12 +9,16 @@ export declare class HandlerRequest {
     private lazyBody?;
     constructor(event: any, context: any);
     get body(): any;
+    set body(value: any);
     get path(): {
         [key: string]: string | undefined;
     };
     get query(): {
         [key: string]: string | undefined;
     };
+    set query(value: {
+        [key: string]: any;
+    });
     header(key: string): string | undefined;
     records<T, U>(selector?: (each: T) => U): T[] | U[];
 }

package/dist/middleware/base.js

@@ -29,12 +29,18 @@ class HandlerRequest {
         }
         return this.lazyBody || {};
     }
+    set body(value) {
+        this.lazyBody = value;
+    }
     get path() {
         return this.event.pathParameters || {};
     }
     get query() {
         return this.event.queryStringParameters || {};
     }
+    set query(value) {
+        this.event.queryStringParameters = value;
+    }
     header(key) {
         return this.event.headers[key.toLowerCase()];
     }

package/dist/middleware/build.d.ts

@@ -1,3 +1,31 @@
-import { Handler, HandlerAuxBase, HandlerPluginBase } from './base';
-declare const build: <Aux extends HandlerAuxBase>(plugins: Array<HandlerPluginBase<any>>) => (handler: Handler<Aux>) => (event: any, context: any, callback: any) => void;
+import { type ZodError, type ZodSchema } from 'zod';
+import { Handler, HandlerAuxBase, HandlerPluginBase, HandlerRequest, HandlerResponse } from './base';
+declare const build: <Aux extends HandlerAuxBase>(plugins: Array<HandlerPluginBase<any>>) => ((handler: Handler<Aux>) => (event: any, context: any, callback: any) => void) & {
+    withBody: <S>(schema: ZodSchema<S>, handler: (context: {
+        request: Omit<HandlerRequest, "body"> & {
+            body: S;
+        };
+        response: HandlerResponse;
+        aux: Aux;
+    }) => any, onInvalid?: (error: ZodError) => {
+        statusCode: number;
+        body: any;
+    } | Promise<{
+        statusCode: number;
+        body: any;
+    } | void> | void) => (event: any, context: any, callback: any) => void;
+    withQuery: <Q>(schema: ZodSchema<Q>, handler: (context: {
+        request: Omit<HandlerRequest, "query"> & {
+            query: Q;
+        };
+        response: HandlerResponse;
+        aux: Aux;
+    }) => any, onInvalid?: (error: ZodError<Q>) => {
+        statusCode: number;
+        body: any;
+    } | Promise<{
+        statusCode: number;
+        body: any;
+    } | void> | void) => (event: any, context: any, callback: any) => void;
+};
 export default build;

package/dist/middleware/build.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../utils/logger");
+const zod_1 = require("zod");
 const utils_1 = require("../utils");
 const base_1 = require("./base");
 const logger = (0, logger_1.getLogger)(__filename);
@@ -107,8 +108,66 @@ class HandlerProxy {
 // It will break type safety because there is no relation between Aux and Plugin.
 const build = (plugins) => {
     const middleware = new HandlerMiddleware(plugins);
-    return (handler) => (event, context, callback) => {
+    const invoke = (handler) => (event, context, callback) => {
         new HandlerProxy(event, context, callback).call(middleware, handler);
     };
+    /**
+     * @param schema - Zod schema to validate the request body.
+     * @param handler - Handler that receives the validated body.
+     * @param onInvalid - Optional callback to customize invalid responses. If it
+     *   returns `{ statusCode, body }`, that is sent instead of the default zod
+     *   error payload.
+     */
+    const withBody = (schema, handler, onInvalid) => invoke(async ({ request, response, aux }) => {
+        const parsed = schema.safeParse(request.body);
+        if (!parsed.success) {
+            logger.error(`Validation failed: ${(0, utils_1.stringifyError)((0, zod_1.treeifyError)(parsed.error))}`);
+            if (onInvalid) {
+                const result = await onInvalid(parsed.error);
+                if (result) {
+                    return response.fail(result.body, result.statusCode);
+                }
+            }
+            return response.fail((0, zod_1.treeifyError)(parsed.error), 400);
+        }
+        const typedRequest = request;
+        typedRequest.body = parsed.data;
+        return handler({
+            request: typedRequest,
+            response,
+            aux,
+        });
+    });
+    /**
+     * @param schema - Zod schema to validate the request query.
+     * @param handler - Handler that receives the validated query.
+     * @param onInvalid - Optional callback to customize invalid responses. If it
+     *   returns `{ statusCode, body }`, that is sent instead of the default zod
+     *   error payload.
+     */
+    const withQuery = (schema, handler, onInvalid) => invoke(async ({ request, response, aux }) => {
+        const parsed = schema.safeParse(request.query);
+        if (!parsed.success) {
+            logger.error(`Validation failed: ${(0, utils_1.stringifyError)((0, zod_1.treeifyError)(parsed.error))}`);
+            if (onInvalid) {
+                const result = await onInvalid(parsed.error);
+                if (result) {
+                    return response.fail(result.body, result.statusCode);
+                }
+            }
+            return response.fail((0, zod_1.treeifyError)(parsed.error), 400);
+        }
+        const typedRequest = request;
+        typedRequest.query = parsed.data;
+        return handler({
+            request: typedRequest,
+            response,
+            aux,
+        });
+    });
+    return Object.assign(invoke, {
+        withBody,
+        withQuery,
+    });
 };
 exports.default = build;

package/dist/middleware/buildWebSocket.d.ts

@@ -0,0 +1,5 @@
+import type { APIGatewayProxyWebsocketHandlerV2 } from 'aws-lambda';
+import { HandlerPluginBase } from './base';
+import { WebSocketHandler, WebSocketHandlerAuxBase } from './websocketBase';
+declare const buildWebSocket: <Aux extends WebSocketHandlerAuxBase>(plugins: Array<HandlerPluginBase<any>>) => (handler: WebSocketHandler<Aux>) => APIGatewayProxyWebsocketHandlerV2;
+export default buildWebSocket;

package/dist/middleware/buildWebSocket.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const logger_1 = require("../utils/logger");
+const websocketBase_1 = require("./websocketBase");
+const logger = (0, logger_1.getLogger)(__filename);
+class WebSocketHandlerMiddleware {
+    auxPromise;
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+        this.auxPromise = this.createAuxPromise();
+    }
+    createAuxPromise = () => {
+        return !this.plugins || this.plugins.length === 0
+            ? Promise.resolve({}) // tslint:disable-line
+            : Promise.all(this.plugins.map((plugin) => {
+                const maybePromise = plugin.create();
+                return maybePromise instanceof Promise
+                    ? maybePromise
+                    : Promise.resolve(maybePromise);
+            })).then((auxes) => auxes.reduce((all, each) => ({ ...all, ...each }), {}));
+    };
+}
+class WebSocketHandlerProxy {
+    request;
+    aux;
+    result;
+    constructor(event, context) {
+        logger.stupid(`WebSocket event`, event);
+        this.request = new websocketBase_1.WebSocketHandlerRequest(event, context);
+        this.aux = {}; // tslint:disable-line
+        this.result = { statusCode: 200 };
+    }
+    call = async (middleware, handler) => {
+        try {
+            this.aux = await middleware.auxPromise;
+        }
+        catch (error) {
+            logger.error(`Error while initializing plugins' aux: ${(0, utils_1.stringifyError)(error)}`);
+            return {
+                statusCode: 500,
+                body: JSON.stringify(error instanceof Error ? { error: error.message } : error),
+            };
+        }
+        const actualHandler = [this.generateHandlerDelegator(handler)];
+        const beginHandlers = middleware.plugins.map((plugin) => this.generatePluginDelegator(plugin.begin));
+        const endHandlers = middleware.plugins.map((plugin) => this.generatePluginDelegator(plugin.end));
+        const errorHandlers = middleware.plugins.map((plugin) => this.generatePluginDelegator(plugin.error));
+        const iterate = async (handlers) => Promise.all(handlers.map((each) => this.safeCall(each, errorHandlers)));
+        const results = [
+            ...(await iterate(beginHandlers)),
+            ...(await iterate(actualHandler)),
+            ...(await iterate(endHandlers)),
+        ].filter((x) => x);
+        // In test phase, throws any exception if there was.
+        if (process.env.NODE_ENV === 'test') {
+            for (const each of results) {
+                if (each instanceof Error) {
+                    logger.error(`Error occurred: ${(0, utils_1.stringifyError)(each)}`);
+                    throw each;
+                }
+            }
+        }
+        results.forEach((result) => logger.silly(`WebSocket middleware result: ${JSON.stringify(result)}`));
+        return this.result;
+    };
+    safeCall = async (delegator, errorHandlers) => {
+        try {
+            const result = await delegator();
+            return result;
+        }
+        catch (error) {
+            const handled = await this.handleError(error, errorHandlers);
+            return handled;
+        }
+    };
+    generateHandlerDelegator = (handler) => async () => {
+        const maybePromise = handler({
+            request: this.request,
+            response: undefined, // WebSocket doesn't use response
+            aux: this.aux,
+        });
+        const result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+        logger.stupid(`WebSocket handler result`, result);
+        if (result) {
+            this.result = result;
+        }
+        return result;
+    };
+    generatePluginDelegator = (pluginCallback) => async () => {
+        const maybePromise = pluginCallback({
+            request: this.request,
+            response: undefined, // WebSocket doesn't use response (for HTTP plugin compatibility)
+            aux: this.aux,
+        });
+        const result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+        logger.stupid(`WebSocket plugin callback result`, result);
+        return result;
+    };
+    handleError = async (error, errorHandlers) => {
+        logger.error(error);
+        this.request.lastError = error;
+        if (errorHandlers) {
+            for (const handler of errorHandlers) {
+                try {
+                    await handler();
+                }
+                catch (ignorable) {
+                    logger.error(ignorable);
+                }
+            }
+        }
+        this.result = {
+            statusCode: 500,
+            body: JSON.stringify(error instanceof Error ? { error: error.message } : error),
+        };
+        return error;
+    };
+}
+const buildWebSocket = (plugins) => {
+    const middleware = new WebSocketHandlerMiddleware(plugins);
+    return (handler) => async (event, context) => {
+        return new WebSocketHandlerProxy(event, context).call(middleware, handler);
+    };
+};
+exports.default = buildWebSocket;

package/dist/middleware/database/connectionProxy.d.ts

@@ -8,6 +8,7 @@ export declare class ConnectionProxy {
     private connectionInitOnce;
     private initialized;
     private dbName?;
+    private readonly MAX_RETRIES;
     constructor(options: MySQLPluginOptions);
     query: <T>(sql: string, params?: any[]) => Promise<T | undefined>;
     fetch: <T>(sql: string, params?: any[]) => Promise<T[]>;
@@ -23,6 +24,7 @@ export declare class ConnectionProxy {
     destroyConnection: () => void;
     onPluginCreated: () => Promise<void>;
     private prepareConnection;
+    private createConnection;
     private ensureConnectionConfig;
     private changeDatabase;
     private tryToInitializeSchema;

package/dist/middleware/database/connectionProxy.js

@@ -15,6 +15,7 @@ class ConnectionProxy {
     connectionInitOnce = new oncePromise_1.OncePromise();
     initialized;
     dbName;
+    MAX_RETRIES = 1;
     constructor(options) {
         this.options = options;
         if (options.schema && options.schema.database) {
@@ -22,10 +23,11 @@ class ConnectionProxy {
             options.config.database = undefined;
         }
         this.secretsCache = secretsManager_1.SecretsManagerCache.getInstance();
+        if (options.secretsManagerConfig) {
+            this.secretsCache.configure(options.secretsManagerConfig);
+        }
     }
-    query = (sql, params) => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    query = (sql, params) => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         if (process.env.NODE_ENV !== 'test') {
             logger.silly(`Execute query[${sql}] with params[${params}]`);
         }
@@ -41,7 +43,7 @@ class ConnectionProxy {
                 }
             }
         });
-    });
+    })));
     fetch = (sql, params) => this.query(sql, params).then((res) => res || []);
     fetchOne = (sql, params, defaultValue) => this.fetch(sql, params).then((res) => {
         if (res === undefined || res[0] === undefined) {
@@ -50,9 +52,7 @@ class ConnectionProxy {
         }
         return res[0];
     });
-    beginTransaction = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    beginTransaction = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.beginTransaction((err) => {
             if (err) {
                 reject(err);
@@ -60,10 +60,8 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
-    commit = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    })));
+    commit = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.commit((err) => {
             if (err) {
                 reject(err);
@@ -71,10 +69,8 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
-    rollback = () => new Promise(async (resolve, reject) => {
-        const connection = await this.prepareConnection();
-        await this.tryToInitializeSchema(false);
+    })));
+    rollback = () => this.prepareConnection().then((connection) => this.tryToInitializeSchema(false).then(() => new Promise((resolve, reject) => {
         connection.rollback((err) => {
             if (err) {
                 reject(err);
@@ -82,7 +78,7 @@ class ConnectionProxy {
             }
             resolve();
         });
-    });
+    })));
     clearConnection = () => {
         const conn = this.connection;
         this.connection = undefined;
@@ -120,12 +116,40 @@ class ConnectionProxy {
         }
         return await this.connectionInitOnce.run(async () => {
             await this.ensureConnectionConfig();
-            const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
-            conn.connect();
-            this.connection = conn;
+            this.connection = await this.createConnection(this.MAX_RETRIES);
             return this.connection;
         });
     };
+    createConnection = async (remainingRetries) => {
+        const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
+        return new Promise((resolve, reject) => {
+            conn.on('error', (err) => {
+                logger.error(`Connection error event: ${err.message}`);
+            });
+            conn.connect((err) => {
+                if (err) {
+                    logger.error(`Failed to connect to database: ${err.message}`);
+                    conn.destroy();
+                    if (remainingRetries > 0) {
+                        logger.warn(`Retrying database connection... (${remainingRetries} attempt(s) remaining)`);
+                        setTimeout(() => {
+                            this.createConnection(remainingRetries - 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, 100);
+                    }
+                    else {
+                        logger.error('Database connection failed after all retries. Giving up.');
+                        reject(err);
+                    }
+                }
+                else {
+                    logger.verbose('Database connection established successfully.');
+                    resolve(conn);
+                }
+            });
+        });
+    };
     ensureConnectionConfig = async () => {
         if (this.connectionConfig) {
             return;

package/dist/middleware/database/sqlClient.js

@@ -14,9 +14,13 @@ class LazyConnectionPool {
     secretsCache;
     configInitOnce = new oncePromise_1.OncePromise();
     connectionInitOnce = new oncePromise_1.OncePromise();
+    MAX_RETRIES = 1;
     constructor(options) {
         this.options = options;
         this.secretsCache = secretsManager_1.SecretsManagerCache.getInstance();
+        if (options.secretsManagerConfig) {
+            this.secretsCache.configure(options.secretsManagerConfig);
+        }
     }
     ensureConnectionConfig = async () => {
         if (this.connectionConfig) {
@@ -44,21 +48,42 @@ class LazyConnectionPool {
         this.connectionInitOnce
             .run(async () => {
             await this.ensureConnectionConfig();
-            const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
-            return await new Promise((resolve, reject) => {
-                conn.connect((err) => {
-                    if (err) {
+            return await this.createConnection(this.MAX_RETRIES);
+        })
+            .then((conn) => callback(null, conn))
+            .catch((err) => callback(err, {}));
+    };
+    createConnection = async (remainingRetries) => {
+        const conn = (0, mysql2_1.createConnection)(this.connectionConfig);
+        return new Promise((resolve, reject) => {
+            conn.on('error', (err) => {
+                logger.error(`Database connection error occurred: ${err.message}`);
+            });
+            conn.connect((err) => {
+                if (err) {
+                    logger.error(`Failed to connect to database: ${err.message}`);
+                    conn.destroy();
+                    if (remainingRetries > 0) {
+                        logger.warn(`Retrying database connection... (${remainingRetries} attempt(s) remaining)`);
+                        setTimeout(() => {
+                            this.createConnection(remainingRetries - 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, 100);
+                    }
+                    else {
+                        logger.error('Database connection failed after all retries. Giving up.');
                         reject(err);
-                        return;
                     }
+                }
+                else {
+                    logger.verbose('Database connection established successfully.');
                     const wrapped = this._addRelease(conn);
                     this.connection = wrapped;
                     resolve(wrapped);
-                });
+                }
             });
-        })
-            .then((conn) => callback(null, conn))
-            .catch((err) => callback(err, {}));
+        });
     };
     end = (callback) => {
         const conn = this.connection;

package/dist/middleware/index.d.ts

@@ -1,5 +1,33 @@
 export declare const middleware: {
-    build: <Aux extends import("./base").HandlerAuxBase>(plugins: Array<import("./base").HandlerPluginBase<any>>) => (handler: import("./base").Handler<Aux>) => (event: any, context: any, callback: any) => void;
+    build: <Aux extends import("./base").HandlerAuxBase>(plugins: Array<import("./base").HandlerPluginBase<any>>) => ((handler: import("./base").Handler<Aux>) => (event: any, context: any, callback: any) => void) & {
+        withBody: <S>(schema: import("zod").ZodType<S>, handler: (context: {
+            request: Omit<import("./base").HandlerRequest, "body"> & {
+                body: S;
+            };
+            response: import("./base").HandlerResponse;
+            aux: Aux;
+        }) => any, onInvalid?: (error: import("zod").ZodError) => {
+            statusCode: number;
+            body: any;
+        } | Promise<{
+            statusCode: number;
+            body: any;
+        } | void> | void) => (event: any, context: any, callback: any) => void;
+        withQuery: <Q>(schema: import("zod").ZodType<Q>, handler: (context: {
+            request: Omit<import("./base").HandlerRequest, "query"> & {
+                query: Q;
+            };
+            response: import("./base").HandlerResponse;
+            aux: Aux;
+        }) => any, onInvalid?: (error: import("zod").ZodError<Q>) => {
+            statusCode: number;
+            body: any;
+        } | Promise<{
+            statusCode: number;
+            body: any;
+        } | void> | void) => (event: any, context: any, callback: any) => void;
+    };
+    buildWebSocket: <Aux extends import("./websocketBase").WebSocketHandlerAuxBase>(plugins: Array<import("./base").HandlerPluginBase<any>>) => (handler: import("./websocketBase").WebSocketHandler<Aux>) => import("aws-lambda").APIGatewayProxyWebsocketHandlerV2;
     aws: (options?: import("./aws").AWSPluginOptions) => import("./aws").AWSPlugin;
     trace: (options: import("./trace").TracerPluginOptions) => import("./trace").TracerPlugin;
     logger: (options: import("./logger").LoggerPluginOptions) => import("./logger").LoggerPlugin;
@@ -11,3 +39,4 @@ export * from './database/index';
 export * from './logger';
 export * from './mysql';
 export * from './trace';
+export * from './websocketBase';

package/dist/middleware/index.js

@@ -16,12 +16,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.middleware = void 0;
 const build_1 = require("./build");
+const buildWebSocket_1 = require("./buildWebSocket");
 const aws_1 = require("./aws");
 const logger_1 = require("./logger");
 const mysql_1 = require("./mysql");
 const trace_1 = require("./trace");
 exports.middleware = {
     build: build_1.default,
+    buildWebSocket: buildWebSocket_1.default,
     aws: aws_1.default,
     trace: trace_1.default,
     logger: logger_1.default,
@@ -33,3 +35,4 @@ __exportStar(require("./database/index"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./mysql"), exports);
 __exportStar(require("./trace"), exports);
+__exportStar(require("./websocketBase"), exports);

package/dist/middleware/mysql.d.ts

@@ -1,3 +1,4 @@
+import type { SecretsManagerClientConfig } from '@aws-sdk/client-secrets-manager';
 import type { ConnectionOptions, PoolOptions } from 'mysql2';
 import { HandlerAuxBase, HandlerPluginBase } from './base';
 import { ConnectionProxy } from './database/connectionProxy';
@@ -12,6 +13,7 @@ export interface MySQLPluginOptions {
      * AWS Secrets Manager secret ID containing {@link DatabaseCredentials}
      */
     secretId?: string;
+    secretsManagerConfig?: SecretsManagerClientConfig;
     schema?: {
         eager?: boolean;
         ignoreError?: boolean;

package/dist/middleware/websocketBase.d.ts

@@ -0,0 +1,32 @@
+import type { APIGatewayProxyWebsocketEventV2, Context } from 'aws-lambda';
+export interface WebSocketHandlerAuxBase {
+    [key: string]: any;
+}
+export declare class WebSocketHandlerRequest {
+    event: APIGatewayProxyWebsocketEventV2;
+    context: Context;
+    lastError: Error | string | undefined;
+    private lazyBody?;
+    constructor(event: APIGatewayProxyWebsocketEventV2, context: Context);
+    get body(): any;
+    get connectionId(): string;
+    get routeKey(): string;
+    get domainName(): string;
+    get stage(): string;
+    /**
+     * For HTTP plugin compatibility (TracerPlugin uses this).
+     * WebSocket events may have headers in $connect route (HTTP handshake),
+     * but typically don't have headers in other routes.
+     */
+    header(key: string): string | undefined;
+}
+export interface WebSocketHandlerResponse {
+    statusCode: number;
+    body?: string;
+}
+export interface WebSocketHandlerContext<A extends WebSocketHandlerAuxBase> {
+    request: WebSocketHandlerRequest;
+    response: undefined;
+    aux: A;
+}
+export type WebSocketHandler<A extends WebSocketHandlerAuxBase> = (context: WebSocketHandlerContext<A>) => WebSocketHandlerResponse | Promise<WebSocketHandlerResponse> | undefined;

package/dist/middleware/websocketBase.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandlerRequest = void 0;
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.getLogger)(__filename);
+class WebSocketHandlerRequest {
+    event;
+    context;
+    lastError;
+    lazyBody;
+    constructor(event, context) {
+        this.event = event;
+        this.context = context;
+        this.lastError = undefined;
+        const ev = this.event;
+        if (ev.headers) {
+            const normalized = {};
+            for (const key of Object.keys(ev.headers)) {
+                normalized[key.toLowerCase()] = ev.headers[key];
+            }
+            ev.headers = normalized;
+        }
+    }
+    get body() {
+        if (!this.event.body) {
+            return {};
+        }
+        if (this.lazyBody === undefined) {
+            try {
+                this.lazyBody = JSON.parse(this.event.body);
+            }
+            catch (error) {
+                logger.error(`Failed to parse WebSocket body: ${error}`);
+                this.lazyBody = {};
+            }
+        }
+        return this.lazyBody || {};
+    }
+    get connectionId() {
+        return this.event.requestContext.connectionId;
+    }
+    get routeKey() {
+        return this.event.requestContext.routeKey;
+    }
+    get domainName() {
+        return this.event.requestContext.domainName;
+    }
+    get stage() {
+        return this.event.requestContext.stage;
+    }
+    // HTTP plugin compatibility methods
+    /**
+     * For HTTP plugin compatibility (TracerPlugin uses this).
+     * WebSocket events may have headers in $connect route (HTTP handshake),
+     * but typically don't have headers in other routes.
+     */
+    header(key) {
+        const event = this.event;
+        if (event.headers) {
+            return event.headers[key.toLowerCase()];
+        }
+        return undefined;
+    }
+}
+exports.WebSocketHandlerRequest = WebSocketHandlerRequest;