@tsed/platform-fastify 8.5.0-beta.1

package/src/services/PlatformFastifyRequest.ts

@@ -0,0 +1,61 @@
+import "@fastify/accepts";
+
+import type {IncomingMessage} from "node:http";
+
+import {type PlatformContext, PlatformRequest} from "@tsed/platform-http";
+import type {FastifyRequest} from "fastify";
+
+declare module "fastify" {
+  export interface FastifyRequest {
+    $ctx: PlatformContext;
+  }
+}
+
+declare module "http" {
+  export interface IncomingMessage {
+    $ctx: PlatformContext;
+  }
+}
+
+declare global {
+  namespace TsED {
+    export interface Request extends FastifyRequest {}
+  }
+}
+
+/**
+ * @platform
+ * @fastify
+ */
+export class PlatformFastifyRequest extends PlatformRequest<FastifyRequest> {
+  get host(): string {
+    return this.raw.hostname;
+  }
+
+  get secure(): boolean {
+    return this.protocol === "https";
+  }
+
+  /**
+   * 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 this.raw.raw.headers[name.toLowerCase()];
+  }
+
+  getReq(): IncomingMessage {
+    return this.raw.raw;
+  }
+
+  accepts(mime?: string | string[]) {
+    const accepts = this.raw.accepts().type([].concat(mime as any));
+
+    return (accepts ? accepts : false) as any;
+  }
+}

package/src/services/PlatformFastifyResponse.spec.ts

@@ -0,0 +1,114 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {PlatformFastifyResponse} from "./PlatformFastifyResponse.js";
+
+function createResponse() {
+  const response = PlatformTest.createResponse();
+  response.code = response.status;
+  response.type = response.contentType;
+  response.header = response.set;
+
+  const ctx = PlatformTest.createRequestContext({
+    event: {
+      response
+    },
+    ResponseKlass: PlatformFastifyResponse
+  });
+
+  return {res: response, response: ctx.response};
+}
+
+describe("PlatformFastifyResponse", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should create a PlatformResponse instance", () => {
+    const {res, response} = createResponse();
+
+    expect(response.raw).toEqual(res);
+  });
+
+  describe("getRes()", () => {
+    it("return res", async () => {
+      const {res, response} = createResponse();
+      res.raw = {};
+
+      const result = await response.getRes();
+
+      expect(result).toEqual(res.raw);
+    });
+  });
+  describe("statusCode", () => {
+    it("return statusCode", () => {
+      const {response} = createResponse();
+
+      response.status(302);
+
+      expect(response.statusCode).toEqual(302);
+    });
+  });
+  describe("contentType()", () => {
+    it("should set contentType", () => {
+      const {res, response} = createResponse();
+
+      response.contentType("text/html");
+
+      expect(res.headers).toEqual({"content-type": "text/html", "x-request-id": "id"});
+    });
+  });
+  describe("body()", () => {
+    it("should set body", () => {
+      const {res, response} = createResponse();
+
+      response.body("body");
+
+      expect(res.data).toEqual("body");
+    });
+  });
+
+  describe("stream()", () => {
+    it("should set body", () => {
+      const {res, response} = createResponse();
+
+      response.stream("body");
+
+      expect(res.data).toEqual("body");
+    });
+  });
+  describe("location", () => {
+    it("should set header location", () => {
+      const {res, response} = createResponse();
+
+      response.location("https://location");
+
+      expect(res.headers).toEqual({
+        location: "https://location",
+        "x-request-id": "id"
+      });
+    });
+
+    it("should go back based on Referrer", async () => {
+      const {res, response} = createResponse();
+
+      response.request.raw.headers["referrer"] = "https://location/back";
+
+      await response.location("back");
+
+      expect(res.headers).toEqual({
+        location: "https://location/back",
+        "x-request-id": "id"
+      });
+    });
+
+    it("should go back based on default path", async () => {
+      const {res, response} = createResponse();
+
+      await response.location("back");
+
+      expect(res.headers).toEqual({
+        location: "/",
+        "x-request-id": "id"
+      });
+    });
+  });
+});

package/src/services/PlatformFastifyResponse.ts

@@ -0,0 +1,100 @@
+import type {ServerResponse} from "node:http";
+
+import {type PlatformContext, PlatformResponse} from "@tsed/platform-http";
+import contentDisposition from "content-disposition";
+import type {FastifyReply} from "fastify";
+
+declare global {
+  namespace TsED {
+    export interface Response extends FastifyReply {
+      locals: Record<string, unknown>;
+    }
+  }
+}
+
+/**
+ * @platform
+ * @fastify
+ */
+export class PlatformFastifyResponse extends PlatformResponse<TsED.Response> {
+  constructor(readonly $ctx: PlatformContext) {
+    super($ctx);
+    this.raw.locals = {};
+  }
+
+  // set raw(raw: FastifyReply) {
+  //   this.$ctx.event.response = raw;
+  // }
+
+  /**
+   * Return the Node.js response object
+   */
+  getRes(): ServerResponse {
+    return this.raw.raw;
+  }
+
+  /**
+   * Sets the HTTP status for the response.
+   *
+   * @param status
+   */
+  status(status: number) {
+    this.raw.code(status);
+
+    return this;
+  }
+
+  /**
+   * Set `Content-Type` response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  contentType(contentType: string) {
+    this.raw.type(contentType);
+
+    return this;
+  }
+
+  /**
+   * Returns the HTTP response header specified by field. The match is case-insensitive.
+   *
+   * ```typescript
+   * response.get('Content-Type') // => "text/plain"
+   * ```
+   *
+   * @param name
+   */
+  get(name: string) {
+    return this.raw.getHeader(name);
+  }
+
+  attachment(filename: string) {
+    this.setHeader("Content-Disposition", contentDisposition(filename));
+    return this;
+  }
+
+  setHeader(key: string, item: any) {
+    this.raw.header(key, this.formatHeader(key, item));
+
+    return this;
+  }
+
+  stream(data: any) {
+    this.raw.send(data);
+
+    return this;
+  }
+
+  json(data: any) {
+    this.raw.send(data);
+
+    return this;
+  }
+}

package/vitest.config.mts

@@ -0,0 +1,21 @@
+// @ts-ignore
+import {presets} from "@tsed/vitest/presets";
+import {defineConfig} from "vitest/config";
+
+export default defineConfig(
+  {
+    ...presets,
+    test: {
+      ...presets.test,
+      coverage: {
+        ...presets.test.coverage,
+        thresholds: {
+          statements: 0,
+          branches: 0,
+          functions: 0,
+          lines: 0
+        }
+      }
+    }
+  }
+);