@tsed/platform-serverless 8.11.0 → 8.11.2-rc.1

package/src/builder/PlatformServerlessHandler.spec.ts

@@ -1,145 +0,0 @@
-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");
-  });
-});

package/src/builder/PlatformServerlessHandler.ts

@@ -1,121 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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);
-  }
-}