@tsed/platform-response-filter 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-response-filter",
   "description": "Platform response filter 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"
@@ -25,23 +26,23 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/json-mapper": "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/exceptions": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
+    "@tsed/schema": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/schema": "8.0.1"
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/exceptions": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
+    "@tsed/schema": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/src/decorators/responseFilter.ts

@@ -0,0 +1,17 @@
+import {injectable} from "@tsed/di";
+
+import {registerResponseFilter, ResponseFilterKey} from "../domain/ResponseFiltersContainer.js";
+
+/**
+ * Register a response filter service.
+ * @param contentTypes
+ * @decorator
+ */
+export function ResponseFilter(...contentTypes: ResponseFilterKey[]): ClassDecorator {
+  return (target: any) => {
+    contentTypes.forEach((contentType) => {
+      registerResponseFilter(contentType, target as any);
+    });
+    injectable(target).class(target);
+  };
+}

package/src/domain/ResponseFiltersContainer.ts

@@ -0,0 +1,18 @@
+import {Type} from "@tsed/core";
+
+import {ResponseFilterMethods} from "../interfaces/ResponseFilterMethods.js";
+/**
+ * @ignore
+ */
+export type ResponseFilterKey = "*/*" | "application/json" | "text/html" | "plain/text" | string;
+/**
+ * @ignore
+ */
+// tslint:disable-next-line:variable-name
+export const ResponseFiltersContainer = new Map<ResponseFilterKey, Type<ResponseFilterMethods>>();
+/**
+ * @ignore
+ */
+export function registerResponseFilter(type: ResponseFilterKey, token: Type<ResponseFilterMethods>) {
+  ResponseFiltersContainer.set(type, token);
+}

package/src/errors/TemplateRenderError.spec.ts

@@ -0,0 +1,9 @@
+import {TemplateRenderError} from "./TemplateRenderError.js";
+
+describe("TemplateRenderingError", () => {
+  it("should have a message", () => {
+    const errorInstance = new TemplateRenderError(class Target {}, "method", new Error("test"));
+    expect(errorInstance.message).toEqual("Template rendering error: Target.method()\nError: test");
+    expect(errorInstance.name).toEqual("TEMPLATE_RENDER_ERROR");
+  });
+});

package/src/errors/TemplateRenderError.ts

@@ -0,0 +1,21 @@
+import {nameOf, Type} from "@tsed/core";
+import {InternalServerError} from "@tsed/exceptions";
+
+/**
+ * @private
+ */
+export class TemplateRenderError extends InternalServerError {
+  name = "TEMPLATE_RENDER_ERROR";
+
+  constructor(target: Type<any> | string, method: string | symbol, err: Error) {
+    super(TemplateRenderError.buildMessage(target, method, err));
+  }
+
+  /**
+   *
+   * @returns {string}
+   */
+  static buildMessage(target: Type<any> | string, method: string | symbol, err: Error) {
+    return `Template rendering error: ${nameOf(target)}.${String(method)}()\n` + err;
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/responseFilter.js";
+export * from "./domain/ResponseFiltersContainer.js";
+export * from "./errors/TemplateRenderError.js";
+export * from "./interfaces/ResponseFilterMethods.js";
+export * from "./services/PlatformResponseFilter.js";
+export * from "./utils/getContentType.js";
+export * from "./utils/renderView.js";

package/src/interfaces/ResponseFilterMethods.ts

@@ -0,0 +1,17 @@
+import {Type} from "@tsed/core";
+import type {BaseContext} from "@tsed/di";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      /**
+       * A list of response filters must be called before returning a response to the consumer. See more on [Response filters](/docs/response-filter.md).
+       */
+      responseFilters: Type<ResponseFilterMethods>[];
+    }
+  }
+}
+
+export interface ResponseFilterMethods<T = unknown> {
+  transform(data: T, ctx: BaseContext): any;
+}

package/src/services/PlatformResponseFilter.spec.ts

@@ -0,0 +1,336 @@
+import {catchAsyncError} from "@tsed/core";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {Context} from "@tsed/platform-params";
+import {EndpointMetadata, Get, Returns, View} from "@tsed/schema";
+
+import {ResponseFilter} from "../decorators/responseFilter.js";
+import {ResponseFilterMethods} from "../interfaces/ResponseFilterMethods.js";
+import {PlatformResponseFilter} from "./PlatformResponseFilter.js";
+
+@ResponseFilter("custom/json")
+class CustomJsonFilter implements ResponseFilterMethods {
+  transform(data: unknown, ctx: Context) {
+    return {data};
+  }
+}
+
+@ResponseFilter("application/json")
+class ApplicationJsonFilter implements ResponseFilterMethods {
+  transform(data: unknown, ctx: Context) {
+    return {data, "content-type": "application/json"};
+  }
+}
+
+@ResponseFilter("*/*")
+class AllFilter implements ResponseFilterMethods {
+  transform(data: unknown, ctx: Context) {
+    return {data, "content-type": "*/*"};
+  }
+}
+
+describe("PlatformResponseFilter", () => {
+  describe("transform()", () => {
+    describe("when filter list is given", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          responseFilters: [CustomJsonFilter, AllFilter, ApplicationJsonFilter]
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+
+      it("should transform data for custom/json", async () => {
+        class Test {
+          @Get("/")
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+        const data = {text: "test"};
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue("custom/json");
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(["custom/json"]);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          data: {
+            text: "test"
+          }
+        });
+      });
+      it("should transform data for application/json", async () => {
+        class Test {
+          @Get("/")
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+        const data = {text: "test"};
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue("application/json");
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(["application/json"]);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          "content-type": "application/json",
+          data: {
+            text: "test"
+          }
+        });
+      });
+      it("should return data without transformation", async () => {
+        class Test {
+          @Get("/")
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        const data = {text: "test"};
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue("application/json");
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(["application/json"]);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          text: "test"
+        });
+      });
+      it("should get content-type set from response", async () => {
+        class Test {
+          @Get("/")
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+        const data = {text: "test"};
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue("text/json; charset: utf-8");
+        vi.spyOn(ctx.request, "get").mockReturnValue("application/json");
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(["application/json"]);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          "content-type": "application/json",
+          data: {
+            text: "test"
+          }
+        });
+      });
+      it("should transform data for any content type", async () => {
+        class Test {
+          @Get("/")
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        const data = {text: "test"};
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue("*/*");
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(["application/json"]);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          "content-type": "application/json",
+          data: {
+            text: "test"
+          }
+        });
+      });
+    });
+
+    describe("when filter list is not given", () => {
+      beforeEach(() =>
+        PlatformTest.create({
+          responseFilters: [AllFilter]
+        })
+      );
+      afterEach(() => PlatformTest.reset());
+      it("should transform data for default content-type from metadata", async () => {
+        class Test {
+          @Get("/")
+          @(Returns(200).ContentType("application/json"))
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        const data = {text: "test"};
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(false);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          "content-type": "*/*",
+          data: {
+            text: "test"
+          }
+        });
+      });
+      it("should transform data for default content-type from metadata with any response filter", async () => {
+        class Test {
+          @Get("/")
+          @(Returns(200).ContentType("application/json"))
+          test() {}
+        }
+
+        const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+
+        const ctx = PlatformTest.createRequestContext();
+        const data = {text: "test"};
+        ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+        vi.spyOn(ctx.response, "contentType").mockReturnThis();
+        vi.spyOn(ctx.response, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "get").mockReturnValue(undefined);
+        vi.spyOn(ctx.request, "accepts").mockReturnValue(false);
+
+        const result = await platformResponseFilter.transform(data, ctx);
+
+        expect(result).toEqual({
+          "content-type": "*/*",
+          data: {
+            text: "test"
+          }
+        });
+      });
+    });
+  });
+  describe("serialize()", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        responseFilters: [CustomJsonFilter, AllFilter, ApplicationJsonFilter]
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+    it("should transform value", async () => {
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+
+      const result = await platformResponseFilter.serialize({test: "test"}, ctx);
+
+      expect(result).toEqual({test: "test"});
+    });
+    it("should transform value (endpoint)", async () => {
+      class Test {
+        @Get("/")
+        test() {}
+      }
+
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+      ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+      vi.spyOn(ctx.endpoint, "getResponseOptions");
+
+      const result = await platformResponseFilter.serialize({test: "test"}, ctx);
+
+      expect(result).toEqual({test: "test"});
+      expect(ctx.endpoint.getResponseOptions).toHaveBeenCalledWith(200, {includes: undefined});
+    });
+    it("should transform value (endpoint + includes)", async () => {
+      class Test {
+        @Get("/")
+        test() {}
+      }
+
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+      ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+      vi.spyOn(ctx.endpoint, "getResponseOptions");
+
+      ctx.request.query.includes = [];
+
+      const result = await platformResponseFilter.serialize({test: "test"}, ctx);
+
+      expect(result).toEqual({test: "test"});
+      expect(ctx.endpoint.getResponseOptions).toHaveBeenCalledWith(200, {includes: []});
+    });
+    it("should transform value (endpoint + includes with ,)", async () => {
+      class Test {
+        @Get("/")
+        test() {}
+      }
+
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+      ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+      vi.spyOn(ctx.endpoint, "getResponseOptions");
+
+      ctx.request.query.includes = ["test,test2"];
+
+      const result = await platformResponseFilter.serialize({test: "test"}, ctx);
+
+      expect(result).toEqual({test: "test"});
+      expect(ctx.endpoint.getResponseOptions).toHaveBeenCalledWith(200, {
+        includes: ["test", "test2"]
+      });
+    });
+    it("should transform value (endpoint - view)", async () => {
+      class Test {
+        @Get("/")
+        @View("test.pug")
+        test() {}
+      }
+
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+      ctx.endpoint = EndpointMetadata.get(Test, "test");
+      vi.spyOn(ctx.response, "render").mockResolvedValue("template");
+
+      const result = await platformResponseFilter.serialize({test: "test"}, ctx);
+
+      expect(result).toEqual("template");
+    });
+    it("should transform value (endpoint - view - error)", async () => {
+      class Test {
+        @Get("/")
+        @View("test.pug")
+        test() {}
+      }
+
+      const platformResponseFilter = PlatformTest.get<PlatformResponseFilter>(PlatformResponseFilter);
+      const ctx = PlatformTest.createRequestContext();
+      ctx.endpoint = EndpointMetadata.get(Test, "test");
+      vi.spyOn(ctx.response, "render").mockRejectedValue(new Error("parsing error"));
+
+      const result = await catchAsyncError(() => platformResponseFilter.serialize({test: "test"}, ctx));
+
+      expect(result?.message).toEqual("Template rendering error: Test.test()\nError: parsing error");
+    });
+  });
+});

package/src/services/PlatformResponseFilter.ts

@@ -0,0 +1,112 @@
+import {isSerializable, Type} from "@tsed/core";
+import {BaseContext, constant, inject, injectable, TokenProvider} from "@tsed/di";
+import {serialize} from "@tsed/json-mapper";
+
+import {ResponseFilterKey, ResponseFiltersContainer} from "../domain/ResponseFiltersContainer.js";
+import {ResponseFilterMethods} from "../interfaces/ResponseFilterMethods.js";
+import {ANY_CONTENT_TYPE, getContentType} from "../utils/getContentType.js";
+import {renderView} from "../utils/renderView.js";
+
+/**
+ * @platform
+ */
+export class PlatformResponseFilter {
+  protected types: Map<ResponseFilterKey, TokenProvider> = new Map();
+  protected responseFilters = constant<Type<ResponseFilterMethods>[]>("responseFilters", []);
+  protected additionalProperties = constant<boolean>("additionalProperties");
+
+  constructor() {
+    ResponseFiltersContainer.forEach((token, type) => {
+      if (this.responseFilters.includes(token)) {
+        this.types.set(type, token);
+      }
+    });
+  }
+
+  get contentTypes(): ResponseFilterKey[] {
+    return [...this.types.keys()];
+  }
+
+  getBestContentType(data: any, ctx: BaseContext) {
+    const contentType = getContentType(data, ctx);
+
+    if (ctx.request.get("Accept")) {
+      const bestContentType = ctx.request.accepts([contentType].concat(this.contentTypes).filter(Boolean));
+
+      if (bestContentType) {
+        return [].concat(bestContentType as any).filter((type) => type !== "*/*")[0];
+      }
+    }
+
+    return contentType;
+  }
+
+  /**
+   * Call filters to transform data
+   * @param data
+   * @param ctx
+   */
+  transform(data: unknown, ctx: BaseContext) {
+    const {response} = ctx;
+
+    if (ctx.endpoint?.operation) {
+      const bestContentType = this.getBestContentType(data, ctx);
+
+      bestContentType && response.contentType(bestContentType);
+
+      const resolved = this.resolve(bestContentType);
+
+      if (resolved) {
+        return resolved.transform(data, ctx);
+      }
+    }
+
+    return data;
+  }
+
+  /**
+   * Serialize data before calling filters
+   * @param data
+   * @param ctx
+   */
+  async serialize(data: unknown, ctx: BaseContext) {
+    const {response, endpoint} = ctx;
+
+    if (endpoint) {
+      if (endpoint.view) {
+        data = await renderView(data, ctx);
+      } else if (isSerializable(data)) {
+        const responseOpts = endpoint.getResponseOptions(response.statusCode, {
+          includes: this.getIncludes(ctx)
+        });
+
+        data = serialize(data, {
+          useAlias: true,
+          additionalProperties: this.additionalProperties,
+          ...responseOpts,
+          endpoint: true
+        });
+      }
+    }
+
+    return data;
+  }
+
+  private resolve(bestContentType: string) {
+    const token = this.types.get(bestContentType) || this.types.get(ANY_CONTENT_TYPE);
+
+    if (token) {
+      return inject<ResponseFilterMethods>(token);
+    }
+  }
+
+  private getIncludes(ctx: BaseContext) {
+    if (ctx.request.query.includes) {
+      return [].concat(ctx.request.query.includes).flatMap((include: string) => include.split(","));
+    }
+
+    return undefined;
+  }
+}
+
+injectable(PlatformResponseFilter);

package/src/utils/getContentType.spec.ts

@@ -0,0 +1,113 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {EndpointMetadata, Get, Returns, View} from "@tsed/schema";
+
+import {getContentType} from "./getContentType.js";
+
+describe("getContentType", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should return the content type (undefined)", () => {
+    class TestController {
+      @Get("/")
+      get() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(TestController, "get");
+
+    const result = getContentType(
+      {
+        test: "test"
+      },
+      ctx
+    );
+
+    expect(result).toEqual(undefined);
+  });
+  it("should return the content type (object - application/json)", () => {
+    class TestController {
+      @Get("/")
+      @(Returns(200).ContentType("application/json"))
+      get() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(TestController, "get");
+    ctx.response.getRes().statusCode = 200;
+    vi.spyOn(ctx.response, "getContentType").mockReturnValue("application/json");
+
+    const result = getContentType(
+      {
+        test: "test"
+      },
+      ctx
+    );
+
+    expect(result).toEqual("application/json");
+  });
+  it("should return the content type (string - application/json)", () => {
+    class TestController {
+      @Get("/")
+      @(Returns(200).ContentType("application/json"))
+      get() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(TestController, "get");
+    ctx.response.getRes().statusCode = 200;
+    vi.spyOn(ctx.response, "getContentType").mockReturnValue("application/json");
+
+    const result = getContentType(
+      {
+        test: "test"
+      },
+      ctx
+    );
+
+    expect(result).toEqual("application/json");
+  });
+  it("should return the content type (string - text/html)", () => {
+    class TestController {
+      @Get("/")
+      @(Returns(200).ContentType("text/html"))
+      get() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(TestController, "get");
+    ctx.response.getRes().statusCode = 200;
+    vi.spyOn(ctx.response, "getContentType").mockReturnValue("text/html");
+
+    const result = getContentType(
+      {
+        test: "test"
+      },
+      ctx
+    );
+
+    expect(result).toEqual("text/html");
+  });
+  it("should return the content type (string - view)", () => {
+    class TestController {
+      @Get("/")
+      @Returns(200)
+      @View("view.html")
+      get() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(TestController, "get");
+    ctx.response.getRes().statusCode = 200;
+    ctx.view = "true";
+
+    const result = getContentType(
+      {
+        test: "test"
+      },
+      ctx
+    );
+
+    expect(result).toEqual("text/html");
+  });
+});

package/src/utils/getContentType.ts

@@ -0,0 +1,26 @@
+import {isObject} from "@tsed/core";
+import type {BaseContext} from "@tsed/di";
+
+export const ANY_CONTENT_TYPE = "*/*";
+
+/**
+ * @ignore
+ */
+export function getContentType(data: any, ctx: BaseContext) {
+  const {endpoint, response} = ctx;
+  const {operation} = endpoint;
+
+  const contentType = response.getContentType() || operation.getContentTypeOf(response.statusCode) || "";
+
+  if (contentType && contentType !== ANY_CONTENT_TYPE) {
+    if (contentType === "application/json" && isObject(data)) {
+      return "application/json";
+    }
+
+    return contentType;
+  }
+
+  if (endpoint.view) {
+    return "text/html";
+  }
+}

package/src/utils/renderView.spec.ts

@@ -0,0 +1,64 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {EndpointMetadata, Get, Ignore, Property, Returns, View} from "@tsed/schema";
+
+import {renderView} from "./renderView.js";
+
+describe("renderView", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  it("should render content", async () => {
+    class Model {
+      @Property()
+      data: string;
+
+      @Ignore()
+      test: string;
+    }
+
+    class Test {
+      @Get("/")
+      @View("view", {options: "options"})
+      @Returns(200, Model)
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    vi.spyOn(ctx.response, "render").mockResolvedValue("HTML");
+
+    ctx.data = {data: "data"};
+
+    await renderView(ctx.data, ctx);
+
+    expect(ctx.response.render).toHaveBeenCalledWith("view", {
+      $ctx: ctx,
+      data: "data",
+      options: "options"
+    });
+  });
+  it("should throw an error", async () => {
+    class Test {
+      @Get("/")
+      @View("view", {options: "options"})
+      test() {}
+    }
+
+    const ctx = PlatformTest.createRequestContext();
+    ctx.endpoint = EndpointMetadata.get(Test, "test");
+
+    vi.spyOn(ctx.response, "render").mockRejectedValue(new Error("parser error"));
+
+    ctx.data = {data: "data"};
+
+    let actualError: any;
+    try {
+      await renderView(ctx.data, ctx);
+    } catch (er) {
+      actualError = er;
+    }
+
+    expect(actualError.message).toEqual("Template rendering error: Test.test()\nError: parser error");
+  });
+});

package/src/utils/renderView.ts

@@ -0,0 +1,15 @@
+import {BaseContext} from "@tsed/di";
+
+import {TemplateRenderError} from "../errors/TemplateRenderError.js";
+
+export async function renderView(data: any, $ctx: BaseContext) {
+  const {response, endpoint} = $ctx;
+  try {
+    const {data} = $ctx;
+    const {path, options} = endpoint.view;
+
+    return await response.render(path, {...options, ...data, $ctx});
+  } catch (err) {
+    throw new TemplateRenderError(endpoint.targetName, endpoint.propertyKey, err);
+  }
+}