dinou 6.1.1 → 7.0.0

package/dinou/core/http-adapter.js

@@ -0,0 +1,115 @@
+// dinou/core/http-adapter.js
+// Bidirectional adapter between Node.js HTTP (IncomingMessage/ServerResponse)
+// and WHATWG Web Standards (Request/Response/ReadableStream).
+
+const { Readable } = require("node:stream");
+
+/**
+ * Converts a Node.js IncomingMessage / Express Request into a standard Web Request.
+ * @param {import('express').Request | import('http').IncomingMessage} req 
+ * @returns {Request}
+ */
+function nodeToWebRequest(req) {
+  const protocol = req.headers["x-forwarded-proto"] || (req.socket?.encrypted ? "https" : "http");
+  const host = req.headers["x-forwarded-host"] || req.headers.host || "localhost";
+  const url = new URL(req.originalUrl || req.url || "/", `${protocol}://${host}`).href;
+
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else {
+      headers.set(key, value);
+    }
+  }
+
+  const method = req.method || "GET";
+  const isBodyAllowed = method !== "GET" && method !== "HEAD";
+
+  let body = null;
+  if (isBodyAllowed) {
+    if (req.body && typeof req.body === "object" && !(req.body instanceof Buffer)) {
+      const contentType = req.headers["content-type"] || "";
+      if (contentType.includes("application/json")) {
+        body = JSON.stringify(req.body);
+      } else {
+        body = JSON.stringify(req.body);
+      }
+    } else if (Buffer.isBuffer(req.body) || typeof req.body === "string") {
+      body = req.body;
+    } else if (typeof req.on === "function") {
+      // If body hasn't been consumed yet, wrap Node stream into Web ReadableStream
+      body = Readable.toWeb(req);
+    }
+  }
+
+  const init = {
+    method,
+    headers,
+    body: isBodyAllowed ? body : null,
+  };
+
+  // Node.js fetch / undici requires duplex: 'half' when streaming request bodies
+  if (body && typeof body.getReader === "function") {
+    init.duplex = "half";
+  }
+
+  return new Request(url, init);
+}
+
+/**
+ * Sends a standard Web Response into a Node.js ServerResponse / Express Response.
+ * @param {Response} webResponse 
+ * @param {import('express').Response | import('http').ServerResponse} res 
+ */
+async function sendWebResponseToNode(webResponse, res) {
+  res.statusCode = webResponse.status;
+  if (webResponse.statusText) {
+    res.statusMessage = webResponse.statusText;
+  }
+
+  // Handle cookies (multiple Set-Cookie headers)
+  if (typeof webResponse.headers.getSetCookie === "function") {
+    const cookies = webResponse.headers.getSetCookie();
+    if (cookies && cookies.length > 0) {
+      res.setHeader("Set-Cookie", cookies);
+    }
+  }
+
+  for (const [key, value] of webResponse.headers.entries()) {
+    if (key.toLowerCase() === "set-cookie") {
+      if (typeof webResponse.headers.getSetCookie !== "function") {
+        res.setHeader("Set-Cookie", value);
+      }
+    } else {
+      res.setHeader(key, value);
+    }
+  }
+
+  if (!webResponse.body) {
+    return res.end();
+  }
+
+  if (typeof webResponse.body.getReader === "function") {
+    const nodeStream = Readable.fromWeb(webResponse.body);
+    nodeStream.on("error", (err) => {
+      console.error("[http-adapter] Error in response stream:", err);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.end("Internal Server Error");
+      } else {
+        res.destroy(err);
+      }
+    });
+    nodeStream.pipe(res);
+  } else {
+    const arrayBuffer = await webResponse.arrayBuffer();
+    res.end(Buffer.from(arrayBuffer));
+  }
+}
+
+module.exports = {
+  nodeToWebRequest,
+  sendWebResponseToNode,
+};

package/dinou/core/import-module.js

@@ -1,53 +1,83 @@
-const { pathToFileURL } = require("url");
-const path = require("path");
-const fs = require("fs");
-const isWebpack = process.env.DINOU_BUILD_TOOL === "webpack";
-
-function getMtimeParam(absPath) {
-  try {
-    const stats = fs.statSync(absPath);
-    return Math.round(stats.mtimeMs);
-  } catch (e) {
-    return Date.now();
-  }
-}
-
-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 += `?mtime=${getMtimeParam(absPath)}`;
-    }
-    const mod = await import(fileUrl);
-    return mod;
-  }
-
-  try {
-    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)
-    ) {
-      let fileUrl = pathToFileURL(absPath).href;
-      if (process.env.NODE_ENV !== "production") {
-        fileUrl += `?mtime=${getMtimeParam(absPath)}`;
-      }
-      const mod = await import(fileUrl);
-      return mod;
-    }
-    throw err;
-  }
-}
-
-module.exports = importModule;
+const { pathToFileURL } = require("url");
+const path = require("path");
+const fs = require("fs");
+
+function getMtimeParam(absPath) {
+  try {
+    const stats = fs.statSync(absPath);
+    return Math.round(stats.mtimeMs);
+  } catch (e) {
+    return Date.now();
+  }
+}
+
+function normalizeKey(p) {
+  if (!p) return "";
+  let s = String(p).replace(/\\/g, "/");
+  s = s.replace(/^file:\/\/\/?/, "");
+  if (s.length > 2 && s[1] === ":") s = s.slice(2);
+  const srcIdx = s.indexOf("/src/");
+  if (srcIdx !== -1) {
+    s = s.slice(srcIdx + 1);
+  } else if (s.startsWith("/src/")) {
+    s = s.slice(1);
+  }
+  const cwd = typeof process !== "undefined" && typeof process.cwd === "function"
+    ? process.cwd().replace(/\\/g, "/")
+    : "";
+  if (cwd && s.startsWith(cwd)) {
+    s = s.slice(cwd.length);
+  }
+  s = s.replace(/^\/+/, "").replace(/^\.\//, "");
+  return s;
+}
+
+async function importModule(modulePath) {
+  const registry = typeof globalThis !== "undefined" ? globalThis.__DINOU_ROUTE_MODULES__ : null;
+  if (registry) {
+    const key = normalizeKey(modulePath);
+    if (registry[key]) {
+      const loader = registry[key];
+      return typeof loader === "function" ? await loader() : loader;
+    }
+    // Also try with or without extensions / leading src/
+    const alternateKeys = [
+      key,
+      key.startsWith("src/") ? key.slice(4) : "src/" + key,
+      key.replace(/\.[jt]sx?$/, ""),
+      key.startsWith("src/") ? key : "src/" + key,
+      key.startsWith("/") ? key : "/" + key,
+    ];
+    for (const alt of alternateKeys) {
+      if (registry[alt]) {
+        const loader = registry[alt];
+        return typeof loader === "function" ? await loader() : loader;
+      }
+    }
+  }
+
+  const absPath = path.isAbsolute(modulePath)
+    ? modulePath
+    : path.resolve(process.cwd(), modulePath);
+
+  let fileUrl = pathToFileURL(absPath).href;
+  if (process.env.NODE_ENV !== "production") {
+    fileUrl += `?mtime=${getMtimeParam(absPath)}`;
+  }
+
+  const mod = await import(/* webpackIgnore: true */ fileUrl);
+  return mod;
+}
+
+function registerRouteModules(modulesMap) {
+  if (typeof globalThis !== "undefined") {
+    globalThis.__DINOU_ROUTE_MODULES__ = {
+      ...(globalThis.__DINOU_ROUTE_MODULES__ || {}),
+      ...modulesMap,
+    };
+  }
+}
+
+importModule.register = registerRouteModules;
+
+module.exports = importModule;

package/dinou/core/layout-functions.js

@@ -0,0 +1,181 @@
+const path = require("path");
+const { existsSync } = require("./vfs");
+const importModule = require("./import-module");
+const { resolveModulePpr } = require("./resolve-module-ppr");
+
+const LAYOUT_FUNCTIONS_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+const LAYOUT_FUNCTIONS_NAMES = ["layout_functions", "layout.functions"];
+
+/**
+ * Finds the layout_functions file in the given layout directory, if it exists.
+ * @param {string} layoutFolderPath
+ * @returns {string | null}
+ */
+function getLayoutFunctionsPath(layoutFolderPath) {
+  if (!layoutFolderPath) return null;
+  for (const name of LAYOUT_FUNCTIONS_NAMES) {
+    for (const ext of LAYOUT_FUNCTIONS_EXTENSIONS) {
+      const candidate = path.join(layoutFolderPath, `${name}${ext}`);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+      const slashCandidate = candidate.replace(/\\/g, "/");
+      if (existsSync(slashCandidate)) {
+        return slashCandidate;
+      }
+      if (typeof globalThis !== "undefined" && globalThis.__DINOU_ROUTE_MODULES__) {
+        const norm = slashCandidate.replace(/^file:\/\/\/?/, "").replace(/^\/+/, "");
+        const clean = norm.startsWith("src/") ? norm : "src/" + norm.replace(/^.*\/src\//, "");
+        if (globalThis.__DINOU_ROUTE_MODULES__[clean] || globalThis.__DINOU_ROUTE_MODULES__[norm]) {
+          return clean;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Executes getProps from layout_functions for a given layout, returning the props directly.
+ * @param {string} layoutPath
+ * @param {object} dParams
+ * @returns {Promise<object>}
+ */
+async function getLayoutProps(layoutPath, dParams = {}) {
+  if (!layoutPath) return {};
+  const layoutFolder = /\.[a-zA-Z0-9]+$/.test(layoutPath)
+    ? path.dirname(layoutPath)
+    : layoutPath;
+  const layoutFunctionsPath = getLayoutFunctionsPath(layoutFolder);
+  if (!layoutFunctionsPath) return {};
+
+  try {
+    const mod = await importModule(layoutFunctionsPath);
+    const getPropsFn =
+      mod.getProps ||
+      mod.default?.getProps ||
+      (typeof mod.default === "function" ? mod.default : null);
+    if (typeof getPropsFn === "function") {
+      const res = await getPropsFn(dParams);
+      return res && typeof res === "object" ? res : {};
+    }
+  } catch (err) {
+    console.error(`[Dinou] Error executing getProps in ${layoutFunctionsPath}:`, err);
+  }
+  return {};
+}
+
+/**
+ * Resolves layout_functions configuration (revalidate, tags, dynamic, allowISG, validateParams).
+ * @param {string} layoutPath
+ * @param {object} dParams
+ * @returns {Promise<object>}
+ */
+async function resolveLayoutFunctionsConfig(layoutPath, dParams = {}) {
+  const defaultConfig = {
+    allowISG: true,
+    staticPathsSet: null,
+    validateParams: null,
+    isDynamic: false,
+    revalidate: undefined,
+    tags: [],
+    getProps: null,
+    ppr: null,
+  };
+
+  if (!layoutPath) return defaultConfig;
+
+  const layoutFolder = /\.[a-zA-Z0-9]+$/.test(layoutPath)
+    ? path.dirname(layoutPath)
+    : layoutPath;
+  const layoutFunctionsPath = getLayoutFunctionsPath(layoutFolder);
+  if (!layoutFunctionsPath) return defaultConfig;
+
+  let layoutPpr = null;
+  try {
+    const mod = await importModule(layoutFunctionsPath);
+    if (mod) {
+      layoutPpr = await resolveModulePpr(mod);
+    }
+    if (layoutPpr === null && typeof globalThis !== "undefined" && globalThis.__DINOU_ROUTE_METADATA__) {
+      const normKey = layoutFunctionsPath ? layoutFunctionsPath.replace(/\\/g, "/") : "";
+      for (const [k, meta] of Object.entries(globalThis.__DINOU_ROUTE_METADATA__)) {
+        if (meta.ppr !== undefined && (normKey === k || normKey.endsWith("/" + k) || normKey.endsWith(k))) {
+          layoutPpr = Boolean(meta.ppr);
+          break;
+        }
+      }
+    }
+    const resolvedAllowISG =
+      typeof mod.allowISG === "function"
+        ? await mod.allowISG()
+        : typeof mod.default?.allowISG === "function"
+        ? await mod.default.allowISG()
+        : (mod.allowISG ?? mod.default?.allowISG ?? true);
+
+    const getStaticPathsFn = mod.getStaticPaths || mod.default?.getStaticPaths;
+    let staticPathsSet = null;
+    if (getStaticPathsFn) {
+      const paths = await (typeof getStaticPathsFn === "function" ? getStaticPathsFn() : getStaticPathsFn);
+      if (Array.isArray(paths)) {
+        staticPathsSet = new Set(
+          paths.map((p) => {
+            if (typeof p === "object" && p !== null && !Array.isArray(p)) {
+              const sorted = Object.entries(p).sort((a, b) => a[0].localeCompare(b[0]));
+              return JSON.stringify(sorted);
+            }
+            return String(p);
+          })
+        );
+      }
+    }
+
+    const revalidateVal =
+      typeof mod.revalidate === "function"
+        ? await mod.revalidate()
+        : typeof mod.default?.revalidate === "function"
+        ? await mod.default.revalidate()
+        : (mod.revalidate ?? mod.default?.revalidate);
+
+    const isDynamic = typeof revalidateVal === "number" && revalidateVal < 1;
+
+    const rawTags = mod.getCacheTags ?? mod.default?.getCacheTags;
+    let tagsVal = [];
+    if (typeof rawTags === "function") {
+      try {
+        tagsVal = await rawTags(dParams);
+      } catch (e) {
+        console.error("Error running getCacheTags in layout-functions:", e);
+      }
+    } else if (Array.isArray(rawTags)) {
+      tagsVal = rawTags;
+    }
+
+    const validateParamsFn = mod.validateParams || mod.default?.validateParams;
+    const getPropsFn =
+      mod.getProps ||
+      mod.default?.getProps ||
+      (typeof mod.default === "function" ? mod.default : null);
+
+    return {
+      allowISG: resolvedAllowISG,
+      staticPathsSet,
+      validateParams: typeof validateParamsFn === "function" ? validateParamsFn : null,
+      isDynamic,
+      revalidate: revalidateVal,
+      tags: Array.isArray(tagsVal) ? tagsVal : [],
+      getProps: typeof getPropsFn === "function" ? getPropsFn : null,
+      ppr: layoutPpr,
+    };
+  } catch (err) {
+    console.error(`[Dinou] Error resolving layout_functions config from ${layoutFunctionsPath}:`, err);
+    return { ...defaultConfig, ppr: layoutPpr };
+  }
+}
+
+module.exports = {
+  getLayoutFunctionsPath,
+  getLayoutProps,
+  resolveLayoutFunctionsConfig,
+};
+

package/dinou/core/link.jsx

@@ -5,37 +5,49 @@ import { resolveUrl, isExternalUrl } from "./navigation-utils.js";
 
 export function Link({
   href,
+  to,
   children,
   prefetch = true,
   fresh = false,
+  onClick,
   ...props
 }) {
+  const targetHref = href || to || "";
   const { push } = useRouter();
   const pathname = usePathname();
-  const resolvedHref = resolveUrl(href, pathname);
+  const resolvedHref = resolveUrl(targetHref, pathname);
 
   const handlePrefetch = () => {
-    if (!prefetch || !href || fresh || isExternalUrl(href)) return;
+    if (!prefetch || !targetHref || fresh || isExternalUrl(targetHref)) return;
     if (window.__DINOU_PREFETCH__) {
       window.__DINOU_PREFETCH__(resolvedHref);
     }
   };
 
   const handleClick = (e) => {
-    if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || isExternalUrl(href)) return;
+    if (onClick) {
+      onClick(e);
+    }
+
+    if (e.defaultPrevented) return;
+    if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || isExternalUrl(targetHref)) return;
 
     e.preventDefault();
-    push(href, { fresh });
+    if (targetHref) {
+      push(targetHref, { fresh });
+    }
   };
 
   return (
     <a
-      href={resolvedHref}
+      {...props}
+      href={resolvedHref || undefined}
       onClick={handleClick}
       onMouseEnter={handlePrefetch}
-      {...props}
     >
       {children}
     </a>
   );
 }
+
+export default Link;

package/dinou/core/load-dinou-config.js

@@ -0,0 +1,60 @@
+const path = require("path");
+const { existsSync } = require("fs");
+const { pathToFileURL } = require("url");
+
+let dinouConfig = { plugins: [] };
+let dinouConfigPromise = null;
+
+async function getDinouConfig() {
+  if (typeof globalThis !== "undefined" && globalThis.__DINOU_CONFIG__) {
+    return globalThis.__DINOU_CONFIG__;
+  }
+  if (dinouConfigPromise) return dinouConfigPromise;
+  dinouConfigPromise = (async () => {
+    const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+    for (const filename of ["dinou.config.js", "dinou.config.mjs", "dinou.config.cjs", "dinou.config.ts"]) {
+      const p = path.resolve(cwd, filename);
+      if (existsSync(p)) {
+        try {
+          let loaded;
+          const isDev = process.env.NODE_ENV !== "production";
+          if (p.endsWith(".mjs")) {
+            loaded = await import(pathToFileURL(p).href + (isDev ? `?t=${Date.now()}` : ""));
+          } else {
+            const nodeReq =
+              typeof globalThis !== "undefined" && typeof globalThis.__dinou_require__ === "function"
+                ? globalThis.__dinou_require__
+                : typeof require === "function"
+                ? require
+                : null;
+            if (nodeReq) {
+              try {
+                loaded = nodeReq(p);
+              } catch (e) {
+                loaded = await import(pathToFileURL(p).href + (isDev ? `?t=${Date.now()}` : ""));
+              }
+            } else {
+              loaded = await import(pathToFileURL(p).href + (isDev ? `?t=${Date.now()}` : ""));
+            }
+          }
+          const cfg = loaded && loaded.default ? loaded.default : loaded || { plugins: [] };
+          dinouConfig = cfg;
+          return cfg;
+        } catch (err) {
+          console.error(`[Dinou] Error loading ${filename}:`, err);
+        }
+      }
+    }
+    return dinouConfig;
+  })();
+  return dinouConfigPromise;
+}
+
+// Initial sync attempt if already set on globalThis
+if (typeof globalThis !== "undefined" && globalThis.__DINOU_CONFIG__) {
+  dinouConfig = globalThis.__DINOU_CONFIG__;
+}
+
+module.exports = {
+  getDinouConfig,
+};