@tsed/vike 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/vike",
   "description": "Vike package 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,12 +26,12 @@
     "sirv": "^2.0.4"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/platform-http": "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/platform-http": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vike": "0.4.198",
@@ -38,7 +39,7 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/platform-http": "8.0.1",
+    "@tsed/platform-http": "8.0.2",
     "vike": ">=0.4.160",
     "vite": ">=4"
   },

package/src/ViteModule.spec.ts

@@ -0,0 +1,104 @@
+import {PlatformApplication} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {PlatformViews} from "@tsed/platform-views";
+
+import {ViteRendererMiddleware} from "./middlewares/ViteRendererMiddleware.js";
+import {VITE_SERVER} from "./services/ViteServer.js";
+import {ViteService} from "./services/ViteService.js";
+import {ViteModule} from "./ViteModule.js";
+
+async function getModuleFixture() {
+  const platformViews = {
+    registerEngine: vi.fn()
+  };
+  const viteService = {
+    render: vi.fn()
+  };
+  const platformApplication = {
+    use: vi.fn(),
+    get: vi.fn()
+  };
+  const viteServer = {
+    middlewares: "middlewares"
+  };
+  const service = await PlatformTest.invoke<ViteModule>(ViteModule, [
+    {
+      token: ViteService,
+      use: viteService
+    },
+    {
+      token: PlatformApplication,
+      use: platformApplication
+    },
+    {
+      token: PlatformViews,
+      use: platformViews
+    },
+    {
+      token: VITE_SERVER,
+      use: viteServer
+    }
+  ]);
+
+  return {service, viteService, platformApplication, platformViews, viteServer};
+}
+
+describe("ViteModule", () => {
+  beforeEach(() =>
+    PlatformTest.create({
+      imports: [
+        {
+          token: VITE_SERVER,
+          use: {
+            middlewares: vi.fn()
+          }
+        }
+      ]
+    })
+  );
+  afterEach(() => PlatformTest.reset());
+
+  describe("$onInit()", () => {
+    it("should render html", async () => {
+      const {viteService, platformViews} = await getModuleFixture();
+      viteService.render.mockResolvedValue("html");
+      expect(platformViews.registerEngine).toHaveBeenCalledWith("vite", {options: {}, render: expect.any(Function)});
+
+      const result = await platformViews.registerEngine.mock.calls[0][1].render("path.vite", {$ctx: {}});
+
+      expect(result).toEqual("html");
+      expect(viteService.render).toHaveBeenCalledWith("path.vite", {$ctx: {}});
+    });
+
+    it("should render empty content", async () => {
+      const {viteService, platformViews} = await getModuleFixture();
+
+      viteService.render.mockResolvedValue(undefined);
+
+      expect(platformViews.registerEngine).toHaveBeenCalledWith("vite", {options: {}, render: expect.any(Function)});
+
+      const result = await platformViews.registerEngine.mock.calls[0][1].render("path.vite", {$ctx: {}});
+
+      expect(result).toEqual("");
+      expect(viteService.render).toHaveBeenCalledWith("path.vite", {$ctx: {}});
+    });
+  });
+  describe("$afterInit()", () => {
+    it("should add the middlewares", async () => {
+      const {service, platformApplication} = await getModuleFixture();
+
+      service.$afterInit();
+
+      expect(platformApplication.use).toHaveBeenCalledWith(expect.any(Function), "middlewares");
+    });
+  });
+  describe("$afterRoutesInit()", () => {
+    it("should handle all GET routes", async () => {
+      const {service, platformApplication} = await getModuleFixture();
+
+      service.$afterRoutesInit();
+
+      expect(platformApplication.get).toHaveBeenCalledWith("*", ViteRendererMiddleware);
+    });
+  });
+});

package/src/ViteModule.ts

@@ -0,0 +1,42 @@
+import {Inject, Module} from "@tsed/di";
+import {PlatformApplication} from "@tsed/platform-http";
+import {PlatformRenderOptions, PlatformViews} from "@tsed/platform-views";
+import compress from "compression";
+
+import {ViteRendererMiddleware} from "./middlewares/ViteRendererMiddleware.js";
+import {VITE_SERVER} from "./services/ViteServer.js";
+import {ViteService} from "./services/ViteService.js";
+
+@Module({
+  imports: []
+})
+export class ViteModule {
+  @Inject()
+  protected app: PlatformApplication;
+
+  @Inject()
+  protected platformView: PlatformViews;
+
+  @Inject()
+  protected viteService: ViteService;
+
+  @Inject(VITE_SERVER)
+  protected viteServer: VITE_SERVER;
+
+  $onInit() {
+    this.platformView.registerEngine("vite", {
+      options: {},
+      render: async (path: string, options: PlatformRenderOptions) => {
+        return (await this.viteService.render(path, options)) || "";
+      }
+    });
+  }
+
+  $afterInit() {
+    this.app.use(compress(), this.viteServer.middlewares);
+  }
+
+  $afterRoutesInit() {
+    return this.app.get("*", ViteRendererMiddleware);
+  }
+}

package/src/decorators/vite.spec.ts

@@ -0,0 +1,31 @@
+import {Store} from "@tsed/core";
+import {Controller} from "@tsed/di";
+
+import {Vite} from "./vite.js";
+
+@Controller("/")
+class ControllerTest {
+  @Vite()
+  post() {
+    return;
+  }
+
+  @Vite("nice-view")
+  postWithView() {
+    return;
+  }
+}
+
+describe("ViteDecorator", () => {
+  it("should return attached View with *.vite with empty path", () => {
+    const metadata = Store.fromMethod(ControllerTest, "post").get("view");
+
+    expect(metadata.path).toEqual("*.vite");
+  });
+
+  it("should return attached View with {path}.vite", () => {
+    const metadata = Store.fromMethod(ControllerTest, "postWithView").get("view");
+
+    expect(metadata.path).toEqual("nice-view.vite");
+  });
+});

package/src/decorators/vite.ts

@@ -0,0 +1,5 @@
+import {View} from "@tsed/schema";
+
+export function Vite(path?: string) {
+  return View(`${path || "*"}.vite`);
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/vite.js";
+export * from "./interfaces/interfaces.js";
+export * from "./interfaces/ViteConfig.js";
+export * from "./interfaces/ViteRenderContext.js";
+export * from "./middlewares/ViteRendererMiddleware.js";
+export * from "./services/ViteServer.js";
+export * from "./services/ViteService.js";
+export * from "./ViteModule.js";

package/src/interfaces/ViteConfig.ts

@@ -0,0 +1,9 @@
+import {Options} from "sirv";
+// @ts-ignore
+import type {InlineConfig} from "vite";
+
+export type ViteConfig = InlineConfig & {
+  enableStream?: boolean;
+  statics?: Omit<Options, "dev">;
+  stateSnapshot?(): unknown;
+};

package/src/interfaces/ViteRenderContext.ts

@@ -0,0 +1,13 @@
+import type {IncomingHttpHeaders} from "http";
+
+export type VitePageProps<Data = Record<string, unknown>> = Data & {view: string};
+
+export interface ViteRenderContext<Data = Record<string, unknown>, Session = Record<string, unknown>> extends Record<string, unknown> {
+  host: string;
+  protocol: string;
+  method: string;
+  url: string;
+  secure: boolean;
+  headers: IncomingHttpHeaders;
+  session?: Session;
+}

package/src/interfaces/interfaces.ts

@@ -0,0 +1,9 @@
+import {ViteConfig} from "./ViteConfig.js";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      vite: ViteConfig;
+    }
+  }
+}

package/src/middlewares/ViteRendererMiddleware.spec.ts

@@ -0,0 +1,65 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {ViteService} from "../services/ViteService.js";
+import {ViteRendererMiddleware} from "./ViteRendererMiddleware.js";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+describe("ViteRenderMiddleware", () => {
+  describe("use()", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        vite: {
+          root: rootDir
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+    it("should return the response", async () => {
+      const viteService = {
+        render: vi.fn()
+      };
+
+      const $ctx = PlatformTest.createRequestContext();
+      vi.spyOn($ctx.response, "body");
+
+      viteService.render.mockResolvedValue("result");
+      vi.spyOn($ctx.response, "isDone").mockReturnValue(false);
+
+      const middleware = await PlatformTest.invoke<ViteRendererMiddleware>(ViteRendererMiddleware, [
+        {
+          token: ViteService,
+          use: viteService
+        }
+      ]);
+
+      await middleware.use($ctx);
+
+      expect(viteService.render).toHaveBeenCalledWith("*", {$ctx});
+      expect($ctx.response.body).toHaveBeenCalledWith("result");
+    });
+    it("should not return the response", async () => {
+      const viteService = {
+        render: vi.fn()
+      };
+
+      const $ctx = PlatformTest.createRequestContext();
+      vi.spyOn($ctx.response, "body");
+      vi.spyOn($ctx.response, "isDone").mockReturnValue(true);
+
+      viteService.render.mockResolvedValue("result");
+
+      const middleware = await PlatformTest.invoke<ViteRendererMiddleware>(ViteRendererMiddleware, [
+        {
+          token: ViteService,
+          use: viteService
+        }
+      ]);
+
+      await middleware.use($ctx);
+
+      expect(viteService.render).toHaveBeenCalledWith("*", {$ctx});
+      expect($ctx.response.body).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/middlewares/ViteRendererMiddleware.ts

@@ -0,0 +1,17 @@
+import {Inject} from "@tsed/di";
+import {Middleware} from "@tsed/platform-middlewares";
+import {Context} from "@tsed/platform-params";
+
+import {ViteService} from "../services/ViteService.js";
+
+@Middleware()
+export class ViteRendererMiddleware {
+  @Inject()
+  protected viteService: ViteService;
+
+  async use(@Context() $ctx: Context) {
+    const response = await this.viteService.render("*", {$ctx});
+
+    response && !$ctx.response.isDone() && $ctx.response.body(response);
+  }
+}

package/src/services/ViteServer.spec.ts

@@ -0,0 +1,138 @@
+import {Env} from "@tsed/core";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import sirv from "sirv";
+
+import {VITE_SERVER} from "./ViteServer.js";
+
+vi.mock("sirv", () => {
+  return {default: vi.fn().mockReturnValue("sirv")};
+});
+vi.mock("vite", () => {
+  return {
+    createServer: vi.fn().mockResolvedValue({
+      middlewares: "middlewares",
+      close: vi.fn()
+    })
+  };
+});
+
+async function createTestFixture() {
+  const mod = await import("vite");
+
+  return {
+    createServer: mod.createServer
+  };
+}
+
+describe("ViteServer", () => {
+  describe("with default options - dev mode", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        vite: {}
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    it("should load vite dev server", async () => {
+      const {createServer} = await createTestFixture();
+      const viteDevServer = PlatformTest.get<VITE_SERVER>(VITE_SERVER);
+
+      expect(viteDevServer.middlewares).toEqual("middlewares");
+      expect(createServer).toHaveBeenCalledWith({
+        logLevel: "off",
+        server: {
+          middlewareMode: true
+        }
+      });
+    });
+    it("should load and close server", async () => {
+      const {createServer} = await createTestFixture();
+      const viteDevServer = PlatformTest.get<VITE_SERVER>(VITE_SERVER);
+      viteDevServer.close = vi.fn();
+
+      expect(viteDevServer.middlewares).toEqual("middlewares");
+      expect(createServer).toHaveBeenCalledWith({
+        logLevel: "off",
+        server: {
+          middlewareMode: true
+        }
+      });
+
+      await PlatformTest.injector.destroy();
+
+      expect(viteDevServer.close).toHaveBeenCalledWith();
+    });
+  });
+  describe("with defined options - dev mode", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        vite: {
+          logLevel: "error",
+          root: "/root",
+          server: {
+            middlewareMode: false
+          }
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    it("should load vite dev server", async () => {
+      const {createServer} = await createTestFixture();
+      const viteDevServer = PlatformTest.get<VITE_SERVER>(VITE_SERVER);
+
+      expect(viteDevServer.middlewares).toEqual("middlewares");
+      expect(createServer).toHaveBeenCalledWith({
+        logLevel: "error",
+        root: "/root",
+        server: {
+          middlewareMode: true
+        }
+      });
+    });
+  });
+  describe("with default options - prod mode", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        env: Env.PROD,
+        vite: {},
+        logger: {
+          level: "off"
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    it("should load sirv to expose statics files", async () => {
+      await createTestFixture();
+      const viteDevServer = PlatformTest.get<VITE_SERVER>(VITE_SERVER);
+
+      expect(viteDevServer.middlewares).toEqual("sirv");
+      expect(sirv).toHaveBeenCalledWith("/dist/client", {
+        dev: false,
+        dotfiles: false
+      });
+    });
+  });
+  describe("with defined options - prod mode", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        env: Env.PROD,
+        logger: {
+          level: "off"
+        },
+        vite: {
+          root: "/root"
+        }
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    it("should load sirv to expose statics files", () => {
+      const viteDevServer = PlatformTest.get<VITE_SERVER>(VITE_SERVER);
+
+      expect(viteDevServer.middlewares).toEqual("sirv");
+      expect(sirv).toHaveBeenCalledWith("/root/dist/client", {dev: false, dotfiles: false});
+    });
+  });
+});

package/src/services/ViteServer.ts

@@ -0,0 +1,50 @@
+import {Env} from "@tsed/core";
+import {Configuration, registerProvider} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+// @ts-ignore
+import type {InlineConfig, ViteDevServer} from "vite";
+
+import {ViteConfig} from "../interfaces/ViteConfig.js";
+
+export const VITE_SERVER = Symbol.for("VITE_DEV_SERVER");
+export type VITE_SERVER = ViteDevServer;
+
+registerProvider({
+  token: VITE_SERVER,
+  deps: [Configuration, Logger],
+  async useAsyncFactory(settings: Configuration, logger: Logger) {
+    const {enableStream, statics: staticsOpts = {}, ...config} = settings.get<ViteConfig & InlineConfig>("vite", {});
+    const level = settings.logger.level;
+
+    if (settings.env !== Env.PROD) {
+      logger.info("Start Vite Dev Server 🚀...");
+      // @ts-ignore
+      const {createServer} = await import("vite");
+
+      return createServer({
+        ...config,
+        server: {
+          ...(config?.server || {}),
+          middlewareMode: true
+        },
+        logLevel: String(config.logLevel || level) as any
+      });
+    }
+
+    logger.info("Initialize statics vite application");
+    const {default: sirv} = await import("sirv");
+
+    return Promise.resolve({
+      middlewares: sirv(`${config.root || ""}/dist/client`, {
+        dotfiles: false,
+        ...staticsOpts,
+        dev: false
+      })
+    });
+  },
+  hooks: {
+    $onDestroy(viteDevServer: Partial<ViteDevServer>): Promise<any> | void {
+      return viteDevServer.close && viteDevServer.close();
+    }
+  }
+});

package/src/services/ViteService.spec.ts

@@ -0,0 +1,254 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {ViteService} from "./ViteService.js";
+
+vi.mock("vike/server", () => {
+  return {
+    renderPage: vi.fn()
+  };
+});
+
+async function getServiceFixture(httpResponse: any) {
+  const $ctx = PlatformTest.createRequestContext();
+
+  const service = await PlatformTest.invoke<ViteService>(ViteService, []);
+
+  $ctx.request.req.method = "GET";
+  $ctx.request.req.url = "/";
+  // @ts-ignore
+  $ctx.request.req.session = {};
+  // @ts-ignore
+  $ctx.request.req.secure = true;
+  // @ts-ignore
+  $ctx.request.req.protocol = "https";
+  $ctx.request.req.headers = {
+    host: "host",
+    "x-header": "x-header",
+    "user-agent": "ua"
+  };
+
+  const pageContext = {
+    httpResponse
+  };
+  const mod = await import("vike/server");
+
+  vi.mocked(mod.renderPage).mockResolvedValue(pageContext as never);
+
+  return {
+    renderPage: mod.renderPage,
+    service,
+    $ctx,
+    pageContext,
+    stateSnapshot: PlatformTest.injector.settings.get("stateSnapshot")
+  };
+}
+
+describe("ViteService", () => {
+  describe("render()", () => {
+    describe("when the enableStream: false", () => {
+      beforeEach(() => {
+        vi.resetAllMocks();
+        return PlatformTest.create({
+          vite: {root: "./path/to/client", stateSnapshot: vi.fn().mockReturnValue({state: "state"})}
+        });
+      });
+      afterEach(() => PlatformTest.reset());
+
+      it("should render the page", async () => {
+        const {$ctx, service, renderPage} = await getServiceFixture({
+          statusCode: 200,
+          headers: [["content-type", "text/html"]],
+          body: "html"
+        });
+
+        vi.spyOn($ctx.response, "status").mockReturnThis();
+        vi.spyOn($ctx.response, "setHeader").mockReturnThis();
+
+        const result = await service.render("*", {$ctx});
+
+        expect(result).toEqual("html");
+        expect(renderPage).toHaveBeenCalledWith({
+          view: "*",
+          pageProps: {
+            view: "*"
+          },
+          contextProps: {
+            headers: {
+              host: "host",
+              "x-header": "x-header",
+              "user-agent": "ua"
+            },
+            host: "host",
+            method: "GET",
+            protocol: "https",
+            secure: true,
+            session: {},
+            stateSnapshot: {state: "state"},
+            url: "/"
+          },
+          urlOriginal: "/",
+          userAgent: "ua"
+        });
+        expect($ctx.response.status).toHaveBeenCalledWith(200);
+        expect($ctx.response.setHeader).toHaveBeenCalledWith("content-type", "text/html");
+      });
+      it("should return empty content if the page doesn't contains jsx content", async () => {
+        const {$ctx, service, renderPage} = await getServiceFixture(null);
+
+        vi.spyOn($ctx.response, "status").mockReturnThis();
+        vi.spyOn($ctx.response, "body").mockReturnThis();
+        vi.spyOn($ctx.response, "contentType").mockReturnThis();
+
+        const result = await service.render("vue.vite", {$ctx, valueOpt: "valueOpt"});
+
+        expect(result).toEqual(undefined);
+        expect(renderPage).toHaveBeenCalledWith(
+          expect.objectContaining({
+            view: "vue",
+            pageProps: {
+              view: "vue",
+              valueOpt: "valueOpt"
+            },
+            contextProps: {
+              headers: {
+                host: "host",
+                "x-header": "x-header",
+                "user-agent": "ua"
+              },
+              host: "host",
+              method: "GET",
+              protocol: "https",
+              secure: true,
+              session: {},
+              stateSnapshot: {state: "state"},
+              url: "/"
+            },
+            urlOriginal: "/",
+            userAgent: "ua"
+          })
+        );
+        expect($ctx.response.status).not.toHaveBeenCalled();
+        expect($ctx.response.contentType).not.toHaveBeenCalled();
+        expect($ctx.response.body).not.toHaveBeenCalled();
+      });
+      it("should log render error", async () => {
+        const {$ctx, service, renderPage} = await getServiceFixture(null);
+
+        vi.spyOn($ctx.logger, "error").mockReturnThis();
+
+        (renderPage as any).mockResolvedValue({
+          httpResponse: {},
+          errorWhileRendering: new Error("")
+        });
+
+        vi.spyOn($ctx.response, "status").mockReturnThis();
+        vi.spyOn($ctx.response, "body").mockReturnThis();
+        vi.spyOn($ctx.response, "setHeader").mockReturnThis();
+
+        await service.render("vue.vite", {$ctx});
+
+        expect($ctx.logger.error).toHaveBeenCalled();
+      });
+    });
+
+    describe("when the enableStream: true", () => {
+      beforeEach(() => {
+        vi.resetAllMocks();
+        return PlatformTest.create({
+          vite: {
+            enableStream: true,
+            root: "./path/to/client",
+            stateSnapshot: vi.fn().mockReturnValue({state: "state"})
+          }
+        });
+      });
+      afterEach(() => PlatformTest.reset());
+
+      it("should render the page", async () => {
+        const {$ctx, service, renderPage} = await getServiceFixture({
+          statusCode: 200,
+          headers: [["content-type", "text/html"]],
+          body: "html"
+        });
+
+        vi.spyOn($ctx.response, "status").mockReturnThis();
+        vi.spyOn($ctx.response, "setHeader").mockReturnThis();
+
+        const result = await service.render("*", {$ctx});
+
+        expect(result).toEqual({
+          body: "html",
+          headers: [["content-type", "text/html"]],
+          statusCode: 200
+        });
+        expect(renderPage).toHaveBeenCalledWith({
+          view: "*",
+          pageProps: {
+            view: "*"
+          },
+          contextProps: {
+            headers: {
+              host: "host",
+              "x-header": "x-header",
+              "user-agent": "ua"
+            },
+            host: "host",
+            method: "GET",
+            protocol: "https",
+            secure: true,
+            session: {},
+            stateSnapshot: {state: "state"},
+            url: "/"
+          },
+          urlOriginal: "/",
+          userAgent: "ua"
+        });
+        expect($ctx.response.status).toHaveBeenCalledWith(200);
+        expect($ctx.response.setHeader).toHaveBeenCalledWith("content-type", "text/html");
+      });
+
+      it("should render the page with statusCode from context.response if superior to httpResponse.statusCode", async () => {
+        const {$ctx, service, renderPage} = await getServiceFixture({
+          statusCode: 200,
+          headers: [["content-type", "text/html"]],
+          body: "html"
+        });
+
+        $ctx.response.status(404);
+        vi.spyOn($ctx.response, "status").mockReturnThis();
+        vi.spyOn($ctx.response, "setHeader").mockReturnThis();
+        const result = await service.render("*", {$ctx});
+
+        expect(result).toEqual({
+          body: "html",
+          headers: [["content-type", "text/html"]],
+          statusCode: 200
+        });
+        expect(renderPage).toHaveBeenCalledWith({
+          view: "*",
+          pageProps: {
+            view: "*"
+          },
+          contextProps: {
+            headers: {
+              host: "host",
+              "x-header": "x-header",
+              "user-agent": "ua"
+            },
+            host: "host",
+            method: "GET",
+            protocol: "https",
+            secure: true,
+            session: {},
+            stateSnapshot: {state: "state"},
+            url: "/"
+          },
+          urlOriginal: "/",
+          userAgent: "ua"
+        });
+        expect($ctx.response.status).toHaveBeenCalledWith(404);
+        expect($ctx.response.setHeader).toHaveBeenCalledWith("content-type", "text/html");
+      });
+    });
+  });
+});

package/src/services/ViteService.ts

@@ -0,0 +1,74 @@
+import {Constant, Injectable} from "@tsed/di";
+import {PlatformContext} from "@tsed/platform-http";
+import {Writable} from "stream";
+
+import {ViteConfig} from "../interfaces/ViteConfig.js";
+import {ViteRenderContext} from "../interfaces/ViteRenderContext.js";
+
+@Injectable()
+export class ViteService {
+  static moduleName = "vike/server";
+
+  @Constant("vite", {})
+  protected config: ViteConfig;
+
+  @Constant("vite.enableStream", false)
+  private enableStream: boolean;
+
+  async render(
+    viewPath: string,
+    {$ctx, ...opts}: {$ctx: PlatformContext} & Record<string, any>
+  ): Promise<string | {pipe(stream: Writable): void} | undefined> {
+    const urlOriginal = $ctx.request.url;
+
+    const {data} = $ctx;
+    const view = viewPath.replace(".vite", "");
+
+    const pageProps = {
+      view,
+      ...$ctx.response.locals,
+      ...opts,
+      ...data
+    };
+
+    const contextProps: ViteRenderContext = {
+      host: $ctx.request.host,
+      protocol: $ctx.request.protocol,
+      method: $ctx.request.method,
+      url: urlOriginal,
+      secure: $ctx.request.secure,
+      headers: $ctx.request.headers,
+      session: $ctx.request.session,
+      stateSnapshot: this.config.stateSnapshot && this.config.stateSnapshot()
+    };
+
+    const {renderPage} = await import("vike/server");
+
+    const pageContext = await renderPage({
+      view,
+      urlOriginal,
+      pageProps,
+      contextProps,
+      userAgent: $ctx.request.headers["user-agent"]
+    });
+
+    if (pageContext.errorWhileRendering) {
+      $ctx.logger.error({
+        event: "VITE_RENDER_ERROR",
+        error: pageContext.errorWhileRendering
+      });
+    }
+
+    if (pageContext.httpResponse) {
+      const {httpResponse} = pageContext;
+      httpResponse.headers?.forEach(([name, value]: [string, string]) => $ctx.response.setHeader(name, value));
+      $ctx.response.status(Math.max(httpResponse.statusCode, $ctx.response.statusCode));
+
+      if (this.enableStream) {
+        return httpResponse;
+      }
+
+      return httpResponse.body;
+    }
+  }
+}