@tsed/platform-serverless-testing 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-serverless-testing",
   "description": "Module to test Serverless function with Ts.ED",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -51,12 +52,12 @@
   "homepage": "https://github.com/tsedio/tsed/tree/production/packages/platform/platform-serverless-testing",
   "repository": "https://github.com/tsedio/tsed",
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/schema": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "@types/aws-lambda": "^8.10.145",
     "eslint": "9.12.0",
     "typescript": "5.4.5"
@@ -65,12 +66,12 @@
     "tslib": "2.7.0"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/openspec": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1"
+    "@tsed/openspec": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/schema": "8.0.2"
   }
 }

package/src/PlatformServerlessTest.ts

@@ -0,0 +1,199 @@
+import {nameOf, Type} from "@tsed/core";
+import {destroyInjector, DITest} from "@tsed/di";
+import type {PlatformBuilder, PlatformBuilderSettings} from "@tsed/platform-http";
+import type {
+  APIGatewayEventDefaultAuthorizerContext,
+  APIGatewayProxyEventBase,
+  APIGatewayProxyHandler,
+  APIGatewayProxyResult
+} from "aws-lambda";
+
+import {createFakeContext} from "./createFakeContext.js";
+import {createFakeEvent} from "./createFakeEvent.js";
+
+export interface LambdaPromiseResult extends Promise<APIGatewayProxyResult> {}
+
+export class LambdaClientRequest extends Promise<APIGatewayProxyResult> {
+  event = createFakeEvent();
+  context = createFakeContext();
+
+  static call(lambdaName: string) {
+    const resolvers: any = {};
+    const promise = new LambdaClientRequest((resolve, reject) => {
+      resolvers.resolve = resolve;
+      resolvers.reject = reject;
+    });
+
+    promise.init(lambdaName, resolvers.resolve, resolvers.reject);
+
+    return promise;
+  }
+
+  static get(path: string, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    return this.call("handler").get(path, options);
+  }
+
+  static post(path: string, body?: any, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    return this.call("handler").post(path, body, options);
+  }
+
+  static put(path: string, body?: any, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    return this.call("handler").put(path, body, options);
+  }
+
+  static patch(path: string, body?: any, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    return this.call("handler").patch(path, body, options);
+  }
+
+  static delete(path: string, body?: any, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    return this.call("handler").delete(path, body, options);
+  }
+
+  get(path: string, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    Object.assign(this.event, options);
+
+    this.event.path = path;
+    this.event.httpMethod = "GET";
+
+    return this;
+  }
+
+  post(path: string, body: any = {}, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    Object.assign(this.event, options);
+
+    this.event.path = path;
+    this.event.httpMethod = "POST";
+
+    this.body(body);
+
+    return this;
+  }
+
+  patch(path: string, body: any = {}, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    Object.assign(this.event, options);
+
+    this.event.path = path;
+    this.event.httpMethod = "PATCH";
+
+    this.body(body);
+
+    return this;
+  }
+
+  put(path: string, body: any = {}, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    Object.assign(this.event, options);
+
+    this.event.path = path;
+    this.event.httpMethod = "PUT";
+
+    this.body(body);
+
+    return this;
+  }
+
+  delete(path: string, body: any = {}, options: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+    Object.assign(this.event, options);
+
+    this.event.path = path;
+    this.event.httpMethod = "DELETE";
+
+    this.body(body);
+
+    return this;
+  }
+
+  query(query: any) {
+    this.event.queryStringParameters = {
+      ...this.event.queryStringParameters,
+      ...JSON.parse(JSON.stringify(query))
+    };
+
+    return this;
+  }
+
+  params(pathParameters: any) {
+    this.event.pathParameters = {
+      ...this.event.pathParameters,
+      ...JSON.parse(JSON.stringify(pathParameters))
+    };
+
+    return this;
+  }
+
+  headers(headers: Record<string, any>) {
+    this.event.headers = {
+      ...this.event.headers,
+      ...JSON.parse(JSON.stringify(headers))
+    };
+
+    return this;
+  }
+
+  body(body: any) {
+    if (body !== undefined) {
+      this.event.headers["content-type"] = "application/json";
+
+      this.event.body = JSON.stringify(body);
+    }
+
+    return this;
+  }
+
+  protected init(lambda: string, resolve: Function, reject: Function) {
+    setTimeout(async () => {
+      try {
+        const result = await PlatformServerlessTest.callbacks[lambda](this.event, this.context, resolve as any);
+        resolve(result as any);
+      } catch (er) {
+        reject(er);
+      }
+    });
+  }
+}
+
+export class PlatformServerlessTest extends DITest {
+  static callbacks: Record<string, APIGatewayProxyHandler> = {};
+  static instance: any;
+  static request = LambdaClientRequest;
+
+  static bootstrap(
+    serverless: {bootstrap: (server: Type<any>, settings: TsED.Configuration) => PlatformBuilder},
+    {server, ...settings}: PlatformBuilderSettings<any> & {server: Type<any>}
+  ): () => Promise<any>;
+  static bootstrap(
+    serverless: {bootstrap: (settings: Partial<TsED.Configuration> & {lambda?: Type[]}) => any},
+    {server, ...settings}: PlatformBuilderSettings<any>
+  ): () => Promise<any>;
+  static bootstrap(serverless: any, {server, ...settings}: PlatformBuilderSettings<any>) {
+    return function before(): Promise<void> {
+      settings = DITest.configure(settings);
+
+      const isServerlessHttp = nameOf(serverless).includes("Http");
+
+      // @ts-ignore
+      const instance = isServerlessHttp ? serverless.bootstrap(server, settings) : serverless.bootstrap(settings);
+
+      PlatformServerlessTest.instance = instance;
+      PlatformServerlessTest.callbacks = {};
+
+      if (!isServerlessHttp) {
+        PlatformServerlessTest.callbacks = instance.callbacks();
+      }
+
+      PlatformServerlessTest.callbacks.handler = instance.handler();
+
+      return instance.promise;
+    };
+  }
+
+  /**
+   * Resets the test injector of the test context, so it won't pollute your next test. Call this in your `tearDown` logic.
+   */
+  static async reset() {
+    if (PlatformServerlessTest.instance) {
+      await PlatformServerlessTest.instance.stop();
+    }
+
+    await destroyInjector();
+  }
+}

package/src/createFakeContext.ts

@@ -0,0 +1,15 @@
+import type {Context} from "aws-lambda";
+
+export function createFakeContext(context?: Context): Context {
+  return {
+    awsRequestId: "awsRequestId",
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: "",
+    functionVersion: "",
+    invokedFunctionArn: "",
+    logGroupName: "",
+    logStreamName: "",
+    memoryLimitInMB: "",
+    ...(context || {})
+  } as Context;
+}

package/src/createFakeEvent.ts

@@ -0,0 +1,32 @@
+import type {APIGatewayEventDefaultAuthorizerContext, APIGatewayProxyEventBase} from "aws-lambda";
+
+export function createFakeEvent(event: Partial<APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>> = {}) {
+  return {
+    body: "",
+    headers: {},
+    httpMethod: "",
+    isBase64Encoded: false,
+    multiValueHeaders: {},
+    multiValueQueryStringParameters: {},
+    path: event.path || "/",
+    pathParameters: {},
+    queryStringParameters: {},
+    resource: "",
+    stageVariables: {},
+    ...event,
+    requestContext: {
+      ...event?.requestContext,
+      accountId: "",
+      apiId: "",
+      protocol: "https",
+      httpMethod: "",
+      identity: {} as any,
+      path: event.path || "/",
+      stage: "",
+      requestId: "requestId",
+      requestTimeEpoch: 0,
+      resourceId: 1,
+      resourcePath: event.path || "/"
+    } as any
+  } as APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./createFakeContext.js";
+export * from "./createFakeEvent.js";
+export * from "./PlatformServerlessTest.js";