serverless-simple-middleware 0.0.74 → 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/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/index.d.ts

@@ -27,6 +27,7 @@ export declare const middleware: {
             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;
@@ -38,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/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;

package/jest.config.js

@@ -1,7 +1,7 @@
-module.exports = {
-  transform: {
-    '^.+\\.tsx?$': 'ts-jest',
-  },
-  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
-};
+module.exports = {
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

package/package.json

@@ -1,70 +1,70 @@
-{
-  "name": "serverless-simple-middleware",
-  "description": "Simple middleware to translate the interface of lambda's handler to request => response",
-  "version": "0.0.74",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "author": "VoyagerX",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/v6x/serverless-simple-middleware.git"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "serverless"
-  ],
-  "bugs": {
-    "url": "https://github.com/v6x/serverless-simple-middleware/issues"
-  },
-  "homepage": "https://github.com/v6x/serverless-simple-middleware#readme",
-  "scripts": {
-    "lint": "tslint --project tsconfig.json",
-    "clean": "rm -rf dist && rm -rf node_modules && yarn install",
-    "build": "tsc --project tsconfig.json",
-    "build:watch": "tsc --project tsconfig.json --watch",
-    "test": "jest --config jest.config.js",
-    "test:watch": "jest --config jest.config.js --watch",
-    "deploy": "yarn build && yarn publish"
-  },
-  "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.828.0",
-    "@aws-sdk/client-s3": "^3.828.0",
-    "@aws-sdk/client-secrets-manager": "3.828.0",
-    "@aws-sdk/client-sqs": "^3.828.0",
-    "@aws-sdk/cloudfront-signer": "^3.821.0",
-    "@aws-sdk/lib-dynamodb": "^3.828.0",
-    "@aws-sdk/lib-storage": "^3.828.0",
-    "@aws-sdk/s3-request-presigner": "^3.828.0",
-    "@types/aws-lambda": "8",
-    "cross-fetch": "^2.2.2",
-    "kysely": "^0.28.2",
-    "mysql2": "^3.14.1",
-    "nanoid": "4.0.2",
-    "simple-staging": "^0.0.12",
-    "ts-enum-util": "^3.1.0",
-    "uuid": "^3.3.2",
-    "zod": "^4.3.5"
-  },
-  "devDependencies": {
-    "@types/jest": "^23.3.1",
-    "@types/node": "18",
-    "@types/uuid": "^3.4.4",
-    "babel-core": "6.26.0",
-    "babel-jest": "^23.4.2",
-    "cross-env": "^5.2.0",
-    "jest": "^23.4.2",
-    "prettier": "3.3.3",
-    "ts-jest": "^23.1.3",
-    "tslint": "^5.11.0",
-    "tslint-config-prettier": "^1.14.0",
-    "typescript": "5.5.3"
-  },
-  "prettier": {
-    "printWidth": 80,
-    "singleQuote": true,
-    "trailingComma": "all"
-  }
-}
+{
+  "name": "serverless-simple-middleware",
+  "description": "Simple middleware to translate the interface of lambda's handler to request => response",
+  "version": "0.0.75",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "VoyagerX",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/v6x/serverless-simple-middleware.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "serverless"
+  ],
+  "bugs": {
+    "url": "https://github.com/v6x/serverless-simple-middleware/issues"
+  },
+  "homepage": "https://github.com/v6x/serverless-simple-middleware#readme",
+  "scripts": {
+    "lint": "tslint --project tsconfig.json",
+    "clean": "rm -rf dist && rm -rf node_modules && yarn install",
+    "build": "tsc --project tsconfig.json",
+    "build:watch": "tsc --project tsconfig.json --watch",
+    "test": "jest --config jest.config.js",
+    "test:watch": "jest --config jest.config.js --watch",
+    "deploy": "yarn build && yarn publish"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.828.0",
+    "@aws-sdk/client-s3": "^3.828.0",
+    "@aws-sdk/client-secrets-manager": "3.828.0",
+    "@aws-sdk/client-sqs": "^3.828.0",
+    "@aws-sdk/cloudfront-signer": "^3.821.0",
+    "@aws-sdk/lib-dynamodb": "^3.828.0",
+    "@aws-sdk/lib-storage": "^3.828.0",
+    "@aws-sdk/s3-request-presigner": "^3.828.0",
+    "@types/aws-lambda": "8",
+    "cross-fetch": "^2.2.2",
+    "kysely": "^0.28.2",
+    "mysql2": "^3.14.1",
+    "nanoid": "4.0.2",
+    "simple-staging": "^0.0.12",
+    "ts-enum-util": "^3.1.0",
+    "uuid": "^3.3.2",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^23.3.1",
+    "@types/node": "18",
+    "@types/uuid": "^3.4.4",
+    "babel-core": "6.26.0",
+    "babel-jest": "^23.4.2",
+    "cross-env": "^5.2.0",
+    "jest": "^23.4.2",
+    "prettier": "3.3.3",
+    "ts-jest": "^23.1.3",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.14.0",
+    "typescript": "5.5.3"
+  },
+  "prettier": {
+    "printWidth": 80,
+    "singleQuote": true,
+    "trailingComma": "all"
+  }
+}

package/src/aws/config.ts

@@ -1,46 +1,46 @@
-import fetch from 'cross-fetch';
-import * as fs from 'fs';
-
-import { AWSComponent } from './define';
-
-export interface AWSConfig {
-  [key: string]: string | boolean | number | undefined;
-}
-
-export interface AWSConfigs {
-  [service: string]: AWSConfig;
-}
-
-export type AWSConfigResolver = (service: string) => AWSConfig;
-
-export type SimpleAWSConfigLoadParam = AWSConfigs | string;
-
-export class SimpleAWSConfig {
-  private configs: AWSConfigs | undefined;
-
-  public constructor(configs?: AWSConfigs) {
-    this.configs = configs;
-  }
-
-  public get = (service: AWSComponent): AWSConfig | undefined => {
-    return this.configs ? this.configs[service] : undefined;
-  };
-}
-
-export const loadAWSConfig = (
-  newConfigsOrUrl: SimpleAWSConfigLoadParam,
-): Promise<SimpleAWSConfig> => {
-  if (typeof newConfigsOrUrl === 'string') {
-    if (/^http.*json$/.test(newConfigsOrUrl)) {
-      return fetch(newConfigsOrUrl)
-        .then((r) => r.json())
-        .then(loadAWSConfig);
-    } else if (/json$/.test(newConfigsOrUrl)) {
-      return loadAWSConfig(
-        JSON.parse(fs.readFileSync(newConfigsOrUrl, 'utf-8')),
-      );
-    }
-    return loadAWSConfig(JSON.parse(newConfigsOrUrl));
-  }
-  return Promise.resolve(new SimpleAWSConfig(newConfigsOrUrl));
-};
+import fetch from 'cross-fetch';
+import * as fs from 'fs';
+
+import { AWSComponent } from './define';
+
+export interface AWSConfig {
+  [key: string]: string | boolean | number | undefined;
+}
+
+export interface AWSConfigs {
+  [service: string]: AWSConfig;
+}
+
+export type AWSConfigResolver = (service: string) => AWSConfig;
+
+export type SimpleAWSConfigLoadParam = AWSConfigs | string;
+
+export class SimpleAWSConfig {
+  private configs: AWSConfigs | undefined;
+
+  public constructor(configs?: AWSConfigs) {
+    this.configs = configs;
+  }
+
+  public get = (service: AWSComponent): AWSConfig | undefined => {
+    return this.configs ? this.configs[service] : undefined;
+  };
+}
+
+export const loadAWSConfig = (
+  newConfigsOrUrl: SimpleAWSConfigLoadParam,
+): Promise<SimpleAWSConfig> => {
+  if (typeof newConfigsOrUrl === 'string') {
+    if (/^http.*json$/.test(newConfigsOrUrl)) {
+      return fetch(newConfigsOrUrl)
+        .then((r) => r.json())
+        .then(loadAWSConfig);
+    } else if (/json$/.test(newConfigsOrUrl)) {
+      return loadAWSConfig(
+        JSON.parse(fs.readFileSync(newConfigsOrUrl, 'utf-8')),
+      );
+    }
+    return loadAWSConfig(JSON.parse(newConfigsOrUrl));
+  }
+  return Promise.resolve(new SimpleAWSConfig(newConfigsOrUrl));
+};

package/src/aws/define.ts

@@ -1,10 +1,10 @@
-export enum AWSComponent {
-  s3 = 's3',
-  sqs = 'sqs',
-  dynamodb = 'dynamodb',
-}
-
-export interface SQSMessageBody<T> {
-  handle: string;
-  body?: T;
-}
+export enum AWSComponent {
+  s3 = 's3',
+  sqs = 'sqs',
+  dynamodb = 'dynamodb',
+}
+
+export interface SQSMessageBody<T> {
+  handle: string;
+  body?: T;
+}

package/src/aws/index.ts

@@ -1,3 +1,3 @@
-export * from './config';
-export * from './define';
-export * from './simple';
+export * from './config';
+export * from './define';
+export * from './simple';