dinou 5.0.1 → 5.0.3

package/dinou/core/server.js

@@ -5,6 +5,8 @@ const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
 globalThis.__dinou_require__ = require;
 const path = require("path");
 
+const { normalizePathCase } = require("./path-utils.js");
+
 let reactServerPath, reactDomServerPath, reactJsxRuntimePath, reactJsxDevRuntimePath;
 
 if (!isWebpack) {
@@ -124,11 +126,10 @@ if (isDevelopment) {
       while (attempts < maxRetries) {
         try {
           // console.log(`Attempting to load manifest (try ${attempts + 1})...`);
-          return JSON.parse(readFileSync(manifestPath, "utf8"));
+          const text = readFileSync(manifestPath, "utf8");
+          if (!text.trim()) throw new Error("Empty JSON");
+          return JSON.parse(text);
         } catch (err) {
-          if (err.code !== "ENOENT") {
-            throw err; // Rethrow if it's not a file not found error
-          }
           attempts++;
           if (attempts >= maxRetries) {
             throw err; // Rethrow after max retries
@@ -621,11 +622,28 @@ async function serveRSCPayload(req, res, isOld = false, isStatic = false) {
     //   reqPath
     // );
     if ((!isDevelopment && !dynamicState.value) || isStatic) {
+      let currentGeneratedAt = null;
+      try {
+        const metadataPath = path.join("dist2", reqPath, "metadata.json");
+        if (existsSync(metadataPath)) {
+          const metaObj = JSON.parse(readFileSync(metadataPath, "utf8"));
+          currentGeneratedAt = metaObj.generatedAt || null;
+        }
+      } catch (e) { }
+
+      const useOld =
+        isOld ||
+        regenerating.has(reqPath) ||
+        (req.query.buildId &&
+          currentGeneratedAt &&
+          req.query.buildId !== String(currentGeneratedAt));
+
       const payloadPath = path.resolve(
         "dist2",
         reqPath.replace(/^\//, ""),
-        isOld || regenerating.has(reqPath) ? "rsc._old.rsc" : "rsc.rsc",
+        useOld ? "rsc._old.rsc" : "rsc.rsc",
       );
+
       const distDir = path.resolve("dist2");
 
       if (!payloadPath.startsWith(distDir)) {
@@ -633,6 +651,7 @@ async function serveRSCPayload(req, res, isOld = false, isStatic = false) {
       }
       if (existsSync(payloadPath)) {
         res.setHeader("Content-Type", "application/octet-stream");
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
         try {
           const buffer = readFileSync(payloadPath);
           return res.send(buffer);
@@ -642,6 +661,103 @@ async function serveRSCPayload(req, res, isOld = false, isStatic = false) {
         }
       }
     }
+    let isPathBlocked = false;
+    const reqSegments = reqPath.split("/").filter(Boolean);
+    const srcFolder = path.resolve(process.cwd(), "src");
+    const [pagePath, dynamicParams] = getFilePathAndDynamicParams(
+      reqSegments,
+      req.query,
+      srcFolder,
+    );
+
+    if (pagePath) {
+      let cachedConfig = pageFunctionsConfigCache.get(pagePath);
+      if (!cachedConfig) {
+        const pageFolder = path.dirname(pagePath);
+        const [pageFunctionsPath] = getFilePathAndDynamicParams(
+          reqSegments,
+          req.query,
+          pageFolder,
+          "page_functions",
+          true,
+          true,
+          undefined,
+          reqSegments.length,
+        );
+
+        if (pageFunctionsPath) {
+          const pageFunctionsModule = await importModule(pageFunctionsPath);
+          const allowISGValue = pageFunctionsModule.allowISG
+            ? await pageFunctionsModule.allowISG()
+            : true;
+
+          let staticPathsSet = null;
+          if (pageFunctionsModule.getStaticPaths) {
+            const paths = await pageFunctionsModule.getStaticPaths();
+            staticPathsSet = new Set(
+              (paths || []).map((pathObj) => {
+                const sortedEntries = Object.entries(pathObj).sort((a, b) =>
+                  a[0].localeCompare(b[0])
+                );
+                return JSON.stringify(sortedEntries);
+              })
+            );
+          }
+
+          cachedConfig = {
+            allowISG: allowISGValue,
+            staticPathsSet,
+            validateParams: pageFunctionsModule.validateParams || null,
+          };
+        } else {
+          cachedConfig = {
+            allowISG: true,
+            staticPathsSet: null,
+            validateParams: null,
+          };
+        }
+
+        if (!isDevelopment) {
+          pageFunctionsConfigCache.set(pagePath, cachedConfig);
+        }
+      }
+
+      const { allowISG: allowISGValue, staticPathsSet, validateParams: validateParamsFn } = cachedConfig;
+      const hasParams = Object.keys(dynamicParams || {}).length > 0;
+      if (hasParams) {
+        if (validateParamsFn) {
+          const isValid = await validateParamsFn(dynamicParams);
+          if (!isValid) {
+            isPathBlocked = true;
+          }
+        }
+
+        if (!isPathBlocked && allowISGValue === false) {
+          let isPathAllowed = false;
+          if (staticPathsSet) {
+            const sortedQueryEntries = Object.entries(dynamicParams)
+              .sort((a, b) => a[0].localeCompare(b[0]))
+              .map(([k, v]) => {
+                if (Array.isArray(v)) return [k, v.join(",")];
+                return [k, String(v)];
+              });
+            const serializedQuery = JSON.stringify(sortedQueryEntries);
+            isPathAllowed = staticPathsSet.has(serializedQuery);
+          }
+          if (!isPathAllowed) {
+            if (isDevelopment) {
+              isPathBlocked = true;
+            } else {
+              const htmlPath = path.join("dist2", reqPath, "index.html");
+              if (!existsSync(htmlPath)) {
+                isPathBlocked = true;
+              }
+            }
+          }
+        }
+      }
+    }
+
     const context = getContext(req, res);
     const isNotFound = {};
     await requestStorage.run(context, async () => {
@@ -650,6 +766,7 @@ async function serveRSCPayload(req, res, isOld = false, isStatic = false) {
         { ...req.query },
         isNotFound,
         isDevelopment,
+        isPathBlocked,
       );
 
       if (isNotFound.value) {
@@ -681,7 +798,43 @@ async function serveRSCPayload(req, res, isOld = false, isStatic = false) {
     });
   } catch (error) {
     console.error("Error rendering RSC:", error);
-    res.status(500).send("Internal Server Error");
+    try {
+      const serializedError = {
+        message: error.message || "Unknown Error",
+        name: error.name,
+        stack: isDevelopment ? error.stack : undefined,
+      };
+      const context = getContext(req, res);
+      await requestStorage.run(context, async () => {
+        const jsx = await getErrorJSX(
+          reqPath,
+          { ...req.query },
+          serializedError,
+          isDevelopment,
+        );
+        const manifest = isDevelopment
+          ? JSON.parse(
+            readFileSync(
+              path.resolve(
+                process.cwd(),
+                isWebpack
+                  ? `${outputFolder}/react-client-manifest.json`
+                  : `react_client_manifest/react-client-manifest.json`,
+              ),
+              "utf8",
+            ),
+          )
+          : cachedClientManifest;
+        const { pipe } = isWebpack
+          ? renderToPipeableStream(jsx, manifest)
+          : renderToPipeableStream(jsx, pathToFileURL(process.cwd()).href + "/");
+        res.status(500);
+        pipe(res);
+      });
+    } catch (innerError) {
+      console.error("Fatal error rendering fallback error RSC:", innerError);
+      res.status(500).send("Internal Server Error");
+    }
   }
 }
 
@@ -706,29 +859,33 @@ app.post(/^\/____rsc_payload_error____\/.*\/?$/, async (req, res) => {
     const reqPath = (
       req.path.endsWith("/") ? req.path : req.path + "/"
     ).replace("/____rsc_payload_error____", "");
-    const jsx = await getErrorJSX(
-      reqPath,
-      { ...req.query },
-      req.body.error,
-      isDevelopment,
-    );
-    const manifest = isDevelopment
-      ? JSON.parse(
-        readFileSync(
-          path.resolve(
-            process.cwd(),
-            isWebpack
-              ? `${outputFolder}/react-client-manifest.json`
-              : `react_client_manifest/react-client-manifest.json`,
+
+    const context = getContext(req, res);
+    await requestStorage.run(context, async () => {
+      const jsx = await getErrorJSX(
+        reqPath,
+        { ...req.query },
+        req.body.error,
+        isDevelopment,
+      );
+      const manifest = isDevelopment
+        ? JSON.parse(
+          readFileSync(
+            path.resolve(
+              process.cwd(),
+              isWebpack
+                ? `${outputFolder}/react-client-manifest.json`
+                : `react_client_manifest/react-client-manifest.json`,
+            ),
+            "utf8",
           ),
-          "utf8",
-        ),
-      )
-      : cachedClientManifest;
-    const { pipe } = isWebpack
-      ? renderToPipeableStream(jsx, manifest)
-      : renderToPipeableStream(jsx, pathToFileURL(process.cwd()).href + "/");
-    pipe(res);
+        )
+        : cachedClientManifest;
+      const { pipe } = isWebpack
+        ? renderToPipeableStream(jsx, manifest)
+        : renderToPipeableStream(jsx, pathToFileURL(process.cwd()).href + "/");
+      pipe(res);
+    });
   } catch (error) {
     console.error("Error rendering RSC:", error);
     res.status(500).send("Internal Server Error");
@@ -868,6 +1025,7 @@ app.get(/^\/.*\/?$/, async (req, res) => {
 
       if (existsSync(fileToRead) && !dynamicState.value) {
         res.setHeader("Content-Type", "text/html");
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
         const meta = getStatus[reqPath];
 
         if (meta && meta.status) {
@@ -876,13 +1034,26 @@ app.get(/^\/.*\/?$/, async (req, res) => {
           res.statusCode = 200; // Default
         }
         try {
-          const htmlContent = readFileSync(fileToRead);
-          res.write(htmlContent);
+          let htmlContent = readFileSync(fileToRead, "utf8");
+          let buildId = "";
+          try {
+            const metadataPath = path.join("dist2", reqPath, "metadata.json");
+            if (existsSync(metadataPath)) {
+              const metaObj = JSON.parse(readFileSync(metadataPath, "utf8"));
+              buildId = metaObj.generatedAt || "";
+            }
+          } catch (e) { }
+
+          let scripts = `<script>window.__DINOU_USE_STATIC__=true;</script>`;
           if (htmlPathOld) {
-            res.write("<script>window.__DINOU_USE_OLD_RSC__=true;</script>");
+            scripts += `<script>window.__DINOU_USE_OLD_RSC__=true;</script>`;
           }
-          res.write("<script>window.__DINOU_USE_STATIC__=true;</script>");
-          res.end();
+          if (buildId) {
+            scripts += `<script>window.__DINOU_BUILD_ID__="${buildId}";</script>`;
+          }
+
+          htmlContent = htmlContent.replace("</head>", `${scripts}</head>`);
+          res.send(htmlContent);
         } catch (err) {
           console.error("Error reading HTML file:", err);
           if (!res.headersSent) res.status(500).send("Server Error");
@@ -1078,8 +1249,27 @@ app.post("/____server_function____", async (req, res) => {
       return res.status(400).json({ error: "Invalid file URL format" });
     }
 
-    // Extract relativePath and normalize (remove 'file://' and potential '/')
-    let relativePath = fileUrl.replace(/^file:\/\/\/?/, "").trim();
+    let relativePath;
+
+    // Check if the URL is a relative reference (e.g. file:///src/...)
+    // If so, extract it directly without using fileURLToPath (which throws on Windows without a drive letter)
+    const isRelativeSrc = fileUrl.startsWith("file:///src/") || fileUrl.startsWith("file:///src\\");
+
+    if (isRelativeSrc) {
+      relativePath = fileUrl.replace(/^file:\/\/\/?/, "").trim();
+    } else {
+      const resolvedPath = fileURLToPath(fileUrl);
+      relativePath = resolvedPath;
+
+      const normalizedCwd = normalizePathCase(process.cwd());
+      const normalizedResolved = normalizePathCase(resolvedPath);
+
+      if (normalizedResolved.startsWith(normalizedCwd)) {
+        relativePath = path.relative(normalizedCwd, normalizedResolved);
+      } else {
+        relativePath = relativePath.replace(/^[\\/]+/, "");
+      }
+    }
     const normalizedRelative = relativePath.replace(/\\/g, "/");
     if (
       normalizedRelative.startsWith("/") ||
@@ -1090,7 +1280,7 @@ app.post("/____server_function____", async (req, res) => {
         .status(400)
         .json({ error: "Invalid path: no absolute, traversal, or drive letter allowed" });
     }
-    // console.log("relPath", relativePath);
+
     // Restrict to 'src/' folder: prepend 'src/' if missing, and resolve absolutePath
     if (!relativePath.startsWith("src/") && !relativePath.startsWith("src\\")) {
       relativePath = path.join("src", relativePath);
@@ -1104,9 +1294,10 @@ app.post("/____server_function____", async (req, res) => {
         .status(403)
         .json({ error: "Access denied: file outside src directory" });
     }
-    // console.log("absPath", absolutePath);
+
     // Verify that the file exists
     if (!existsSync(absolutePath)) {
+      // console.error("❌ [Dinou Server Function 404] File not found! id:", id, "relativePath:", relativePath, "absolutePath:", absolutePath);
       return res.status(404).json({ error: "File not found" });
     }
 
@@ -1127,8 +1318,8 @@ app.post("/____server_function____", async (req, res) => {
           .status(403)
           .json({ error: "Not a valid server function file" });
       }
-      // Parse exports (you need to implement parseExports on server if not present)
-      const exports = parseExports(fileContent); // Assume you move parseExports to a shared util
+      // Parse exports
+      const exports = parseExports(fileContent);
       allowedExports = new Set(exports);
     }
 
@@ -1141,10 +1332,10 @@ app.post("/____server_function____", async (req, res) => {
       return res.status(400).json({ error: "Invalid export name" });
     }
 
-    // Proceed with import (using your importModule)
+    // Proceed with import
     const mod = await importModule(absolutePath);
 
-    // Validate exportName: only allow 'default' or others if you define a whitelist
+    // Validate exportName
     if (!exportName || (exportName !== "default" && !mod[exportName])) {
       return res.status(400).json({ error: "Invalid export name" });
     }

package/dinou/esbuild/helpers-esbuild/get-config-esbuild-prod.mjs

@@ -56,6 +56,9 @@ export default function getConfigEsbuildProd({
     metafile: true,
     logLevel: "warning",
     minify: true,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+    },
     external: [
       "/__SERVER_FUNCTION_PROXY__",
       "/serverFunctionProxy.js",

package/dinou/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou-ejected",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "main": "index.js",
   "private": true,
   "exports": {

package/dinou/webpack/loaders/server-functions-loader.js

@@ -1,4 +1,6 @@
 const path = require("path");
+
+const { normalizePathCase } = require("../../core/path-utils.js");
 const parseExports = require("../../core/parse-exports.js");
 const { useServerRegex } = require("../../constants.js");
 
@@ -16,7 +18,10 @@ module.exports = function (source) {
 
   // Build IDs
   const moduleId = this.resourcePath;
-  const relativePath = path.relative(process.cwd(), moduleId);
+  const relativePath = path.relative(
+    normalizePathCase(process.cwd()),
+    normalizePathCase(moduleId)
+  );
   const normalizedPath = relativePath.replace(/\\/g, "/");
 
   const fileUrl = `file:///${normalizedPath}`;

package/dinou/webpack/plugins/manifest-generator-plugin.js

@@ -14,7 +14,7 @@ class ManifestGeneratorPlugin {
       compilation.hooks.processAssets.tap(
         {
           name: pluginName,
-          stage: Compilation.PROCESS_ASSETS_STAGE_REPORT,
+          stage: Compilation.PROCESS_ASSETS_STAGE_ANALYSE,
         },
         (assets) => {
           // Traverse chunks to generate manifest

package/dinou/webpack/webpack.config.js

@@ -45,7 +45,17 @@ const outputDirs = [
 
 function cleanDir(dir) {
   if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
+    try {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        const fullPath = path.join(dir, file);
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      }
+    } catch (e) {
+      try {
+        fs.rmSync(dir, { recursive: true, force: true });
+      } catch (err) {}
+    }
   }
 }
 
@@ -61,6 +71,7 @@ module.exports = async () => {
       maxEntrypointSize: 512000,
       maxAssetSize: 512000,
     },
+    cache: false,
     mode: isDevelopment ? "development" : "production",
     entry: {
       main: [path.resolve(__dirname, "../core/client-webpack.jsx")].filter(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "description": "Lightweight-Ejectable Full-Stack React 19 Framework with support for React Server Components (RSC), Server Functions, Server-Side Rendering (SSR), Static Generation (SSG), Incremental Static Generation (ISG), and Incremental Static Regeneration (ISR)",
   "main": "index.js",
   "bin": {