@nestjs-ssr/react 0.1.12 → 0.2.1

package/dist/render/index.d.mts

@@ -1,4 +1,4 @@
-export { E as ErrorPageDevelopment, f as ErrorPageProduction, b as RenderInterceptor, R as RenderModule, a as RenderService, S as StreamingErrorHandler, T as TemplateParserService } from '../index-BiaVDe9J.mjs';
+export { E as ErrorPageDevelopment, f as ErrorPageProduction, c as RenderInterceptor, a as RenderModule, b as RenderService, S as StreamingErrorHandler, T as TemplateParserService } from '../index-C5Knql-9.mjs';
 import '@nestjs/common';
 import 'react';
 import 'vite';

package/dist/render/index.d.ts

@@ -1,4 +1,4 @@
-export { E as ErrorPageDevelopment, f as ErrorPageProduction, b as RenderInterceptor, R as RenderModule, a as RenderService, S as StreamingErrorHandler, T as TemplateParserService } from '../index-BiaVDe9J.js';
+export { E as ErrorPageDevelopment, f as ErrorPageProduction, c as RenderInterceptor, a as RenderModule, b as RenderService, S as StreamingErrorHandler, T as TemplateParserService } from '../index-C5Knql-9.js';
 import '@nestjs/common';
 import 'react';
 import 'vite';

package/dist/render/index.js

@@ -4,7 +4,7 @@ var common = require('@nestjs/common');
 var core = require('@nestjs/core');
 var fs = require('fs');
 var path = require('path');
-var serialize = require('serialize-javascript');
+var devalue = require('devalue');
 var escapeHtml = require('escape-html');
 var server = require('react-dom/server');
 var react = require('react');
@@ -12,7 +12,6 @@ var operators = require('rxjs/operators');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var serialize__default = /*#__PURE__*/_interopDefault(serialize);
 var escapeHtml__default = /*#__PURE__*/_interopDefault(escapeHtml);
 
 var __defProp = Object.defineProperty;
@@ -105,21 +104,20 @@ exports.TemplateParserService = class TemplateParserService {
   /**
   * Build inline script that provides initial state to the client
   *
-  * Safely serializes data using serialize-javascript to avoid XSS vulnerabilities.
-  * This library handles all edge cases including escaping dangerous characters,
-  * functions, dates, regexes, and prevents prototype pollution.
+  * Safely serializes data using devalue to avoid XSS vulnerabilities.
+  * Devalue is designed specifically for SSR, handling complex types safely
+  * while being faster and more secure than alternatives.
   */
-  buildInlineScripts(data, context, componentName) {
+  buildInlineScripts(data, context, componentName, layouts) {
+    const layoutMetadata = layouts ? layouts.map((l) => ({
+      name: l.layout.displayName || l.layout.name || "default",
+      props: l.props
+    })) : [];
     return `<script>
-window.__INITIAL_STATE__ = ${serialize__default.default(data, {
-      isJSON: true
-    })};
-window.__CONTEXT__ = ${serialize__default.default(context, {
-      isJSON: true
-    })};
-window.__COMPONENT_NAME__ = ${serialize__default.default(componentName, {
-      isJSON: true
-    })};
+window.__INITIAL_STATE__ = ${devalue.uneval(data)};
+window.__CONTEXT__ = ${devalue.uneval(context)};
+window.__COMPONENT_NAME__ = ${devalue.uneval(componentName)};
+window.__LAYOUTS__ = ${devalue.uneval(layoutMetadata)};
 </script>`;
   }
   /**
@@ -428,12 +426,14 @@ exports.RenderService = class _RenderService {
   isDevelopment;
   ssrMode;
   entryServerPath;
-  constructor(templateParser, streamingErrorHandler, ssrMode, defaultHead) {
+  rootLayout = void 0;
+  rootLayoutChecked = false;
+  constructor(templateParser, streamingErrorHandler, ssrMode, defaultHead, customTemplate) {
     this.templateParser = templateParser;
     this.streamingErrorHandler = streamingErrorHandler;
     this.defaultHead = defaultHead;
     this.isDevelopment = process.env.NODE_ENV !== "production";
-    this.ssrMode = ssrMode || process.env.SSR_MODE || "string";
+    this.ssrMode = ssrMode || process.env.SSR_MODE || "stream";
     const absoluteServerPath = path.join(__dirname, "/templates/entry-server.tsx");
     const relativeServerPath = path.relative(process.cwd(), absoluteServerPath);
     if (relativeServerPath.startsWith("..")) {
@@ -441,36 +441,54 @@ exports.RenderService = class _RenderService {
     } else {
       this.entryServerPath = "/" + relativeServerPath.replace(/\\/g, "/");
     }
-    let templatePath;
-    if (this.isDevelopment) {
-      const packageTemplatePaths = [
-        path.join(__dirname, "../templates/index.html"),
-        path.join(__dirname, "../src/templates/index.html"),
-        path.join(__dirname, "../../src/templates/index.html")
-      ];
-      const localTemplatePath = path.join(process.cwd(), "src/views/index.html");
-      const foundPackageTemplate = packageTemplatePaths.find((p) => fs.existsSync(p));
-      if (foundPackageTemplate) {
-        templatePath = foundPackageTemplate;
-      } else if (fs.existsSync(localTemplatePath)) {
-        templatePath = localTemplatePath;
+    if (customTemplate) {
+      if (customTemplate.includes("<!DOCTYPE") || customTemplate.includes("<html")) {
+        this.template = customTemplate;
+        this.logger.log(`\u2713 Loaded custom template (inline)`);
       } else {
-        throw new Error(`Template file not found. Tried:
+        const customTemplatePath = customTemplate.startsWith("/") ? customTemplate : path.join(process.cwd(), customTemplate);
+        if (!fs.existsSync(customTemplatePath)) {
+          throw new Error(`Custom template file not found at ${customTemplatePath}`);
+        }
+        try {
+          this.template = fs.readFileSync(customTemplatePath, "utf-8");
+          this.logger.log(`\u2713 Loaded custom template from ${customTemplatePath}`);
+        } catch (error) {
+          throw new Error(`Failed to read custom template file at ${customTemplatePath}: ${error.message}`);
+        }
+      }
+    } else {
+      let templatePath;
+      if (this.isDevelopment) {
+        const packageTemplatePaths = [
+          path.join(__dirname, "../templates/index.html"),
+          path.join(__dirname, "../src/templates/index.html"),
+          path.join(__dirname, "../../src/templates/index.html")
+        ];
+        const localTemplatePath = path.join(process.cwd(), "src/views/index.html");
+        const foundPackageTemplate = packageTemplatePaths.find((p) => fs.existsSync(p));
+        if (foundPackageTemplate) {
+          templatePath = foundPackageTemplate;
+        } else if (fs.existsSync(localTemplatePath)) {
+          templatePath = localTemplatePath;
+        } else {
+          throw new Error(`Template file not found. Tried:
 ` + packageTemplatePaths.map((p) => `  - ${p} (package template)`).join("\n") + `
   - ${localTemplatePath} (local template)`);
+        }
+      } else {
+        templatePath = path.join(process.cwd(), "dist/client/index.html");
+        if (!fs.existsSync(templatePath)) {
+          throw new Error(`Template file not found at ${templatePath}. Make sure to run the build process first.`);
+        }
       }
-    } else {
-      templatePath = path.join(process.cwd(), "dist/client/index.html");
-      if (!fs.existsSync(templatePath)) {
-        throw new Error(`Template file not found at ${templatePath}. Make sure to run the build process first.`);
+      try {
+        this.template = fs.readFileSync(templatePath, "utf-8");
+        this.logger.log(`\u2713 Loaded template from ${templatePath}`);
+      } catch (error) {
+        throw new Error(`Failed to read template file at ${templatePath}: ${error.message}`);
       }
     }
-    try {
-      this.template = fs.readFileSync(templatePath, "utf-8");
-      this.logger.log(`\u2713 Loaded template from ${templatePath}`);
-    } catch (error) {
-      throw new Error(`Failed to read template file at ${templatePath}: ${error.message}`);
-    }
     if (!this.isDevelopment) {
       const manifestPath = path.join(process.cwd(), "dist/client/.vite/manifest.json");
       if (fs.existsSync(manifestPath)) {
@@ -490,6 +508,52 @@ exports.RenderService = class _RenderService {
     this.vite = vite;
   }
   /**
+  * Get the root layout component if it exists
+  * Auto-discovers layout files at conventional paths:
+  * - src/views/layout.tsx
+  * - src/views/layout/index.tsx
+  * - src/views/_layout.tsx
+  */
+  async getRootLayout() {
+    if (this.rootLayoutChecked) {
+      return this.rootLayout;
+    }
+    this.rootLayoutChecked = true;
+    const conventionalPaths = [
+      "src/views/layout.tsx",
+      "src/views/layout/index.tsx",
+      "src/views/_layout.tsx"
+    ];
+    try {
+      for (const path$1 of conventionalPaths) {
+        const absolutePath = path.join(process.cwd(), path$1);
+        if (!fs.existsSync(absolutePath)) {
+          continue;
+        }
+        this.logger.log(`\u2713 Found root layout at ${path$1}`);
+        if (this.vite) {
+          const layoutModule = await this.vite.ssrLoadModule("/" + path$1);
+          this.rootLayout = layoutModule.default;
+          return this.rootLayout;
+        } else {
+          const prodPath = path$1.replace("src/views", "dist/server/views").replace(".tsx", ".js");
+          const absoluteProdPath = path.join(process.cwd(), prodPath);
+          if (fs.existsSync(absoluteProdPath)) {
+            const layoutModule = await import(absoluteProdPath);
+            this.rootLayout = layoutModule.default;
+            return this.rootLayout;
+          }
+        }
+      }
+      this.rootLayout = null;
+      return null;
+    } catch (error) {
+      this.logger.warn(`\u26A0\uFE0F  Error loading root layout: ${error.message}`);
+      this.rootLayout = null;
+      return null;
+    }
+  }
+  /**
   * Main render method that routes to string or stream mode
   */
   async render(viewComponent, data = {}, res, head) {
@@ -551,20 +615,19 @@ exports.RenderService = class _RenderService {
           throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
         }
       }
-      const { data: pageData, __context: context } = data;
+      const { data: pageData, __context: context, __layouts: layouts } = data;
       const appHtml = await renderModule.renderComponent(viewComponent, data);
       const componentName = viewComponent.displayName || viewComponent.name || "Component";
+      const layoutMetadata = layouts ? layouts.map((l) => ({
+        name: l.layout.displayName || l.layout.name || "default",
+        props: l.props
+      })) : [];
       const initialStateScript = `
         <script>
-          window.__INITIAL_STATE__ = ${serialize__default.default(pageData, {
-        isJSON: true
-      })};
-          window.__CONTEXT__ = ${serialize__default.default(context, {
-        isJSON: true
-      })};
-          window.__COMPONENT_NAME__ = ${serialize__default.default(componentName, {
-        isJSON: true
-      })};
+          window.__INITIAL_STATE__ = ${devalue.uneval(pageData)};
+          window.__CONTEXT__ = ${devalue.uneval(context)};
+          window.__COMPONENT_NAME__ = ${devalue.uneval(componentName)};
+          window.__LAYOUTS__ = ${devalue.uneval(layoutMetadata)};
         </script>
       `;
       let clientScript = "";
@@ -637,9 +700,9 @@ exports.RenderService = class _RenderService {
           throw new Error("Server bundle not found in manifest. Run `pnpm build:server` to generate the server bundle.");
         }
       }
-      const { data: pageData, __context: context } = data;
+      const { data: pageData, __context: context, __layouts: layouts } = data;
       const componentName = viewComponent.displayName || viewComponent.name || "Component";
-      const inlineScripts = this.templateParser.buildInlineScripts(pageData, context, componentName);
+      const inlineScripts = this.templateParser.buildInlineScripts(pageData, context, componentName, layouts);
       const clientScript = this.templateParser.getClientScriptTag(this.isDevelopment, this.manifest);
       const stylesheetTags = this.templateParser.getStylesheetTags(this.isDevelopment, this.manifest);
       const headTags = this.templateParser.buildHeadTags(head);
@@ -695,15 +758,20 @@ exports.RenderService = _ts_decorate3([
   _ts_param2(2, common.Inject("SSR_MODE")),
   _ts_param2(3, common.Optional()),
   _ts_param2(3, common.Inject("DEFAULT_HEAD")),
+  _ts_param2(4, common.Optional()),
+  _ts_param2(4, common.Inject("CUSTOM_TEMPLATE")),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof exports.TemplateParserService === "undefined" ? Object : exports.TemplateParserService,
     typeof exports.StreamingErrorHandler === "undefined" ? Object : exports.StreamingErrorHandler,
     typeof SSRMode === "undefined" ? Object : SSRMode,
-    typeof HeadData === "undefined" ? Object : HeadData
+    typeof HeadData === "undefined" ? Object : HeadData,
+    String
   ])
 ], exports.RenderService);
 var RENDER_KEY = "render";
+var RENDER_OPTIONS_KEY = "render_options";
+var LAYOUT_KEY = "layout";
 
 // src/render/render.interceptor.ts
 function _ts_decorate4(decorators, target, key, desc) {
@@ -717,6 +785,12 @@ function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
 function isRenderResponse(data) {
   return data && typeof data === "object" && "props" in data;
 }
@@ -727,9 +801,60 @@ exports.RenderInterceptor = class RenderInterceptor {
   }
   reflector;
   renderService;
-  constructor(reflector, renderService) {
+  allowedHeaders;
+  allowedCookies;
+  constructor(reflector, renderService, allowedHeaders, allowedCookies) {
     this.reflector = reflector;
     this.renderService = renderService;
+    this.allowedHeaders = allowedHeaders;
+    this.allowedCookies = allowedCookies;
+  }
+  /**
+  * Resolve the layout hierarchy for a given route
+  * Hierarchy: Root Layout → Controller Layout → Method Layout → Page
+  *
+  * Props are merged in priority order:
+  * 1. Static props from @Layout decorator (base)
+  * 2. Static props from @Render decorator (override)
+  * 3. Dynamic props from controller return (final override)
+  */
+  async resolveLayoutChain(context, dynamicLayoutProps) {
+    const layouts = [];
+    const rootLayout = await this.renderService.getRootLayout();
+    if (rootLayout) {
+      layouts.push({
+        layout: rootLayout,
+        props: dynamicLayoutProps || {}
+      });
+    }
+    const controllerLayoutMeta = this.reflector.get(LAYOUT_KEY, context.getClass());
+    const renderOptions = this.reflector.get(RENDER_OPTIONS_KEY, context.getHandler());
+    if (renderOptions?.layout === null) {
+      return [];
+    } else if (renderOptions?.layout === false) {
+      return layouts;
+    }
+    if (controllerLayoutMeta) {
+      const mergedProps = {
+        ...controllerLayoutMeta.options?.props || {},
+        ...dynamicLayoutProps || {}
+      };
+      layouts.push({
+        layout: controllerLayoutMeta.layout,
+        props: mergedProps
+      });
+    }
+    if (renderOptions?.layout) {
+      const mergedProps = {
+        ...renderOptions.layoutProps || {},
+        ...dynamicLayoutProps || {}
+      };
+      layouts.push({
+        layout: renderOptions.layout,
+        props: mergedProps
+      });
+    }
+    return layouts;
   }
   intercept(context, next) {
     const viewPathOrComponent = this.reflector.get(RENDER_KEY, context.getHandler());
@@ -745,16 +870,36 @@ exports.RenderInterceptor = class RenderInterceptor {
         path: request.path,
         query: request.query,
         params: request.params,
-        userAgent: request.headers["user-agent"],
-        acceptLanguage: request.headers["accept-language"],
-        referer: request.headers.referer
+        method: request.method
       };
+      if (this.allowedHeaders?.length) {
+        for (const headerName of this.allowedHeaders) {
+          const value = request.headers[headerName.toLowerCase()];
+          if (value) {
+            renderContext[headerName] = Array.isArray(value) ? value.join(", ") : value;
+          }
+        }
+      }
+      if (this.allowedCookies?.length && request.cookies) {
+        const cookies = {};
+        for (const cookieName of this.allowedCookies) {
+          const value = request.cookies[cookieName];
+          if (value !== void 0) {
+            cookies[cookieName] = value;
+          }
+        }
+        if (Object.keys(cookies).length > 0) {
+          renderContext.cookies = cookies;
+        }
+      }
       const renderResponse = isRenderResponse(data) ? data : {
         props: data
       };
+      const layoutChain = await this.resolveLayoutChain(context, renderResponse.layoutProps);
       const fullData = {
         data: renderResponse.props,
-        __context: renderContext
+        __context: renderContext,
+        __layouts: layoutChain
       };
       try {
         const html = await this.renderService.render(viewPathOrComponent, fullData, response, renderResponse.head);
@@ -771,10 +916,16 @@ exports.RenderInterceptor = class RenderInterceptor {
 };
 exports.RenderInterceptor = _ts_decorate4([
   common.Injectable(),
+  _ts_param3(2, common.Optional()),
+  _ts_param3(2, common.Inject("ALLOWED_HEADERS")),
+  _ts_param3(3, common.Optional()),
+  _ts_param3(3, common.Inject("ALLOWED_COOKIES")),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     typeof core.Reflector === "undefined" ? Object : core.Reflector,
-    typeof exports.RenderService === "undefined" ? Object : exports.RenderService
+    typeof exports.RenderService === "undefined" ? Object : exports.RenderService,
+    Array,
+    Array
   ])
 ], exports.RenderInterceptor);
 function _ts_decorate5(decorators, target, key, desc) {
@@ -788,12 +939,12 @@ function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata4, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
+__name(_ts_param4, "_ts_param");
 var ViteInitializerService = class _ViteInitializerService {
   static {
     __name(this, "ViteInitializerService");
@@ -909,8 +1060,8 @@ var ViteInitializerService = class _ViteInitializerService {
 };
 ViteInitializerService = _ts_decorate5([
   common.Injectable(),
-  _ts_param3(2, common.Optional()),
-  _ts_param3(2, common.Inject("VITE_CONFIG")),
+  _ts_param4(2, common.Optional()),
+  _ts_param4(2, common.Inject("VITE_CONFIG")),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     typeof exports.RenderService === "undefined" ? Object : exports.RenderService,
@@ -1003,6 +1154,20 @@ exports.RenderModule = class _RenderModule {
         useValue: config.defaultHead
       });
     }
+    if (config?.template) {
+      providers.push({
+        provide: "CUSTOM_TEMPLATE",
+        useValue: config.template
+      });
+    }
+    providers.push({
+      provide: "ALLOWED_HEADERS",
+      useValue: config?.allowedHeaders || []
+    });
+    providers.push({
+      provide: "ALLOWED_COOKIES",
+      useValue: config?.allowedCookies || []
+    });
     return {
       global: true,
       module: _RenderModule,
@@ -1095,6 +1260,30 @@ exports.RenderModule = class _RenderModule {
         inject: [
           "RENDER_CONFIG"
         ]
+      },
+      // Custom template provider - reads from config
+      {
+        provide: "CUSTOM_TEMPLATE",
+        useFactory: /* @__PURE__ */ __name((config) => config?.template, "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Allowed headers provider - reads from config
+      {
+        provide: "ALLOWED_HEADERS",
+        useFactory: /* @__PURE__ */ __name((config) => config?.allowedHeaders || [], "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
+      },
+      // Allowed cookies provider - reads from config
+      {
+        provide: "ALLOWED_COOKIES",
+        useFactory: /* @__PURE__ */ __name((config) => config?.allowedCookies || [], "useFactory"),
+        inject: [
+          "RENDER_CONFIG"
+        ]
       }
     ];
     return {