dinou 4.0.16 → 5.0.1

package/dinou/core/render-app-to-html.js

@@ -1,10 +1,45 @@
 const path = require("path");
-const { fork } = require("child_process"); // ⬅️ CHANGE 1: We use fork
+const { fork } = require("child_process");
 const url = require("url");
-const { getJSXJSON, hasJSXJSON } = require("./jsx-json");
+const fs = require("fs");
+const getJSX = require("./get-jsx.js");
+const { requestStorage } = require("./request-context.js");
+
+const isDevelopment = process.env.NODE_ENV !== "production";
+const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+
+const { renderToPipeableStream } = isWebpack
+  ? require("react-server-dom-webpack/server")
+  : require("@roggc/react-server-dom-esm/server");
+
+const manifestPath = path.resolve(
+  process.cwd(),
+  isWebpack
+    ? (isDevelopment ? "public/react-client-manifest.json" : "dist3/react-client-manifest.json")
+    : "react_client_manifest/react-client-manifest.json"
+);
+
+let cachedManifest = null;
+function getManifest() {
+  if (!isDevelopment && cachedManifest) return cachedManifest;
+  try {
+    const content = fs.readFileSync(manifestPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed && Object.keys(parsed).length > 0) {
+      cachedManifest = parsed;
+    }
+    return cachedManifest || parsed;
+  } catch (e) {
+    if (cachedManifest) {
+      console.warn("Using cached client manifest due to read error:", e.message);
+      return cachedManifest;
+    }
+    console.error("Error reading client manifest:", e);
+    return {};
+  }
+}
 
 function toFileUrl(p) {
-  // Converts to file://, cross-platform
   return url.pathToFileURL(p).href;
 }
 
@@ -13,22 +48,123 @@ const registerLoaderPath = toFileUrl(
 );
 const renderHtmlPath = path.resolve(__dirname, "render-html.js");
 
-// ----------------------------------------------------
-// 💡 WHITELIST STRATEGY
-// ----------------------------------------------------
-
-// 1. Define ESSENTIAL Node.js flags that the child must have.
-//    (We leave the list empty to avoid inheriting problematic flags)
 const ESSENTIAL_NODE_ARGS = [];
-
-// 2. Add the loader --import, which is the only confirmed necessity.
 const loaderArg = `--import=${registerLoaderPath}`;
 const childExecArgv = ESSENTIAL_NODE_ARGS.concat(loaderArg);
 
-// ----------------------------------------------------
-
 const { resolveRelativeUrl } = require("./url-resolver");
 
+function createParentResponseWrapper(reqPath, res, child) {
+  let hasRedirected = false;
+
+  const safeRedirect = (targetUrl) => {
+    if (hasRedirected) return;
+    hasRedirected = true;
+
+    const resolvedUrl = resolveRelativeUrl(targetUrl, reqPath);
+    let finalUrl = "/";
+    if (
+      typeof resolvedUrl === "string" &&
+      resolvedUrl.startsWith("/") &&
+      !resolvedUrl.startsWith("//")
+    ) {
+      finalUrl = resolvedUrl;
+    } else {
+      console.warn(
+        `[Dinou Security] Blocked unsafe redirect to: ${targetUrl}`,
+      );
+    }
+
+    if (res.headersSent) {
+      console.log(
+        `[Dinou] Streaming active. Redirecting via JavaScript to: ${finalUrl}`,
+      );
+      const safeUrl = JSON.stringify(finalUrl);
+      res.write(`<script>window.location.href = ${safeUrl};</script>`);
+      res.end();
+      child.stdout.unpipe(res);
+      child.kill();
+    } else {
+      res.redirect(302, finalUrl);
+      child.stdout.unpipe(res);
+      child.kill();
+    }
+  };
+
+  return {
+    setHeader: (name, value) => {
+      if (res.headersSent) {
+        console.warn(
+          `[Dinou Warning] Cannot set header '${name}' because streaming started.`,
+        );
+      } else {
+        res.setHeader(name, value);
+      }
+    },
+    cookie: (name, value, options) => {
+      if (res.headersSent) {
+        if (options && options.httpOnly) {
+          console.error(
+            `[Dinou Error] Cannot set HttpOnly cookie '${name}' because streaming has already started.`,
+          );
+          return;
+        }
+        console.log(
+          `[Dinou] Streaming active. Setting cookie '${name}' via JS.`,
+        );
+        let cookieStr = `${name}=${encodeURIComponent(value)}`;
+        if (options) {
+          if (options.path) cookieStr += `; path=${options.path}`;
+          if (options.domain) cookieStr += `; domain=${options.domain}`;
+          if (options.maxAge) cookieStr += `; max-age=${options.maxAge}`;
+          if (options.expires)
+            cookieStr += `; expires=${new Date(options.expires).toUTCString()}`;
+          if (options.secure) cookieStr += `; secure`;
+          if (options.sameSite)
+            cookieStr += `; samesite=${options.sameSite}`;
+        }
+        const safeCookieStr = JSON.stringify(cookieStr);
+        res.write(`<script>document.cookie = ${safeCookieStr};</script>`);
+      } else {
+        res.cookie(name, value, options);
+      }
+    },
+    clearCookie: (name, options) => {
+      if (res.headersSent) {
+        console.log(
+          `[Dinou] Streaming active. Clearing cookie '${name}' via JS.`,
+        );
+        let cookieStr = `${name}=; Max-Age=0`;
+        const path = options?.path || "/";
+        cookieStr += `; path=${path}`;
+        if (options) {
+          if (options.domain) cookieStr += `; domain=${options.domain}`;
+          if (options.secure) cookieStr += `; secure`;
+          if (options.sameSite) cookieStr += `; samesite=${options.sameSite}`;
+        }
+        cookieStr += ";";
+        const safeCookieStr = JSON.stringify(cookieStr);
+        res.write(`<script>document.cookie = ${safeCookieStr};</script>`);
+      } else {
+        res.clearCookie(name, options);
+      }
+    },
+    redirect: (arg1, arg2) => {
+      const url = arg2 || arg1;
+      safeRedirect(url);
+    },
+    status: (code) => {
+      if (res.headersSent) {
+        console.warn(
+          `[Dinou Warning] HTTP status '${code}' ignored because streaming started.`,
+        );
+      } else {
+        res.status(code);
+      }
+    },
+  };
+}
+
 function renderAppToHtml(
   reqPath,
   paramsString,
@@ -36,31 +172,62 @@ function renderAppToHtml(
   res,
   capturedStatus = null,
   isDynamic = false,
+  forceNotFound = false,
 ) {
-  const jsxJson = getJSXJSON(reqPath);
-  const hasJsxJson = hasJSXJSON(reqPath);
-  // We replicate the array of positional arguments passed to the script
-  // [renderHtmlPath, reqPath, paramsString, cookiesString]
-  const scriptArgs = [
-    reqPath,
-    paramsString,
-    contextForChild ? JSON.stringify(contextForChild) : JSON.stringify({}),
-    isDynamic ? "true" : "false",
-    hasJsxJson ? "true" : "false",
-    JSON.stringify(hasJsxJson ? jsxJson : {}),
-  ];
-
   const child = fork(
-    renderHtmlPath, // ⬅️ CHANGE 2: The script (path) is the first argument of fork (no need for "node")
-    scriptArgs, // Positional arguments for the script (process.argv)
+    renderHtmlPath,
+    [
+      reqPath,
+      paramsString,
+      contextForChild ? JSON.stringify(contextForChild) : JSON.stringify({}),
+      isDynamic ? "true" : "false",
+    ],
     {
-      // ⬅️ CHANGE 3: Apply Whitelist to execArgv, resetting inherited options
       execArgv: childExecArgv,
-      // ⬅️ CHANGE 4: stdio needs 'ipc' for fork to work and for the future communication channel
-      stdio: ["ignore", "pipe", "pipe", "ipc"], // stdin, stdout, stderr, ipc
+      stdio: ["ignore", "pipe", "pipe", "ipc", "pipe"], // fd 4 is the RSC stream pipe
     },
   );
 
+  const query = JSON.parse(paramsString || "{}");
+  const rscPath = path.resolve(process.cwd(), "dist2", reqPath.replace(/^\//, ""), "rsc.rsc");
+  const hasStaticRsc = !isDynamic && fs.existsSync(rscPath);
+
+  if (hasStaticRsc) {
+    try {
+      const rscBuffer = fs.readFileSync(rscPath);
+      child.stdio[4].write(rscBuffer);
+      child.stdio[4].end();
+    } catch (err) {
+      console.error(`[Dinou] Failed to read static RSC from ${rscPath}:`, err.message);
+      if (child.stdio[4]) child.stdio[4].destroy();
+    }
+  } else {
+    // Dynamic SSR render: render RSC in parent and pipe to fd 4
+    const isNotFound = {};
+    const parentRes = createParentResponseWrapper(reqPath, res, child);
+    const context = {
+      req: contextForChild ? contextForChild.req : {},
+      res: parentRes,
+    };
+    requestStorage.run(context, () => {
+      getJSX(reqPath, query, isNotFound, isDevelopment, forceNotFound)
+        .then((jsx) => {
+          if (isNotFound.value) {
+            parentRes.status(404);
+          }
+          const manifest = getManifest();
+          const { pipe } = isWebpack
+            ? renderToPipeableStream(jsx, manifest)
+            : renderToPipeableStream(jsx, url.pathToFileURL(process.cwd()).href + "/");
+          pipe(child.stdio[4]);
+        })
+        .catch((err) => {
+          console.error("Error rendering JSX in parent renderAppToHtml:", err);
+          if (child.stdio[4]) child.stdio[4].destroy();
+        });
+    });
+  }
+
   // 💡 on('message') Implementation (IPC Channel)
   // ----------------------------------------------------
   child.on("message", (message) => {

package/dinou/core/render-html.js

@@ -1,6 +1,18 @@
+const path = require("path");
+global.__webpack_require__ = function (id) {
+  if (global.__webpack_require_map__ && global.__webpack_require_map__[id]) {
+    return require(global.__webpack_require_map__[id]);
+  }
+  if (typeof id === "string" && id.startsWith("./")) {
+    id = path.resolve(process.cwd(), id);
+  }
+  return require(id);
+};
+global.__webpack_chunk_load__ = function (chunkId) {
+  return Promise.resolve();
+};
+
 require("./register-paths");
-require("./register-hooks.js");
-const babelPluginRegisterImports = require("./babel-plugin-register-imports.js");
 const babelRegister = require("@babel/register");
 babelRegister({
   ignore: [/node_modules[\\/](?!dinou)/],
@@ -8,7 +20,7 @@ babelRegister({
     ["@babel/preset-react", { runtime: "automatic" }],
     "@babel/preset-typescript",
   ],
-  plugins: [babelPluginRegisterImports, "@babel/transform-modules-commonjs"],
+  plugins: ["@babel/transform-modules-commonjs"],
   extensions: [".js", ".jsx", ".ts", ".tsx"],
 });
 const addHook = require("./asset-require-hook.js");
@@ -26,9 +38,7 @@ addHook({
 const getAssetFromManifest = require("./get-asset-from-manifest.js");
 const { renderToPipeableStream } = require("react-dom/server");
 const getJSX = require("./get-jsx");
-const getSSGJSX = require("./get-ssg-jsx.js");
 const { getErrorJSX } = require("./get-error-jsx");
-const { renderJSXToClientJSX } = require("./render-jsx-to-client-jsx");
 const isDevelopment = process.env.NODE_ENV !== "production";
 const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 const { requestStorage } = require("./request-context.js");
@@ -124,13 +134,121 @@ function writeErrorOutput(error, isProd) {
   );
 }
 
+function getImportMapHtml() {
+  const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+  if (isWebpack) return "";
+
+  const fs = require("fs");
+  const path = require("path");
+  const { pathToFileURL } = require("url");
+
+  const manifestPath = path.resolve(
+    process.cwd(),
+    "react_client_manifest/react-client-manifest.json"
+  );
+
+  if (!fs.existsSync(manifestPath)) {
+    return "";
+  }
+
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const imports = {};
+    const moduleBasePath = pathToFileURL(process.cwd()).href + "/";
+
+    for (const [key, val] of Object.entries(manifest)) {
+      let specifier = key;
+      if (specifier.startsWith(moduleBasePath)) {
+        specifier = specifier.slice(moduleBasePath.length);
+      }
+      const hashIdx = specifier.indexOf("#");
+      if (hashIdx !== -1) {
+        specifier = specifier.slice(0, hashIdx);
+      }
+      imports[specifier] = val.id;
+    }
+
+    return `<script type="importmap">{"imports":${JSON.stringify(imports)}}</script><script>(function(){const map=document.querySelector('script[type="importmap"]');if(map)map.remove();if(document.currentScript)document.currentScript.remove();})();</script>`;
+  } catch (err) {
+    console.error("Error generating importmap:", err);
+    return "";
+  }
+}
+
+let cachedSsrManifest = null;
+let cachedRequireMap = null;
+function getSsrManifest() {
+  if (!isDevelopment && cachedSsrManifest) return cachedSsrManifest;
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const ssrManifestPath = path.resolve(
+      process.cwd(),
+      isDevelopment ? "public/react-ssr-manifest.json" : "dist3/react-ssr-manifest.json"
+    );
+    const clientManifestPath = path.resolve(
+      process.cwd(),
+      isDevelopment ? "public/react-client-manifest.json" : "dist3/react-client-manifest.json"
+    );
+
+    const ssrContent = fs.readFileSync(ssrManifestPath, "utf8");
+    const ssrManifest = JSON.parse(ssrContent);
+
+    if (fs.existsSync(clientManifestPath)) {
+      const clientContent = fs.readFileSync(clientManifestPath, "utf8");
+      const clientManifest = JSON.parse(clientContent);
+
+      const { fileURLToPath } = require("url");
+      const requireMap = {};
+      for (const [fileUrl, entry] of Object.entries(clientManifest)) {
+        if (entry && entry.id !== undefined) {
+          try {
+            requireMap[entry.id] = fileURLToPath(fileUrl);
+          } catch {}
+        }
+      }
+      global.__webpack_require_map__ = requireMap;
+      cachedRequireMap = requireMap;
+
+      if (ssrManifest.moduleMap) {
+        for (const [modId, exports] of Object.entries(ssrManifest.moduleMap)) {
+          for (const [expName, expData] of Object.entries(exports)) {
+            if (expData && expData.specifier) {
+              const clientEntry = clientManifest[expData.specifier];
+              if (clientEntry) {
+                expData.id = clientEntry.id;
+                expData.chunks = clientEntry.chunks;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    cachedSsrManifest = ssrManifest;
+    return cachedSsrManifest;
+  } catch (e) {
+    if (cachedSsrManifest) {
+      console.warn("Using cached SSR manifest due to read error:", e.message);
+      if (cachedRequireMap) {
+        global.__webpack_require_map__ = cachedRequireMap;
+      }
+      return cachedSsrManifest;
+    }
+    console.error("Error reading SSR manifest:", e);
+    return {};
+  }
+}
+
+const { createFromNodeStream } = isWebpack
+  ? require("react-server-dom-webpack/client")
+  : require("@roggc/react-server-dom-esm/client");
+
 async function renderToStream(
   reqPath,
   query,
   serializedBox,
   isDynamic,
-  hasJsxJson,
-  jsxJson,
 ) {
   const context = {
     req: serializedBox.req,
@@ -138,21 +256,15 @@ async function renderToStream(
   };
   await requestStorage.run(context, async () => {
     try {
-      const isNotFound = {};
-      const jsx =
-        isDevelopment ||
-          isDynamic ||
-          !hasJsxJson
-          ? renderJSXToClientJSX(
-            await getJSX(reqPath, query, isNotFound, isDevelopment),
-          )
-          : ((await getSSGJSX(jsxJson)) ??
-            renderJSXToClientJSX(
-              await getJSX(reqPath, query, isNotFound, isDevelopment),
-            ));
-      if (isNotFound.value) {
-        context.res.status(404);
-      }
+      const { createReadStream } = require("fs");
+      const rscStream = createReadStream(null, { fd: 4 });
+      const { pathToFileURL } = require("url");
+      const baseUrl = pathToFileURL(process.cwd()).href + "/";
+
+      const jsx = isWebpack
+        ? await createFromNodeStream(rscStream, getSsrManifest())
+        : await createFromNodeStream(rscStream, baseUrl, baseUrl);
+
       const stream = renderToPipeableStream(jsx, {
         onError(error) {
           process.nextTick(async () => {
@@ -181,6 +293,11 @@ async function renderToStream(
 
               const errorStream = renderToPipeableStream(errorJSX, {
                 onShellReady() {
+                  const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+          if (!isWebpack) {
+            const importMapHtml = getImportMapHtml();
+            process.stdout.write(importMapHtml);
+          }
                   errorStream.pipe(process.stdout);
                 },
                 onError(err) {
@@ -216,6 +333,11 @@ async function renderToStream(
           });
         },
         onShellReady() {
+          const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+          if (!isWebpack) {
+            const importMapHtml = getImportMapHtml();
+            process.stdout.write(importMapHtml);
+          }
           stream.pipe(process.stdout);
         },
         bootstrapModules: isDevelopment
@@ -250,8 +372,6 @@ const reqPath = process.argv[2] || "/";
 const query = JSON.parse(process.argv[3] || "{}");
 const serializedBox = JSON.parse(process.argv[4] || "{}");
 const isDynamic = process.argv[5] === "true";
-const hasJsxJson = process.argv[6] === "true";
-const jsxJson = JSON.parse(process.argv[7] || "{}");
 
 process.on("uncaughtException", (error) => {
   process.stdout.write(formatErrorHtml(error));
@@ -281,8 +401,6 @@ renderToStream(
   query,
   serializedBox,
   isDynamic,
-  hasJsxJson,
-  jsxJson,
 ).catch((err) => {
   console.error("❌ Fatal error starting render stream:", err);
   process.exit(1);

package/dinou/core/render-jsx-to-client-jsx.js

@@ -1,14 +1,13 @@
 // Function to check if a component is a client component
 function isClientComponent(type) {
-  if (typeof type !== "function") {
+  if (!type) {
     return false;
   }
-  const isAsync =
-    type instanceof Object.getPrototypeOf(async function () {}).constructor;
-  if (isAsync) {
-    return false;
-  }
-  return true;
+  const CLIENT_REFERENCE = Symbol.for("react.client.reference");
+  return (
+    (typeof type === "function" && type.$$typeof === CLIENT_REFERENCE) ||
+    (typeof type === "object" && type.$$typeof === CLIENT_REFERENCE)
+  );
 }
 
 function renderJSXToClientJSX(jsx, key = null) {

package/dinou/core/request-context.js

@@ -4,15 +4,20 @@ const DINOU_CONTEXT_KEY = Symbol.for("dinou.request.context.storage");
 let requestStorage;
 
 if (typeof window === "undefined") {
-  const nodeRequire = eval("require");
+  const nodeRequire =
+    typeof module !== "undefined" && typeof module.require === "function"
+      ? module.require.bind(module)
+      : null;
 
-  const { AsyncLocalStorage } = nodeRequire("node:async_hooks");
+  if (nodeRequire) {
+    const { AsyncLocalStorage } = nodeRequire("node:async_hooks");
 
-  if (!global[DINOU_CONTEXT_KEY]) {
-    global[DINOU_CONTEXT_KEY] = new AsyncLocalStorage();
-  }
+    if (!global[DINOU_CONTEXT_KEY]) {
+      global[DINOU_CONTEXT_KEY] = new AsyncLocalStorage();
+    }
 
-  requestStorage = global[DINOU_CONTEXT_KEY];
+    requestStorage = global[DINOU_CONTEXT_KEY];
+  }
 } else {
   requestStorage = {
     run: (store, callback) => callback(),

package/dinou/core/revalidating.js

@@ -6,41 +6,44 @@ const { buildStaticPage } = require("./build-static-pages");
 const generateStaticRSC = require("./generate-static-rsc");
 const { safeRename } = require("./safe-rename");
 const { updateStatus } = require("./status-manifest");
-const { getJSXJSON } = require("./jsx-json");
 
 const regenerating = new Set();
 
 function revalidating(reqPath, isDynamicFromServer) {
   const dist2Folder = path.resolve(process.cwd(), "dist2");
-  const jsxJSON = getJSXJSON(reqPath);
-  if (!jsxJSON) return;
+  const metadataPath = path.join(dist2Folder, reqPath, "metadata.json");
 
-  const { revalidate, generatedAt } = jsxJSON;
+  if (regenerating.has(reqPath)) return;
 
-  const isExpired =
-    typeof revalidate === "number" &&
-    revalidate > 0 &&
-    Date.now() > generatedAt + revalidate;
+  fs.readFile(metadataPath, "utf8")
+    .then((content) => {
+      const metadata = JSON.parse(content);
+      const { revalidate, generatedAt } = metadata;
 
-  if (isExpired && !regenerating.has(reqPath)) {
-    try {
-      if (existsSync(path.join(dist2Folder, reqPath, "index.html")))
-        copyFileSync(
-          path.join(dist2Folder, reqPath, "index.html"),
-          path.join(dist2Folder, reqPath, "index._old.html")
-        );
-      if (existsSync(path.join(dist2Folder, reqPath, "rsc.rsc")))
-        copyFileSync(
-          path.join(dist2Folder, reqPath, "rsc.rsc"),
-          path.join(dist2Folder, reqPath, "rsc._old.rsc")
-        );
-    } catch (e) {}
+      const isExpired =
+        typeof revalidate === "number" &&
+        revalidate > 0 &&
+        Date.now() > generatedAt + revalidate;
 
-    regenerating.add(reqPath);
+      if (isExpired && !regenerating.has(reqPath)) {
+        try {
+          if (existsSync(path.join(dist2Folder, reqPath, "index.html")))
+            copyFileSync(
+              path.join(dist2Folder, reqPath, "index.html"),
+              path.join(dist2Folder, reqPath, "index._old.html")
+            );
+          if (existsSync(path.join(dist2Folder, reqPath, "rsc.rsc")))
+            copyFileSync(
+              path.join(dist2Folder, reqPath, "rsc.rsc"),
+              path.join(dist2Folder, reqPath, "rsc._old.rsc")
+            );
+        } catch (e) {}
 
-    (async () => {
-      try {
-        console.log(`[ISR] Starting regeneration for ${reqPath}...`);
+        regenerating.add(reqPath);
+
+        (async () => {
+          try {
+            console.log(`[ISR] Starting regeneration for ${reqPath}...`);
         const isDynamic = {};
         await buildStaticPage(reqPath, isDynamic);
         if (isDynamic.value) {
@@ -80,6 +83,7 @@ function revalidating(reqPath, isDynamicFromServer) {
       }
     })();
   }
+  }).catch((err) => {});
 }
 
 module.exports = { revalidating, regenerating };