@tsed/platform-serverless 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-serverless",
   "description": "Platform serverless module for Ts.ED Framework",
   "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"
@@ -22,23 +23,23 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/hooks": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/platform-exceptions": "8.0.1",
-    "@tsed/platform-params": "8.0.1",
-    "@tsed/schema": "8.0.1",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/exceptions": "8.0.2",
+    "@tsed/hooks": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
+    "@tsed/platform-exceptions": "8.0.2",
+    "@tsed/platform-params": "8.0.2",
+    "@tsed/schema": "8.0.2",
     "encodeurl": "^2.0.0",
     "mime": "^4.0.4",
     "tslib": "2.7.0",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/platform-serverless-testing": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/platform-serverless-testing": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "@types/aws-lambda": "^8.10.145",
     "@types/encodeurl": "^1.0.2",
     "@types/mime": "^4.0.0",
@@ -48,7 +49,7 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/di": "8.0.1",
+    "@tsed/di": "8.0.2",
     "@tsed/logger": ">=6.7.5",
     "find-my-way": ">=7.0.0"
   },

package/src/builder/PlatformServerless.spec.ts

@@ -0,0 +1,219 @@
+import {Controller, Inject, Injectable} from "@tsed/di";
+import {BodyParams, PathParams, QueryParams} from "@tsed/platform-params";
+import {createFakeContext, createFakeEvent, PlatformServerlessTest} from "@tsed/platform-serverless-testing";
+import {Delete, Get, Patch, Post, Put} from "@tsed/schema";
+
+import {PlatformServerless} from "./PlatformServerless.js";
+
+@Injectable()
+class TimeslotsService {
+  get() {
+    return "test";
+  }
+}
+
+@Controller("/")
+class TimeslotsLambdaController {
+  @Inject()
+  protected timeslotsService: TimeslotsService;
+
+  @(Get("/:id").Name("byID"))
+  getByID(@PathParams("id") id: string) {
+    return {
+      id
+    };
+  }
+
+  @Get("/")
+  get(@QueryParams("start_date") startDate: Date, @QueryParams("end_date") endDate: Date) {
+    return {
+      value: this.timeslotsService.get(),
+      startDate,
+      endDate
+    };
+  }
+
+  @Post("/")
+  post(@BodyParams() body: any) {
+    return body;
+  }
+
+  @Put("/:id")
+  put(@BodyParams() body: any) {
+    return body;
+  }
+
+  @Patch("/:id")
+  patch(@BodyParams() body: any) {
+    return body;
+  }
+
+  @Delete("/:id")
+  delete(@BodyParams() body: any) {
+    return body;
+  }
+
+  other() {}
+}
+
+describe("PlatformServerless", () => {
+  describe("bootstrap()", () => {
+    beforeEach(
+      PlatformServerlessTest.bootstrap(PlatformServerless, {
+        lambda: [TimeslotsLambdaController]
+      })
+    );
+    afterEach(() => PlatformServerlessTest.reset());
+
+    it("should load lambda", () => {
+      const handlers = PlatformServerlessTest.callbacks;
+
+      expect(handlers).toHaveProperty("get");
+      expect(handlers).toHaveProperty("byID");
+    });
+    it("should call lambda", async () => {
+      const response = await PlatformServerlessTest.request.call("get").query({
+        start_date: new Date("2020-01-01"),
+        end_date: new Date("2020-01-10")
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        endDate: "2020-01-10T00:00:00.000Z",
+        startDate: "2020-01-01T00:00:00.000Z",
+        value: "test"
+      });
+    });
+    it("should call lambda with custom x-request-id", async () => {
+      const response = await PlatformServerlessTest.request
+        .call("get")
+        .headers({
+          "x-request-id": "request-id"
+        })
+        .query({
+          start_date: new Date("2020-01-01"),
+          end_date: new Date("2020-01-10")
+        });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "request-id",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        endDate: "2020-01-10T00:00:00.000Z",
+        startDate: "2020-01-01T00:00:00.000Z",
+        value: "test"
+      });
+    });
+    it("should call lambda from handler()", async () => {
+      const response = await PlatformServerlessTest.request.get("/").query({
+        start_date: new Date("2020-01-01"),
+        end_date: new Date("2020-01-10")
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        endDate: "2020-01-10T00:00:00.000Z",
+        startDate: "2020-01-01T00:00:00.000Z",
+        value: "test"
+      });
+    });
+    it("should call lambda from handler() with params", async () => {
+      const response = await PlatformServerlessTest.request.get("/1");
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        id: "1"
+      });
+    });
+    it("should call lambda from handler() (post)", async () => {
+      const response = await PlatformServerlessTest.request.post("/").body({
+        label: "label"
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        label: "label"
+      });
+    });
+    it("should call lambda from handler() (put)", async () => {
+      const response = await PlatformServerlessTest.request.put("/1").body({
+        label: "label"
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        label: "label"
+      });
+    });
+    it("should call lambda from handler() (patch)", async () => {
+      const response = await PlatformServerlessTest.request.patch("/1").body({
+        label: "label"
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        label: "label"
+      });
+    });
+    it("should call lambda from handler() (delete)", async () => {
+      const response = await PlatformServerlessTest.request.delete("/1").body({
+        label: "label"
+      });
+
+      expect(response.statusCode).toEqual(200);
+      expect(response.headers).toEqual({
+        "x-request-id": "requestId",
+        "content-type": "application/json"
+      });
+      expect(JSON.parse(response.body)).toEqual({
+        label: "label"
+      });
+    });
+    it("should call lambda from handler() but returns a 404 if controller doesn't match and endpoint", async () => {
+      const event = createFakeEvent();
+      event.httpMethod = "GET";
+      event.path = "/test/other";
+      const context = createFakeContext();
+      const response = await PlatformServerlessTest.instance.handler()(event, context);
+
+      expect(response.statusCode).toEqual(404);
+      expect(response.headers).toEqual({"x-request-id": "requestId"});
+      expect(response.body).toEqual("Not found");
+    });
+  });
+  describe("callback()", () => {
+    it("should create handler from given parameters", () => {
+      const handler = PlatformServerless.callback(TimeslotsLambdaController, "get", {
+        // settings
+      });
+
+      expect(handler).toBeInstanceOf(Function);
+    });
+  });
+});

package/src/builder/PlatformServerless.ts

@@ -0,0 +1,202 @@
+import {Env, Type} from "@tsed/core";
+import {configuration, constant, createContainer, destroyInjector, injector, InjectorService, setLoggerConfiguration} from "@tsed/di";
+import {$asyncEmit} from "@tsed/hooks";
+import {$log} from "@tsed/logger";
+import {getOperationsRoutes, JsonEntityStore} from "@tsed/schema";
+import type {Context, Handler} from "aws-lambda";
+import type {HTTPMethod, Instance} from "find-my-way";
+
+import {ServerlessContext} from "../domain/ServerlessContext.js";
+import type {ServerlessEvent} from "../domain/ServerlessEvent.js";
+import {type RequestHandler, ServerlessResponseStream} from "../domain/ServerlessResponseStream.js";
+import {getRequestId} from "../utils/getRequestId.js";
+import {PlatformServerlessHandler} from "./PlatformServerlessHandler.js";
+
+export interface PlatformServerlessSettings extends Partial<TsED.Configuration> {
+  lambda?: Type[];
+}
+
+/**
+ * @platform
+ */
+export class PlatformServerless {
+  readonly name: string = "PlatformServerless";
+  private _router: Instance<any>;
+  private _promise: Promise<any>;
+
+  get injector(): InjectorService {
+    return injector();
+  }
+
+  get settings() {
+    return configuration();
+  }
+
+  get promise() {
+    return this._promise;
+  }
+
+  static bootstrap(settings: Partial<TsED.Configuration> & {lambda?: Type[]} = {}): PlatformServerless {
+    const platform = new PlatformServerless();
+    platform.createInjector(settings);
+
+    return platform;
+  }
+
+  /**
+   * Create a new handler from the given token and propertyKey. No routing is used here.
+   */
+  static callback(
+    token: Type<any>,
+    propertyKey: string,
+    settings: Partial<TsED.Configuration> = {}
+  ): Handler<ServerlessEvent> | RequestHandler {
+    const platform = PlatformServerless.bootstrap({
+      ...settings,
+      lambda: [token]
+    });
+
+    return platform.callback(token, propertyKey);
+  }
+
+  public handler(): Handler {
+    return async (event, context) => {
+      const [router] = await Promise.all([this.initRouter(), this.init()]);
+      const result = router.find(event.httpMethod as any, event.path);
+
+      if (result) {
+        const {handler, params} = result;
+
+        event.pathParameters = {
+          ...(event.pathParameters || {}),
+          ...params
+        };
+
+        return (handler as any)(event, context);
+      }
+
+      return {
+        statusCode: 404,
+        body: "Not found",
+        headers: {
+          "x-request-id": getRequestId(event, context)
+        },
+        isBase64Encoded: false
+      };
+    };
+  }
+
+  public callbacks(tokens: Type | Type[] = [], callbacks: any = {}): Record<string, Handler> {
+    return configuration()
+      .get<Type[]>("lambda", [])
+      .concat(tokens)
+      .reduce((callbacks, token) => {
+        const routes = getOperationsRoutes(token);
+
+        return routes.reduce((callbacks, operationRoute) => {
+          const {operationId, token, propertyName, method, url} = operationRoute;
+
+          // istanbul ignore next
+          if (method === "USE") {
+            return callbacks;
+          }
+
+          const callback = this.callback(token, propertyName);
+
+          this._router?.on(method as HTTPMethod, url as string, callback as any);
+
+          return {
+            ...callbacks,
+            [operationId]: callback
+          };
+        }, callbacks);
+      }, callbacks);
+  }
+
+  public async ready() {
+    await $asyncEmit("$onReady");
+  }
+
+  public async stop() {
+    await destroyInjector();
+  }
+
+  public init() {
+    if (!this._promise) {
+      this._promise = this.loadInjector().then(() => this.ready());
+    }
+
+    return this._promise;
+  }
+
+  protected callback(token: Type<any>, propertyKey: string): Handler<ServerlessEvent> | RequestHandler {
+    const entity = JsonEntityStore.fromMethod(token, propertyKey);
+    let handler: ($ctx: ServerlessContext<ServerlessEvent>) => Promise<unknown>;
+
+    const wrappedHandler = async (event: ServerlessEvent, responseStream: ServerlessResponseStream | undefined, context: Context) => {
+      await this.init();
+
+      if (!handler) {
+        const platformHandler = this.injector.get<PlatformServerlessHandler>(PlatformServerlessHandler)!;
+        handler = platformHandler.createHandler(token, propertyKey);
+      }
+
+      const $ctx = new ServerlessContext<ServerlessEvent>({
+        event,
+        context,
+        responseStream,
+        id: getRequestId(event, context),
+        endpoint: entity
+      });
+
+      return handler($ctx);
+    };
+
+    const isBinary = entity.operation.response?.isBinary();
+
+    if (isBinary) {
+      return ServerlessResponseStream.streamifyResponse(wrappedHandler);
+    }
+
+    return (event: ServerlessEvent, context: Context) => {
+      return wrappedHandler(event, undefined, context);
+    };
+  }
+
+  protected async initRouter() {
+    if (!this._router) {
+      const {default: FindMyMay} = await import("find-my-way");
+
+      this._router = FindMyMay({
+        caseSensitive: false,
+        ignoreTrailingSlash: true
+      });
+
+      this.callbacks();
+    }
+
+    return this._router;
+  }
+
+  protected createInjector(settings: any) {
+    injector().logger = $log;
+    injector().settings.set(settings);
+
+    // istanbul ignore next
+    if (constant("env") === Env.TEST && !settings?.logger?.level) {
+      $log.stop();
+    }
+
+    return this;
+  }
+
+  protected async loadInjector() {
+    const container = createContainer();
+
+    setLoggerConfiguration();
+
+    await injector().load(container);
+
+    await $asyncEmit("$afterInit");
+  }
+}

package/src/builder/PlatformServerlessHandler.spec.ts

@@ -0,0 +1,145 @@
+import {catchAsyncError} from "@tsed/core";
+import {DITest, Inject, Injectable} from "@tsed/di";
+import {Unauthorized} from "@tsed/exceptions";
+import {QueryParams} from "@tsed/platform-params";
+import {JsonEntityStore} from "@tsed/schema";
+import type {APIGatewayTokenAuthorizerEvent} from "aws-lambda";
+
+import {ServerlessContext} from "../domain/ServerlessContext.js";
+import {PlatformServerlessHandler} from "./PlatformServerlessHandler.js";
+
+async function getPlatformServerlessHandlerFixture() {
+  const service = await DITest.invoke<PlatformServerlessHandler>(PlatformServerlessHandler);
+  return {
+    service
+  };
+}
+
+@Injectable()
+class TimeslotsService {
+  get() {
+    return "test";
+  }
+}
+
+@Injectable()
+export class TimeslotsLambdaController {
+  @Inject()
+  protected timeslotsService: TimeslotsService;
+
+  get(@QueryParams("start_date") startDate: Date, @QueryParams("end_date") endDate: Date) {
+    return {
+      value: this.timeslotsService.get(),
+      startDate,
+      endDate
+    };
+  }
+
+  throwError(@QueryParams("start_date") startDate: Date, @QueryParams("end_date") endDate: Date) {
+    throw new Unauthorized("Unauthorized");
+  }
+}
+
+describe("PlatformServerlessHandler", () => {
+  beforeEach(() => DITest.create({}));
+  afterEach(() => DITest.reset());
+
+  it("should call lambda provider and return http response", async () => {
+    const {service} = await getPlatformServerlessHandlerFixture();
+
+    const endpoint = JsonEntityStore.fromMethod(TimeslotsLambdaController, "get");
+    const $ctx = new ServerlessContext({
+      event: {
+        httpMethod: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      } as any,
+      context: {} as any,
+      endpoint
+    } as any);
+
+    const handler = service.createHandler(TimeslotsLambdaController, "get");
+    const result = await handler($ctx);
+
+    expect(result).toEqual({
+      body: '{"value":"test"}',
+      headers: {
+        "content-type": "application/json"
+      },
+      isBase64Encoded: false,
+      statusCode: 200
+    });
+  });
+  it("shouldn't throw error and return http response", async () => {
+    const {service} = await getPlatformServerlessHandlerFixture();
+
+    const endpoint = JsonEntityStore.fromMethod(TimeslotsLambdaController, "throwError");
+    const $ctx = new ServerlessContext({
+      event: {
+        httpMethod: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      } as any,
+      context: {} as any,
+      endpoint,
+      injector: DITest.injector
+    } as any);
+
+    const handler = service.createHandler(TimeslotsLambdaController, "throwError");
+
+    const result = await handler($ctx);
+
+    expect(result).toEqual({
+      body: '{"name":"UNAUTHORIZED","message":"Unauthorized","status":401,"errors":[]}',
+      headers: {
+        "content-type": "application/json"
+      },
+      isBase64Encoded: false,
+      statusCode: 401
+    });
+  });
+  it("should call lambda provider and return raw response when isn't a http event", async () => {
+    const {service} = await getPlatformServerlessHandlerFixture();
+
+    const endpoint = JsonEntityStore.fromMethod(TimeslotsLambdaController, "get");
+    const $ctx = new ServerlessContext({
+      event: {
+        type: "TOKEN",
+        methodArn: "",
+        authorizationToken: ""
+      } as APIGatewayTokenAuthorizerEvent,
+      context: {} as any,
+      endpoint
+    } as any);
+
+    const handler = service.createHandler(TimeslotsLambdaController, "get");
+    const result = await handler($ctx);
+
+    expect(result).toEqual({
+      value: "test"
+    });
+  });
+  it("should throw error when isn't a http event", async () => {
+    const {service} = await getPlatformServerlessHandlerFixture();
+
+    const endpoint = JsonEntityStore.fromMethod(TimeslotsLambdaController, "throwError");
+    const $ctx = new ServerlessContext({
+      event: {
+        type: "TOKEN",
+        methodArn: "",
+        authorizationToken: ""
+      } as APIGatewayTokenAuthorizerEvent,
+      context: {} as any,
+      endpoint,
+      injector: DITest.injector
+    } as any);
+
+    const handler = service.createHandler(TimeslotsLambdaController, "throwError");
+
+    const result = await catchAsyncError<Error>(() => handler($ctx));
+
+    expect(result?.message).toEqual("Unauthorized");
+  });
+});