@tsed/platform-serverless 8.0.1 → 8.0.3

package/src/builder/PlatformServerlessHandler.ts

@@ -0,0 +1,121 @@
+import {pipeline} from "node:stream/promises";
+
+import {AnyPromiseResult, AnyToPromise, isSerializable, isStream} from "@tsed/core";
+import {BaseContext, inject, injectable, lazyInject, ProviderScope, runInContext, TokenProvider} from "@tsed/di";
+import {$asyncEmit} from "@tsed/hooks";
+import {serialize} from "@tsed/json-mapper";
+import {DeserializerPipe, PlatformParams, ValidationPipe} from "@tsed/platform-params";
+
+import {ServerlessContext} from "../domain/ServerlessContext.js";
+import type {ServerlessEvent} from "../domain/ServerlessEvent.js";
+import {ServerlessResponseStream} from "../domain/ServerlessResponseStream.js";
+import {setResponseHeaders} from "../utils/setResponseHeaders.js";
+
+export class PlatformServerlessHandler {
+  protected params = inject(PlatformParams);
+
+  createHandler(token: TokenProvider, propertyKey: string | symbol) {
+    const promisedHandler = this.params.compileHandler({token, propertyKey});
+
+    return ($ctx: ServerlessContext<ServerlessEvent>) => {
+      return runInContext($ctx, async () => {
+        await $asyncEmit("$onRequest", $ctx);
+
+        try {
+          const resolver = new AnyToPromise();
+          const handler = await promisedHandler;
+          const result = await resolver.call(() => handler({$ctx}));
+
+          this.processResult(result, $ctx);
+        } catch (er) {
+          $ctx.response.status(500).body(er);
+          const exceptions = await lazyInject(() => import("@tsed/platform-exceptions"));
+
+          await exceptions.catch(er, $ctx as unknown as BaseContext);
+        }
+
+        return this.flush($ctx);
+      });
+    };
+  }
+
+  private async flush($ctx: ServerlessContext<ServerlessEvent>) {
+    const body: unknown = $ctx.isHttpEvent() && !$ctx.isAuthorizerEvent() ? await this.makeHttpResponse($ctx) : $ctx.response.getBody();
+
+    await $asyncEmit("$onResponse", $ctx);
+
+    $ctx.logger.flush();
+    $ctx.destroy();
+
+    if (!$ctx.isHttpEvent() && $ctx.response.statusCode >= 400 && body) {
+      throw new Error((body as Error).message);
+    }
+
+    return body;
+  }
+
+  private async makeHttpResponse($ctx: ServerlessContext<ServerlessEvent>) {
+    setResponseHeaders($ctx);
+
+    let body = $ctx.response.getBody();
+
+    if (isSerializable(body)) {
+      $ctx.response.set("content-type", "application/json");
+      body = JSON.stringify(body);
+    }
+
+    const meta = {
+      statusCode: $ctx.response.getStatus(),
+      headers: {
+        ...$ctx.response.getHeaders(),
+        "x-request-id": $ctx.id
+      }
+    };
+
+    if (isStream(body) && $ctx.responseStream) {
+      const resStream = ServerlessResponseStream.setMeta($ctx.responseStream, {
+        ...meta,
+        headers: {
+          "content-type": "application/octet-stream",
+          ...meta.headers
+        }
+      });
+
+      await pipeline(body, resStream);
+
+      return undefined;
+    }
+
+    return {
+      ...meta,
+      body: body === undefined ? "" : body,
+      isBase64Encoded: false
+    };
+  }
+
+  private processResult({status, headers, data}: AnyPromiseResult, $ctx: ServerlessContext<ServerlessEvent>) {
+    if (status) {
+      $ctx.response.status(status);
+    }
+
+    if (headers) {
+      $ctx.response.setHeaders(headers);
+    }
+
+    if (data !== undefined) {
+      data = $ctx.response.getStatus() !== 204 ? data : "";
+
+      if (isSerializable(data)) {
+        data = serialize(data, {
+          ...$ctx.endpoint.getResponseOptions($ctx.response.getStatus()),
+          useAlias: true,
+          endpoint: true
+        });
+      }
+
+      $ctx.response.body(data);
+    }
+  }
+}
+
+injectable(PlatformServerlessHandler).scope(ProviderScope.SINGLETON).imports([DeserializerPipe, ValidationPipe]);

package/src/domain/ServerlessContext.spec.ts

@@ -0,0 +1,106 @@
+import {PlatformServerlessTest} from "@tsed/platform-serverless-testing";
+
+import {createServerlessContext} from "../../test/utils/createServerlessContext.js";
+
+describe("ServerlessContext", () => {
+  beforeEach(() => PlatformServerlessTest.create());
+  afterEach(() => PlatformServerlessTest.reset());
+
+  describe("constructor", () => {
+    it("should push callback", () => {
+      const ctx = createServerlessContext({
+        endpoint: {} as any
+      });
+      expect(ctx.event).toEqual({
+        body: "",
+        headers: {},
+        httpMethod: "",
+        isBase64Encoded: false,
+        multiValueHeaders: {},
+        multiValueQueryStringParameters: {},
+        path: "/",
+        pathParameters: {},
+        queryStringParameters: {},
+        requestContext: {
+          accountId: "",
+          apiId: "",
+          httpMethod: "",
+          identity: {},
+          path: "/",
+          protocol: "https",
+          requestId: "requestId",
+          requestTimeEpoch: 0,
+          resourceId: 1,
+          resourcePath: "/",
+          stage: ""
+        },
+        resource: "",
+        stageVariables: {}
+      });
+      expect(ctx.response.raw).toEqual(ctx.request.raw);
+      expect(ctx.request.event).toEqual(ctx.response.event);
+      expect(ctx.request.response).toEqual(ctx.response);
+      expect(ctx.response.request).toEqual(ctx.request);
+      expect(ctx.isHttpEvent()).toBeTruthy();
+      expect(ctx.isAuthorizerEvent()).toBeFalsy();
+    });
+    it("should push callback with event headers", () => {
+      const ctx = createServerlessContext({
+        endpoint: {} as any,
+        event: {
+          headers: undefined
+        }
+      });
+      expect(ctx.event).toEqual({
+        body: "",
+        headers: {},
+        httpMethod: "",
+        isBase64Encoded: false,
+        multiValueHeaders: {},
+        multiValueQueryStringParameters: {},
+        path: "/",
+        pathParameters: {},
+        queryStringParameters: {},
+        requestContext: {
+          accountId: "",
+          apiId: "",
+          httpMethod: "",
+          identity: {},
+          path: "/",
+          protocol: "https",
+          requestId: "requestId",
+          requestTimeEpoch: 0,
+          resourceId: 1,
+          resourcePath: "/",
+          stage: ""
+        },
+        resource: "",
+        stageVariables: {}
+      });
+      expect(ctx.response.raw).toEqual(ctx.request.raw);
+      expect(ctx.request.event).toEqual(ctx.response.event);
+      expect(ctx.request.response).toEqual(ctx.response);
+      expect(ctx.response.request).toEqual(ctx.request);
+    });
+    it("should accept auth event (request)", () => {
+      const ctx = createServerlessContext({
+        event: {
+          type: "REQUEST",
+          httpMethod: "GET"
+        } as never,
+        endpoint: {} as any
+      });
+      expect(ctx.isHttpEvent()).toBeTruthy();
+      expect(ctx.isAuthorizerEvent()).toBeTruthy();
+    });
+    it("should accept auth event (token)", () => {
+      const ctx = createServerlessContext({
+        event: {
+          type: "TOKEN"
+        } as never,
+        endpoint: {} as any
+      });
+      expect(ctx.isAuthorizerEvent()).toBeTruthy();
+    });
+  });
+});

package/src/domain/ServerlessContext.ts

@@ -0,0 +1,60 @@
+import {DIContext, DIContextOptions} from "@tsed/di";
+import {JsonEntityStore} from "@tsed/schema";
+import type {APIGatewayProxyEvent, Context} from "aws-lambda";
+
+import {ServerlessRequest} from "./ServerlessRequest.js";
+import {ServerlessResponse} from "./ServerlessResponse.js";
+import type {ServerlessResponseStream} from "./ServerlessResponseStream.js";
+
+export interface ServerlessContextOptions<Event = APIGatewayProxyEvent> extends DIContextOptions {
+  event: Event;
+  context: Context;
+  responseStream?: ServerlessResponseStream;
+  endpoint: JsonEntityStore;
+}
+
+export class ServerlessContext<Event extends object = APIGatewayProxyEvent> extends DIContext {
+  readonly response: ServerlessResponse<Event>;
+  readonly request: ServerlessRequest<Event>;
+  readonly context: Context;
+  readonly event: Event;
+  readonly responseStream: ServerlessResponseStream | undefined;
+  readonly endpoint: JsonEntityStore;
+  readonly PLATFORM = "SERVERLESS";
+
+  constructor({event, context, endpoint, responseStream, ...options}: ServerlessContextOptions<Event>) {
+    super({
+      ...options,
+      maxStackSize: 0
+    });
+    this.context = context;
+    this.responseStream = responseStream;
+    this.event = {
+      ...event,
+      headers:
+        "headers" in event && event.headers
+          ? Object.fromEntries(Object.entries(event.headers).map(([key, value]) => [key.toLowerCase(), value]))
+          : {}
+    };
+    this.request = new ServerlessRequest<Event>(this);
+    this.response = new ServerlessResponse<Event>(this);
+    this.endpoint = endpoint;
+  }
+
+  isHttpEvent() {
+    return "httpMethod" in this.event;
+  }
+
+  isAuthorizerEvent() {
+    return "type" in this.event && ["TOKEN", "REQUEST"].includes(this.event.type as string);
+  }
+
+  async destroy() {
+    await super.destroy();
+    this.response.destroy();
+  }
+
+  isDone() {
+    return this.response.isDone();
+  }
+}

package/src/domain/ServerlessEvent.ts

@@ -0,0 +1,24 @@
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayTokenAuthorizerEvent,
+  CloudWatchLogsEvent,
+  DynamoDBStreamEvent,
+  KinesisStreamEvent,
+  S3Event,
+  ScheduledEvent,
+  SNSEvent,
+  SQSEvent
+} from "aws-lambda";
+
+export type ServerlessEvent =
+  | APIGatewayProxyEvent
+  | APIGatewayProxyEventV2
+  | S3Event
+  | SQSEvent
+  | SNSEvent
+  | DynamoDBStreamEvent
+  | KinesisStreamEvent
+  | CloudWatchLogsEvent
+  | ScheduledEvent
+  | APIGatewayTokenAuthorizerEvent;

package/src/domain/ServerlessRequest.spec.ts

@@ -0,0 +1,130 @@
+import {PlatformServerlessTest} from "@tsed/platform-serverless-testing";
+
+import {createServerlessContext} from "../../test/utils/createServerlessContext.js";
+
+describe("ServerlessRequest", () => {
+  beforeEach(() => PlatformServerlessTest.create());
+  afterEach(() => PlatformServerlessTest.reset());
+  describe("secure()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.secure).toEqual(true);
+    });
+  });
+
+  describe("host()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.event.headers["host"] = "host";
+
+      expect(context.request.host).toEqual("host");
+    });
+  });
+  describe("protocol()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.protocol).toEqual("https");
+    });
+  });
+  describe("url()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.url).toEqual("/");
+    });
+  });
+  describe("headers()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.headers).toEqual({});
+    });
+  });
+  describe("method()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.request.raw.httpMethod = "GET";
+      expect(context.request.method).toEqual("GET");
+    });
+  });
+
+  describe("body()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.body).toEqual({});
+    });
+    it("should return catch error on body", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.request.raw.body = "{";
+
+      expect(context.request.body).toEqual("{");
+    });
+    it("should return parse body", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.request.raw.body = "{}";
+
+      expect(context.request.body).toEqual({});
+    });
+  });
+
+  describe("rawBody()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.rawBody).toEqual("");
+    });
+  });
+
+  describe("params()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.params).toEqual({});
+    });
+
+    it("should return expected value (undefined params)", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      delete context.event.pathParameters;
+
+      expect(context.request.params).toEqual({});
+    });
+  });
+
+  describe("query()", () => {
+    it("should return expected value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.request.query).toEqual({});
+    });
+  });
+});

package/src/domain/ServerlessRequest.ts

@@ -0,0 +1,106 @@
+import {getValue} from "@tsed/core";
+import type {APIGatewayProxyEvent} from "aws-lambda";
+
+import {ServerlessContext} from "./ServerlessContext.js";
+
+/**
+ * @platform
+ */
+export class ServerlessRequest<Event extends object = APIGatewayProxyEvent> {
+  constructor(protected $ctx: ServerlessContext<Event>) {}
+
+  /**
+   * APIGatewayProxyEvent to no break the current code
+   * @note use getEvent() instead to use generic type
+   */
+  get event(): APIGatewayProxyEvent {
+    return this.getEvent();
+  }
+
+  get raw(): Event {
+    return this.event as unknown as Event;
+  }
+
+  get response() {
+    return this.$ctx.response;
+  }
+
+  get secure(): boolean {
+    return true;
+  }
+
+  get host(): string {
+    return this.get("host");
+  }
+
+  get protocol(): string {
+    return "https";
+  }
+
+  /**
+   * Get the url of the request.
+   *
+   * Is equivalent of `express.response.originalUrl || express.response.url`.
+   */
+  get url(): string {
+    return this.event.path;
+  }
+
+  get headers() {
+    return this.event.headers;
+  }
+
+  get method(): string {
+    return this.event.httpMethod;
+  }
+
+  /**
+   * Contains key-value pairs of data submitted in the request body. By default, it is `undefined`, and is populated when you use
+   * `body-parsing` middleware such as `express.json()` or `express.urlencoded()`.
+   */
+  get body(): any {
+    try {
+      return this.event.body ? JSON.parse(this.event.body!) : {};
+    } catch (er) {
+      return this.event.body;
+    }
+  }
+
+  get rawBody(): any {
+    return this.event.body;
+  }
+
+  /**
+   * This property is an object containing properties mapped to the named route `parameters`.
+   * For example, if you have the route `/user/:name`, then the `name` property is available as `req.params.name`.
+   * This object defaults to `{}`.
+   */
+  get params(): {[key: string]: any} {
+    return this.event.pathParameters || {};
+  }
+
+  /**
+   * This property is an object containing a property for each query string parameter in the route.
+   * When query parser is set to disabled, it is an empty object `{}`, otherwise it is the result of the configured query parser.
+   */
+  get query(): {[key: string]: any} {
+    return this.event.queryStringParameters || {};
+  }
+
+  getEvent<E = Event>(): E {
+    return this.$ctx.event as unknown as E;
+  }
+
+  /**
+   * Returns the HTTP request header specified by field. The match is case-insensitive.
+   *
+   * ```typescript
+   * request.get('Content-Type') // => "text/plain"
+   * ```
+   *
+   * @param name
+   */
+  get(name: string) {
+    return getValue(this.event.headers, name);
+  }
+}

package/src/domain/ServerlessResponse.spec.ts

@@ -0,0 +1,139 @@
+import {PlatformServerlessTest} from "@tsed/platform-serverless-testing";
+
+import {createServerlessContext} from "../../test/utils/createServerlessContext.js";
+
+describe("ServerlessResponse", () => {
+  beforeEach(() => PlatformServerlessTest.create());
+  afterEach(() => PlatformServerlessTest.reset());
+
+  describe("isHeadersSent", () => {
+    it("should push callback", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      expect(context.response.isHeadersSent).toEqual(false);
+
+      context.response.destroy();
+
+      expect(context.response.isHeadersSent).toEqual(true);
+    });
+  });
+  describe("statusCode", () => {
+    it("should return the statusCode", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.response.statusCode = 201;
+      expect(context.response.statusCode).toEqual(201);
+    });
+  });
+  describe("locals()", () => {
+    it("should return the locals", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      expect(context.response.locals).toEqual({});
+    });
+  });
+  describe("contentLength()", () => {
+    it("should return the content length", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.response.contentLength(300);
+      expect(context.response.getContentLength()).toEqual(300);
+    });
+
+    it("should return the default content length", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+      context.response.contentLength(" " as any);
+      expect(context.response.getContentLength()).toEqual(0);
+    });
+  });
+  describe("location()", () => {
+    it("should set location", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.response.location("/path/to");
+
+      expect(context.response.getHeaders()).toEqual({
+        location: "/path/to"
+      });
+    });
+    it("should set location (back)", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.request.headers["Referrer"] = "https://referrer.com";
+      context.response.location("back");
+
+      expect(context.response.getHeaders()).toEqual({
+        location: "https://referrer.com"
+      });
+    });
+  });
+  describe("redirect()", () => {
+    it("should set location", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.response.redirect(301, "/path/to");
+
+      expect(context.response.getHeaders()).toEqual({
+        "content-length": 42,
+        location: "/path/to"
+      });
+      expect(context.response.statusCode).toEqual(301);
+      expect(context.response.getBody()).toEqual("Moved Permanently. Redirecting to /path/to");
+    });
+    it("should set location (back)", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.request.headers["Referrer"] = "https://referrer.com";
+      context.response.redirect(301, "back");
+
+      expect(context.response.getHeaders()).toEqual({
+        "content-length": 54,
+        location: "https://referrer.com"
+      });
+      expect(context.response.statusCode).toEqual(301);
+      expect(context.response.getStatus()).toEqual(301);
+      expect(context.response.getContentLength()).toEqual(54);
+      expect(context.response.getContentType()).toEqual("");
+      expect(context.response.getBody()).toEqual("Moved Permanently. Redirecting to https://referrer.com");
+    });
+  });
+  describe("setHeader()", () => {
+    it("should set location", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.event.headers["Referrer"] = "https://referrer.com";
+      context.response.set("location", "back");
+      expect(context.response.getHeaders()).toEqual({
+        location: "https://referrer.com"
+      });
+    });
+    it("should set location back with default value", () => {
+      const context = createServerlessContext({
+        endpoint: {} as any
+      });
+
+      context.event.headers["Referrer"] = "";
+      context.response.set("location", "back");
+      expect(context.response.getHeaders()).toEqual({
+        location: "/"
+      });
+    });
+  });
+});