dinou 6.1.1 → 7.1.0

package/dinou/deno/seed-kv.js

@@ -0,0 +1,115 @@
+// dinou/deno/seed-kv.js
+// Pre-seeds Deno KV database (Local SQLite or Remote Deno Deploy KV) with static SSG pages.
+
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const cwd = typeof Deno !== "undefined" && typeof Deno.cwd === "function" ? Deno.cwd() : process.cwd();
+const kvUrl = typeof Deno !== "undefined" ? Deno.env.get("DENO_KV_URL") : process.env.DENO_KV_URL;
+const dist2Dir = path.resolve(cwd, ".dinou/dist2");
+
+if (!fs.existsSync(dist2Dir)) {
+  console.log("ℹ️  [Deno KV Seed] No static files found at .dinou/dist2. Skipping KV pre-seed.");
+  if (typeof Deno !== "undefined") Deno.exit(0);
+}
+
+let kv;
+if (kvUrl) {
+  console.log(`🌐 [Deno KV Seed] Connecting to remote Deno KV: ${kvUrl}...`);
+  kv = await Deno.openKv(kvUrl);
+} else {
+  const defaultDbPath = path.resolve(cwd, ".dinou/kv.db");
+  const kvPath = (typeof Deno !== "undefined" ? Deno.env.get("DENO_KV_PATH") : process.env.DENO_KV_PATH) || defaultDbPath;
+  fs.mkdirSync(path.dirname(kvPath), { recursive: true });
+  try {
+    if (fs.existsSync(kvPath)) fs.unlinkSync(kvPath);
+    if (fs.existsSync(kvPath + "-wal")) fs.unlinkSync(kvPath + "-wal");
+    if (fs.existsSync(kvPath + "-shm")) fs.unlinkSync(kvPath + "-shm");
+  } catch (e) {}
+  console.log(`💾 [Deno KV Seed] Pre-seeding local Deno KV at ${kvPath}...`);
+  kv = await Deno.openKv(kvPath);
+}
+
+const KV_CHUNK_SIZE = 16384;
+
+async function setKvCache(kvInstance, key, content, metadata = null) {
+  if (typeof content === "string" && content.length > KV_CHUNK_SIZE) {
+    const totalChunks = Math.ceil(content.length / KV_CHUNK_SIZE);
+    const atomic = kvInstance.atomic();
+    atomic.set(["dinou_cache", key], {
+      chunked: true,
+      totalChunks,
+      metadata,
+    });
+    for (let i = 0; i < totalChunks; i++) {
+      const chunk = content.slice(i * KV_CHUNK_SIZE, (i + 1) * KV_CHUNK_SIZE);
+      atomic.set(["dinou_cache_chunk", key, i], chunk);
+    }
+    await atomic.commit();
+  } else {
+    await kvInstance.set(["dinou_cache", key], {
+      chunked: false,
+      content,
+      metadata,
+    });
+  }
+}
+
+let seededCount = 0;
+
+async function processDir(dir, relPrefix = "") {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relPath = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+    const cleanRelPath = relPath.replace(/\\/g, "/");
+
+    if (entry.isDirectory()) {
+      await processDir(fullPath, cleanRelPath);
+    } else if (entry.name === "index.html") {
+      const html = fs.readFileSync(fullPath, "utf8");
+      let metadata = null;
+      const metaPath = path.join(dir, "metadata.json");
+      if (fs.existsSync(metaPath)) {
+        try {
+          metadata = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+        } catch (e) {}
+      }
+
+      await setKvCache(kv, cleanRelPath, html, metadata);
+      seededCount++;
+      if (process.env.DINOU_DEBUG) {
+        console.log(`   ✅ Cached HTML: ${cleanRelPath}`);
+      }
+
+      if (cleanRelPath.endsWith("/index.html")) {
+        const folderKey = cleanRelPath.slice(0, -11);
+        await setKvCache(kv, folderKey, html, metadata);
+      } else if (cleanRelPath === "index.html") {
+        await setKvCache(kv, "", html, metadata);
+      }
+    } else if (entry.name.endsWith("metadata.json")) {
+      const metaContent = fs.readFileSync(fullPath, "utf8");
+      let metadata = null;
+      try {
+        metadata = JSON.parse(metaContent);
+      } catch (e) {}
+      await setKvCache(kv, cleanRelPath, metaContent, metadata);
+      seededCount++;
+      if (process.env.DINOU_DEBUG) {
+        console.log(`   ✅ Cached Meta: ${cleanRelPath}`);
+      }
+    } else if (entry.name.endsWith(".rsc")) {
+      const rsc = fs.readFileSync(fullPath, "utf8");
+      await setKvCache(kv, cleanRelPath, rsc, null);
+      seededCount++;
+      if (process.env.DINOU_DEBUG) {
+        console.log(`   ✅ Cached RSC:  ${cleanRelPath}`);
+      }
+    }
+  }
+}
+
+await processDir(dist2Dir);
+await kv.close();
+console.log(`🎉 [Deno KV Seed] Finished successfully! ${seededCount} file(s) cached in KV.\n`);

package/dinou/esbuild/build.mjs

@@ -22,10 +22,13 @@ const absPathToLink = path.resolve(
   __dirname,
   "../core/link.jsx"
 );
+const absPathToSlot = path.resolve(
+  __dirname,
+  "../core/slot.js"
+);
 
 const frameworkEntryPoints = {
   main: path.resolve(__dirname, "../core/client.jsx"),
-  error: path.resolve(__dirname, "../core/client-error.jsx"),
   serverFunctionProxy: path.resolve(
     __dirname,
     "../core/server-function-proxy.js"
@@ -37,6 +40,7 @@ const frameworkEntryPoints = {
   ),
   dinouClientRedirect: absPathToClientRedirect,
   dinouLink: absPathToLink,
+  dinouSlot: absPathToSlot,
 };
 
 try {
@@ -57,6 +61,12 @@ try {
     true,
     manifest
   );
+  updateManifestForModule(
+    absPathToSlot,
+    await fs.readFile(absPathToSlot, "utf8"),
+    true,
+    manifest
+  );
 
   const componentEntryPoints = [...esbuildEntries].reduce(
     (acc, dCE) => ({ ...acc, [dCE.outfileName]: dCE.absPath }),
@@ -87,6 +97,46 @@ try {
       outdir,
     })
   );
+
+  // 🚀 Server & Adapter Pre-bundling with react-server condition
+  console.log("⚡ [esbuild] Pre-bundling server handler and adapters (conditions: ['react-server'])...");
+  await esbuild.build({
+    entryPoints: {
+      handler: path.resolve(__dirname, "../core/handler.js"),
+      netlify: path.resolve(__dirname, "../adapters/netlify.js"),
+    },
+    bundle: true,
+    platform: "node",
+    target: "node20",
+    format: "esm",
+    conditions: ["react-server", "node", "import"],
+    outdir: ".dinou/dist3/server",
+    external: [
+      "express",
+      "chokidar",
+      "dotenv",
+      "fsevents",
+      "@swc/core",
+      "@babel/core",
+      "esbuild",
+    ],
+    banner: {
+      js: "import { createRequire as ___createRequire } from 'node:module'; import { fileURLToPath as ___fileURLToPath } from 'node:url'; import ___path from 'node:path'; const require = ___createRequire(import.meta.url || ___path.resolve(process.cwd(), 'package.json')); const __filename = import.meta.url ? ___fileURLToPath(import.meta.url) : ___path.resolve(process.cwd(), 'index.js'); const __dirname = ___path.dirname(__filename); process.env.NODE_ENV = process.env.NODE_ENV || 'production';",
+    },
+    sourcemap: true,
+  });
+  await fs.writeFile(
+    path.resolve(process.cwd(), ".dinou/dist3/server/package.json"),
+    JSON.stringify({ type: "module" }, null, 2)
+  );
+
+  // 🏗️ Pre-render static pages (SSG) at build time
+  const { execSync } = await import("node:child_process");
+  execSync(`"${process.execPath}" --conditions=react-server "${path.resolve(__dirname, "../core/run-ssg.js")}"`, {
+    stdio: "inherit",
+    env: { ...process.env, NODE_ENV: "production" },
+  });
 } catch (err) {
   console.error("Error in build:", err);
+  process.exit(1);
 }