dinou 4.0.15 → 5.0.0

package/dinou/core/generate-static-page.js

@@ -1,8 +1,9 @@
 const path = require("path");
-const { mkdirSync, createWriteStream } = require("fs");
+const { mkdirSync, createWriteStream, existsSync } = require("fs");
 const fs = require("fs").promises;
 const renderAppToHtml = require("./render-app-to-html.js");
-const getSSGMetadata = require("./get-ssg-metadata.js");
+const { getStaticMetadata } = require("./build-static-pages.js");
+const { processMetadata } = require("./get-ssg-metadata.js");
 
 const OUT_DIR = path.resolve("dist2");
 
@@ -64,7 +65,11 @@ async function generateStaticPage(reqPath) {
       capturedStatus
     );
 
-    const sideEffectScripts = getSSGMetadata(reqPath);
+    const metadata = getStaticMetadata(finalReqPath);
+    let sideEffectScripts = "";
+    if (metadata && metadata.effects) {
+      sideEffectScripts = processMetadata(metadata.effects);
+    }
 
     await new Promise((resolve, reject) => {
       if (sideEffectScripts) fileStream.write(sideEffectScripts);
@@ -81,6 +86,19 @@ async function generateStaticPage(reqPath) {
       fileStream.on("error", reject);
     });
 
+    if (metadata) {
+      const metadataPath = path.join(OUT_DIR, finalReqPath, "metadata.json");
+      await fs.writeFile(
+        metadataPath,
+        JSON.stringify({
+          revalidate: metadata.revalidate,
+          generatedAt: Date.now(),
+          effects: metadata.effects,
+        }, null, 2),
+        "utf8"
+      );
+    }
+
     const status = capturedStatus.value || 200;
     const success = status !== 500;
 

package/dinou/core/generate-static-pages.js

@@ -1,80 +1,57 @@
 // generate-static-pages.js
 const path = require("path");
 const { mkdirSync, createWriteStream } = require("fs");
+const fs = require("fs").promises;
 const renderAppToHtml = require("./render-app-to-html.js");
-const getSSGMetadata = require("./get-ssg-metadata.js");
+const { getStaticMetadata } = require("./build-static-pages.js");
+const { processMetadata } = require("./get-ssg-metadata.js");
 const { updateStatus } = require("./status-manifest.js");
 
 const OUT_DIR = path.resolve("dist2");
 
 async function generateStaticPages(routes) {
   for (const route of routes) {
-    // Normalization of the route
     const reqPath = route.endsWith("/") ? route : route + "/";
     const htmlPath = path.join(OUT_DIR, reqPath, "index.html");
 
-    // Prepare Query params (empty by default in SSG, unless your router supports it)
     const query = {};
     const paramsString = JSON.stringify(query);
     const capturedStatus = {};
-    // ---------------------------------------------------------
-    // 1. CREATE MOCK REQUEST (Solution to your second question)
-    // ---------------------------------------------------------
     const contextForChild = {
       req: {
         query,
-        cookies: {}, // No cookies at build time
+        cookies: {},
         headers: {
           "user-agent": "Dinou-SSG-Builder",
-          host: "localhost", // Safe default value
+          host: "localhost",
           "x-forwarded-proto": "http",
         },
-        path: reqPath, // 💡 Vital for active menu logic, etc.
+        path: reqPath,
         method: "GET",
       },
-      // We do not pass 'res' here, the child ignores it, we pass the mockRes as an argument
     };
 
     try {
       mkdirSync(path.dirname(htmlPath), { recursive: true });
       const fileStream = createWriteStream(htmlPath);
-      let htmlStream = null; // Declare outside to use in the closure
+      let htmlStream = null;
 
-      // ---------------------------------------------------------
-      // 2. CREATE MOCK RESPONSE (With Fix for Webpack)
-      // ---------------------------------------------------------
       const mockRes = {
-        headersSent: true, // Force "streaming/script injection" mode
-        _cookies: [], // Optional: for debug
-
-        // 👇 ADD THIS METHOD
+        headersSent: true,
+        _cookies: [],
         cookie(name, value, options) {
-          // In SSG we don't do anything real, but we save a record if you want to debug
-          // console.log(`[SSG] Cookie set ignored: ${name}=${value}`);
           this._cookies.push({ name, value, options });
         },
-
         write: (chunk) => {
           if (!fileStream.writableEnded) fileStream.write(chunk);
         },
-
         end: (chunk) => {
-          // If they send us a last chunk (e.g., </script>)
           if (chunk && !fileStream.writableEnded) fileStream.write(chunk);
-
-          // 🔥 WEBPACK "WRITE AFTER END" FIX:
-          // Disconnect the child's stream immediately.
-          // If Webpack sends garbage afterwards, it won't reach the fileStream.
           if (htmlStream) {
             htmlStream.unpipe(fileStream);
-            // Optional: Pause or destroy the child's stream to free memory
-            // htmlStream.destroy();
           }
-
-          // Officially close the file
           if (!fileStream.writableEnded) fileStream.end();
         },
-
         status: (code) => {
           if (code !== 200)
             console.warn(`[SSG] Status ${code} ignored for ${reqPath}`);
@@ -85,25 +62,26 @@ async function generateStaticPages(routes) {
         redirect: () => {},
       };
 
-      // 3. Execute Render
       htmlStream = renderAppToHtml(
         reqPath,
         paramsString,
-        contextForChild, // ✅ Pass the MockReq
+        contextForChild,
         mockRes,
         capturedStatus
       );
 
-      const sideEffectScripts = getSSGMetadata(reqPath);
+      const metadata = getStaticMetadata(reqPath);
+      let sideEffectScripts = "";
+      if (metadata && metadata.effects) {
+        sideEffectScripts = processMetadata(metadata.effects);
+      }
+
       await new Promise((resolve, reject) => {
-        // 🟢 SCRIPT INJECTION
         if (sideEffectScripts) {
           fileStream.write(sideEffectScripts);
         }
-        // Connect standard output to the file
-        htmlStream.pipe(fileStream, { end: false }); // end: false gives us manual control in the mockRes
+        htmlStream.pipe(fileStream, { end: false });
 
-        // Event handling
         htmlStream.on("end", () => {
           if (!fileStream.writableEnded) fileStream.end();
           updateStatus(reqPath, capturedStatus.value);
@@ -111,7 +89,6 @@ async function generateStaticPages(routes) {
         });
 
         htmlStream.on("error", (err) => {
-          // If the error is "write after end" and we already closed, ignore it (it's noise)
           if (err.code === "ERR_STREAM_WRITE_AFTER_END") {
             resolve();
           } else {
@@ -122,9 +99,21 @@ async function generateStaticPages(routes) {
         fileStream.on("error", reject);
       });
 
+      if (metadata) {
+        const metadataPath = path.join(OUT_DIR, reqPath, "metadata.json");
+        await fs.writeFile(
+          metadataPath,
+          JSON.stringify({
+            revalidate: metadata.revalidate,
+            generatedAt: Date.now(),
+            effects: metadata.effects,
+          }, null, 2),
+          "utf8"
+        );
+      }
+
       console.log("✅ Generated HTML:", reqPath);
     } catch (error) {
-      // Extra safety filter in case the error bubbles up here
       if (error.code === "ERR_STREAM_WRITE_AFTER_END") {
         console.log("⚠️ Ignored write-after-end race condition for:", reqPath);
       } else {

package/dinou/core/generate-static-rsc.js

@@ -1,12 +1,16 @@
 const fs = require("fs");
 const path = require("path");
 const { PassThrough } = require("stream");
-const getSSGJSXOrJSX = require("./get-ssg-jsx-or-jsx.js");
-const { renderToPipeableStream } = require("react-server-dom-webpack/server");
+const url = require("url");
+const getJSX = require("./get-jsx.js");
+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 { requestStorage } = require("./request-context.js");
 
 const OUT_DIR = path.resolve("dist2");
-const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+// const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
 async function generateStaticRSC(reqPath) {
   const finalReqPath = reqPath.endsWith("/") ? reqPath : reqPath + "/";
@@ -94,8 +98,10 @@ async function generateStaticRSC(reqPath) {
     const passThrough = new PassThrough();
 
     await requestStorage.run(mockContext, async () => {
-      const jsx = await getSSGJSXOrJSX(finalReqPath, {});
-      const { pipe } = renderToPipeableStream(jsx, manifest);
+      const jsx = await getJSX(finalReqPath, {}, null, false);
+      const { pipe } = isWebpack
+        ? renderToPipeableStream(jsx, manifest)
+        : renderToPipeableStream(jsx, url.pathToFileURL(process.cwd()).href + "/");
       pipe(passThrough);
       passThrough.pipe(fileStream);
 

package/dinou/core/generate-static-rscs.js

@@ -1,14 +1,18 @@
 const fs = require("fs");
 const path = require("path");
 const { PassThrough } = require("stream");
-const getSSGJSXOrJSX = require("./get-ssg-jsx-or-jsx.js");
-const { renderToPipeableStream } = require("react-server-dom-webpack/server");
+const url = require("url");
+const getJSX = require("./get-jsx.js");
+const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+const { renderToPipeableStream } = isWebpack
+  ? require("react-server-dom-webpack/server")
+  : require("@roggc/react-server-dom-esm/server");
 
 // 👇 Your context storage
 const { requestStorage } = require("./request-context.js");
 
 const OUT_DIR = path.resolve("dist2");
-const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
+// const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
 async function generateStaticRSCs(routes) {
   const manifest = JSON.parse(
@@ -110,8 +114,10 @@ async function generateStaticRSCs(routes) {
 
       // 1. The entire lifecycle of the stream must be inside the storage
       await requestStorage.run(mockContext, async () => {
-        const jsx = await getSSGJSXOrJSX(reqPath, {});
-        const { pipe } = renderToPipeableStream(jsx, manifest);
+        const jsx = await getJSX(reqPath, {}, null, false);
+        const { pipe } = isWebpack
+          ? renderToPipeableStream(jsx, manifest)
+          : renderToPipeableStream(jsx, url.pathToFileURL(process.cwd()).href + "/");
 
         pipe(passThrough);
         passThrough.pipe(fileStream);

package/dinou/core/generate-static.js

@@ -2,8 +2,7 @@ const path = require("path");
 const { existsSync, rmSync } = require("fs");
 const generateStaticRSCs = require("./generate-static-rscs");
 const generateStaticPages = require("./generate-static-pages");
-const { getStaticPaths } = require("./jsx-json");
-const { buildStaticPages } = require("./build-static-pages");
+const { buildStaticPages, getStaticPaths } = require("./build-static-pages");
 
 async function generateStatic() {
   const distFolder2 = path.resolve(process.cwd(), "dist2");
@@ -16,8 +15,8 @@ async function generateStatic() {
   await buildStaticPages();
   const routes = getStaticPaths();
   console.log("Static paths:", routes);
-  await generateStaticPages(routes);
   await generateStaticRSCs(routes);
+  await generateStaticPages(routes);
 }
 
 module.exports = generateStatic;

package/dinou/core/get-jsx.js

@@ -12,6 +12,7 @@ async function getJSX(
   query,
   isNotFound = null,
   isDevelopment = false,
+  forceNotFound = false,
 ) {
   const srcFolder = path.resolve(process.cwd(), "src");
   const reqSegments = reqPath.split("/").filter(Boolean);
@@ -52,7 +53,7 @@ async function getJSX(
   let jsx;
   let pageFunctionsProps;
 
-  if (!pagePath) {
+  if (!pagePath || forceNotFound) {
     if (isNotFound) isNotFound.value = true;
     const [notFoundPath, dParams] = getFilePathAndDynamicParams(
       reqSegments,

package/dinou/core/get-ssg-metadata.js

@@ -1,9 +1,6 @@
-const { getJSXJSON, hasJSXJSON } = require("./jsx-json");
+function processMetadata(effects) {
+  if (!effects) return "";
 
-function processMetadata(metadata) {
-  if (!metadata || !metadata.effects) return "";
-
-  const { effects } = metadata;
   let scriptContent = "";
 
   if (effects.cookies && effects.cookies.length > 0) {
@@ -29,11 +26,6 @@ function processMetadata(metadata) {
   return `<script>(function(){ ${scriptContent} })();</script>`;
 }
 
-function getSSGMetadata(reqPath) {
-  if (!hasJSXJSON(reqPath)) return;
-  const { metadata } = getJSXJSON(reqPath);
-  const script = processMetadata(metadata);
-  return script;
-}
-
-module.exports = getSSGMetadata;
+module.exports = {
+  processMetadata,
+};

package/dinou/core/import-module.js

@@ -1,19 +1,38 @@
 const { pathToFileURL } = require("url");
 const path = require("path");
+const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 
 async function importModule(modulePath) {
+  const absPath = path.isAbsolute(modulePath)
+    ? modulePath
+    : path.resolve(process.cwd(), modulePath);
+
+  if (!isWebpack) {
+    let fileUrl = pathToFileURL(absPath).href;
+    if (process.env.NODE_ENV !== "production") {
+      fileUrl += `?t=${Date.now()}`;
+    }
+    const mod = await import(fileUrl);
+    return mod;
+  }
+
   try {
-    return require(modulePath);
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        const resolved = require.resolve(absPath);
+        delete require.cache[resolved];
+      } catch (e) {}
+    }
+    return require(absPath);
   } catch (err) {
     if (
       err.code === "ERR_REQUIRE_ESM" ||
       /require\(\) of ES Module/.test(err.message)
     ) {
-      const absPath = path.isAbsolute(modulePath)
-        ? modulePath
-        : path.resolve(process.cwd(), modulePath);
-
-      const fileUrl = pathToFileURL(absPath).href;
+      let fileUrl = pathToFileURL(absPath).href;
+      if (process.env.NODE_ENV !== "production") {
+        fileUrl += `?t=${Date.now()}`;
+      }
       const mod = await import(fileUrl);
       return mod;
     }

package/dinou/core/redirect.jsx

@@ -8,18 +8,25 @@ export function redirect(destination) {
   // 1. We try to get the server context
   if (typeof window === "undefined") {
     // getContext() must be accessible here
-    const dynamicRequire = require;
-    const { getContext } = dynamicRequire(
-      /* webpackIgnore: true */ "./request-context.js"
-    );
-    const ctx = getContext();
+    const dynamicRequire =
+      typeof __dinou_require__ !== "undefined"
+        ? __dinou_require__
+        : typeof module !== "undefined" && typeof module.require === "function"
+          ? module.require.bind(module)
+          : null;
+    if (dynamicRequire) {
+      const { getContext } = dynamicRequire(
+        /* webpackIgnore: true */ "./request-context.js"
+      );
+      const ctx = getContext();
 
-    // 2. If we are on the server and headers have NOT been sent yet...
-    // We can do a real HTTP redirect (Status 307).
-    // This is better for SEO and speed in Hard Navigation.
-    if (ctx && ctx.res) {
-      ctx.res.redirect(destination);
-      return <ClientRedirect to={destination} />;
+      // 2. If we are on the server and headers have NOT been sent yet...
+      // We can do a real HTTP redirect (Status 307).
+      // This is better for SEO and speed in Hard Navigation.
+      if (ctx && ctx.res) {
+        ctx.res.redirect(destination);
+        return <ClientRedirect to={destination} />;
+      }
     }
   }
 

package/dinou/core/register-loader.mjs

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 
 const require = createRequire(import.meta.url);
+globalThis.__dinou_require__ = require;
 
 const loaderPath = require.resolve("./babel-esm-loader.js");