dinou 6.1.1 → 7.0.0

package/dinou/adapters/cloudflare.js

@@ -0,0 +1,65 @@
+// dinou/adapters/cloudflare.js
+// Cloudflare Workers Adapter for Dinou v7.
+// Universal edge entry point with KV storage, route registry, and Web Streams.
+
+import { handleRequest } from "../core/handler.js";
+import {
+  getStorageAdapter,
+  setStorageAdapter,
+  CloudflareKVStorage,
+  MemoryStorage,
+} from "../core/storage-adapter.js";
+
+// Ensure Edge runtime flag is set globally
+if (typeof globalThis !== "undefined") {
+  globalThis.__DINOU_RUNTIME__ = "edge";
+}
+
+let storageInitialized = false;
+
+export default {
+  /**
+   * Cloudflare Workers fetch handler
+   * @param {Request} request 
+   * @param {object} env Bindings (KV, D1, Environment variables)
+   * @param {object} ctx Execution context (waitUntil, passThroughOnException)
+   * @returns {Promise<Response>}
+   */
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith("/cdn-cgi/")) {
+      return new Response(null, { status: 404 });
+    }
+
+    if (!storageInitialized) {
+      if (env && env.DINOU_CACHE) {
+        setStorageAdapter(new CloudflareKVStorage(env.DINOU_CACHE));
+      } else {
+        setStorageAdapter(new MemoryStorage());
+      }
+      storageInitialized = true;
+    }
+
+    const isRSCPayload = url.pathname.includes("____rsc_");
+    const isServerFunction = url.pathname.includes("____server_function____") || request.headers.get("x-server-function-call") === "1";
+
+    // Static assets: files with extensions like .js, .css, .png, etc. (excluding document .html and RSC/server-functions)
+    const staticExtRegex = /\.(js|mjs|cjs|css|png|jpg|jpeg|gif|svg|ico|webp|avif|woff|woff2|ttf|eot|otf|wasm|map|txt|webmanifest)$/i;
+    const isStaticAsset = staticExtRegex.test(url.pathname) || url.pathname.startsWith("/assets/") || url.pathname.startsWith("/_dinou/");
+
+    if (!isRSCPayload && !isServerFunction && isStaticAsset && env && env.ASSETS && (request.method === "GET" || request.method === "HEAD")) {
+      try {
+        const assetRes = await env.ASSETS.fetch(request.clone ? request.clone() : request);
+        if (assetRes && assetRes.status < 400) {
+          return assetRes;
+        }
+      } catch (e) {}
+    }
+
+    return handleRequest(request, {
+      env,
+      ctx,
+      runtime: "edge",
+    });
+  },
+};

package/dinou/adapters/deno.js

@@ -0,0 +1,48 @@
+// dinou/adapters/deno.js
+// Native Deno & Deno Deploy Adapter for Dinou v7.
+// Supports standalone containers, Deno CLI, and Deno Deploy Edge.
+
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+if (typeof globalThis.AsyncLocalStorage === "undefined" && typeof AsyncLocalStorage !== "undefined") {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+
+const cwd = typeof Deno !== "undefined" ? Deno.cwd() : process.cwd();
+const mainBundlePath = path.resolve(cwd, ".dinou/deno/main.js");
+
+let mainModule = null;
+if (fs.existsSync(mainBundlePath)) {
+  try {
+    mainModule = await import(pathToFileURL(mainBundlePath).href);
+  } catch (e) {
+    console.error("[Dinou Deno Adapter] Failed to load .dinou/deno/main.js:", e);
+  }
+}
+
+const PORT = Number(
+  (typeof Deno !== "undefined" ? Deno.env.get("PORT") : process.env.PORT) || 3000
+);
+
+export async function fetch(req) {
+  if (mainModule && typeof mainModule.fetch === "function") {
+    return mainModule.fetch(req);
+  }
+  return new Response("Dinou bundle not found. Please run 'npm run build:deno' first.", {
+    status: 500,
+    headers: { "content-type": "text/plain; charset=utf-8" },
+  });
+}
+
+// Start standalone server if run directly in Deno
+if (typeof Deno !== "undefined" && typeof Deno.serve === "function" && import.meta.main) {
+  Deno.serve({ port: PORT }, fetch);
+}
+
+export default {
+  port: PORT,
+  fetch,
+};

package/dinou/adapters/netlify.js

@@ -0,0 +1,85 @@
+// dinou/adapters/netlify.js
+// Netlify Functions v2 Adapter for Dinou.
+// Automatically routes all requests to Dinou's universal Web Standards handler.
+Object.assign(process.env, { NODE_ENV: "production" });
+
+import { register } from "node:module";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+import Module from "node:module";
+
+import { dinouCoreDir } from "../core/dinou-paths.js";
+
+if (typeof register === "function") {
+  try {
+    const loaderPath = path.join(dinouCoreDir, "babel-esm-loader.js");
+    register(pathToFileURL(loaderPath).href, pathToFileURL("./"));
+  } catch (e) {
+    console.error("[Dinou Adapter] Loader registration failed:", e);
+  }
+}
+
+let reactServerPath, reactDomServerPath, reactJsxRuntimePath, reactJsxDevRuntimePath;
+let roggcServerNodePath, webpackServerNodePath;
+
+try {
+  const reactPkgJson = require.resolve("react/package.json");
+  reactServerPath = path.join(path.dirname(reactPkgJson), "react.react-server.js");
+  reactJsxRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-runtime.react-server.js");
+  reactJsxDevRuntimePath = path.join(path.dirname(reactPkgJson), "jsx-dev-runtime.react-server.js");
+
+  const reactDomPkgJson = require.resolve("react-dom/package.json");
+  reactDomServerPath = path.join(path.dirname(reactDomPkgJson), "react-dom.react-server.js");
+} catch (e) {}
+
+try {
+  const roggcPkgJson = require.resolve("@roggc/react-server-dom-esm/package.json");
+  roggcServerNodePath = path.join(path.dirname(roggcPkgJson), "server.node.js");
+} catch (e) {}
+
+try {
+  const webpackPkgJson = require.resolve("react-server-dom-webpack/package.json");
+  webpackServerNodePath = path.join(path.dirname(webpackPkgJson), "server.node.js");
+} catch (e) {}
+
+if (Module && Module._resolveFilename) {
+  const originalResolveFilename = Module._resolveFilename;
+  Module._resolveFilename = function (request, parent, isMain, options) {
+    if (request === "react") {
+      return reactServerPath;
+    } else if (request === "react-dom") {
+      return reactDomServerPath;
+    } else if (request === "react/jsx-runtime") {
+      return reactJsxRuntimePath;
+    } else if (request === "react/jsx-dev-runtime") {
+      return reactJsxDevRuntimePath;
+    } else if (request === "@roggc/react-server-dom-esm/server" && roggcServerNodePath) {
+      return roggcServerNodePath;
+    } else if (request === "react-server-dom-webpack/server" && webpackServerNodePath) {
+      return webpackServerNodePath;
+    }
+    return originalResolveFilename.call(this, request, parent, isMain, options);
+  };
+}
+
+if (typeof require === "function") {
+  globalThis.__dinou_require__ = require;
+}
+
+import { handleRequest } from "../core/handler.js";
+
+/**
+ * Netlify Function v2 handler
+ * @param {Request} request 
+ * @param {object} context 
+ * @returns {Promise<Response>}
+ */
+export default async function netlifyHandler(request, context) {
+  return handleRequest(request);
+}
+
+export const config = {
+  path: "/*",
+  preferStatic: true,
+};
+

package/dinou/adapters/node.mjs

@@ -0,0 +1,31 @@
+// dinou/adapters/node.mjs
+// Native Node.js Pre-Bundled Adapter for Dinou v7.
+// Serves the standalone pre-bundled server from .dinou/node/server.mjs.
+
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+if (typeof globalThis.AsyncLocalStorage === "undefined" && typeof AsyncLocalStorage !== "undefined") {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+
+const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+const bundlePath = path.resolve(cwd, ".dinou/node/server.mjs");
+
+if (!fs.existsSync(bundlePath)) {
+  console.error("❌ [Dinou Node Adapter] .dinou/node/server.mjs not found. Please run 'npm run build:node' first.");
+  process.exit(1);
+}
+
+const serverModule = await import(pathToFileURL(bundlePath).href);
+const PORT = Number(process.env.PORT || 3000);
+
+if (typeof serverModule.startServer === "function") {
+  await serverModule.startServer(PORT);
+} else if (serverModule.default && typeof serverModule.default.startServer === "function") {
+  await serverModule.default.startServer(PORT);
+}
+
+export default serverModule.default || serverModule;