@brightsideoy/kama 0.1.0-alpha.149 → 0.1.0-alpha.151

package/templates/astro-starter/src/middleware.ts

@@ -0,0 +1,293 @@
+import { defineMiddleware } from "astro:middleware";
+import { env } from "cloudflare:workers";
+
+export const onRequest = defineMiddleware(async (context, next) => {
+    const pathname = context.url.pathname;
+    const cfContext = (context.locals as any).cfContext;
+    const workerEnv = cfContext?.env || (env as any);
+    const HTML_CACHE = workerEnv?.HTML_CACHE; // KV Namespace binding
+
+    // 🎯 0. DIRECT EDGE INTERCEPT FOR CACHE PURGE ENDPOINT
+    if (pathname === "/api/purge" || pathname === "/api/purge/") {
+        if (context.request.method !== "POST") {
+            return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+                status: 405,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        const authHeader = context.request.headers.get("Authorization");
+        const expectedToken = workerEnv.CLOUDFLARE_API_TOKEN;
+
+        if (!expectedToken || authHeader !== `Bearer ${expectedToken}`) {
+            return new Response(JSON.stringify({ error: "Unauthorized Token Mismatch" }), {
+                status: 401,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        try {
+            const body = await context.request.json();
+            const cache = typeof caches !== "undefined" && caches.default ? caches.default : null;
+            const origin = context.url.origin;
+
+            // A. Purge Workers Caching Layer (Astro cfContext)
+            if (typeof cfContext?.cache?.purge === 'function') {
+                try {
+                    await cfContext.cache.purge({ purgeEverything: true });
+                    console.log("✅ New Cloudflare Workers Cache Engine Purged");
+                } catch (e) {
+                    console.error("❌ Failed to purge new Workers Cache Engine", e);
+                }
+            }
+
+            // B. Version-Based Instant Invalidation (0ms KV Write)
+            if (HTML_CACHE) {
+                try {
+                    const now = Date.now().toString();
+
+                    if (body.purge_everything) {
+                        // 🎯 GLOBAL PURGE: Bumping site_version instantly invalidates ALL KV pages globally!
+                        await HTML_CACHE.put("site_version", now);
+                        console.log(`✅ [Version Tagging] Global site_version updated to ${now}`);
+                    } else if (Array.isArray(body.urls) && body.urls.length > 0) {
+                        // 🎯 SURGICAL PURGE: Parallel execution for page version bumps
+                        const purgeTasks = body.urls.map((targetUrl: string) => {
+                            const urlPath = new URL(targetUrl).pathname;
+                            const cleanPath = urlPath.replace(/\/$/, "") || "/";
+                            return HTML_CACHE.put(`v:${cleanPath}`, now);
+                        });
+                        await Promise.all(purgeTasks);
+                        console.log(`✅ [Version Tagging] Updated versions for ${body.urls.length} URLs`);
+                    }
+                } catch (kvErr) {
+                    console.error("❌ KV Version Tagging Error:", kvErr);
+                }
+            }
+
+            // C. Global Legacy Worker Cache Purge
+            if (body.purge_everything) {
+                if (cache) {
+                    const rootUrls = [
+                        origin,
+                        `${origin}/`,
+                        `${origin}/home`,
+                        `${origin}/home/`
+                    ];
+
+                    for (const url of rootUrls) {
+                        await cache.delete(new Request(url));
+                    }
+                }
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "All Worker Caches Purged"
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            // D. Surgical Legacy Worker Cache Purge (For Updated Pages)
+            if (Array.isArray(body.urls) && body.urls.length > 0) {
+                const results = [];
+
+                for (const targetUrl of body.urls) {
+                    const cleanUrl = targetUrl.split('?')[0];
+                    const urlNoSlash = cleanUrl.replace(/\/$/, "");
+                    const urlWithSlash = urlNoSlash + "/";
+
+                    let p1 = false, p2 = false;
+                    if (cache) {
+                        p1 = await cache.delete(new Request(urlNoSlash));
+                        p2 = await cache.delete(new Request(urlWithSlash));
+                    }
+
+                    results.push({ url: targetUrl, purged: p1 || p2 });
+                }
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "URLs processed and version tags updated",
+                    results
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            // 🎯 E. SURGICAL DELETION FOR DELETED PAGES
+            if (Array.isArray(body.deleted_urls) && body.deleted_urls.length > 0) {
+                const results: any[] = [];
+
+                const deleteTasks = body.deleted_urls.map(async (targetUrl: string) => {
+                    const urlPath = new URL(targetUrl).pathname;
+                    const cleanPath = urlPath.replace(/\/$/, "") || "/";
+
+                    let purgedKv = false;
+
+                    if (HTML_CACHE) {
+                        const [siteVer, pageVer] = await Promise.all([
+                            HTML_CACHE.get("site_version"),
+                            HTML_CACHE.get(`v:${cleanPath}`)
+                        ]);
+
+                        if (siteVer || pageVer) {
+                            const activeCacheKey = `${cleanPath}:v:${siteVer || "1"}:${pageVer || "1"}`;
+                            await HTML_CACHE.delete(activeCacheKey);
+                            purgedKv = true;
+                        }
+
+                        await HTML_CACHE.delete(`v:${cleanPath}`);
+                    }
+
+                    const cleanUrl = targetUrl.split('?')[0];
+                    const urlNoSlash = cleanUrl.replace(/\/$/, "");
+                    const urlWithSlash = urlNoSlash + "/";
+
+                    let p1 = false, p2 = false;
+                    if (cache) {
+                        p1 = await cache.delete(new Request(urlNoSlash));
+                        p2 = await cache.delete(new Request(urlWithSlash));
+                    }
+
+                    results.push({ url: targetUrl, purgedKv, purgedLegacy: p1 || p2 });
+                });
+
+                await Promise.all(deleteTasks);
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "Deleted URLs processed and KV keys permanently removed",
+                    results
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            return new Response(JSON.stringify({ error: "Invalid payload format" }), {
+                status: 400,
+                headers: { "Content-Type": "application/json" },
+            });
+
+        } catch (err: any) {
+            return new Response(JSON.stringify({ error: err.message }), {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+
+    // 🎯 1. KV STATIC "FILE" CACHE READ WITH VERSION TAGGING
+    const isWarmer = context.request.headers.get("X-Cache-Warmer") === "true";
+    const isHtmlPage = !pathname.includes('.') && !pathname.startsWith('/api/');
+    const cleanLookupPath = pathname.replace(/\/$/, "") || "/";
+
+    let activeCacheKey = cleanLookupPath;
+
+    if (isHtmlPage && HTML_CACHE && !isWarmer) {
+        try {
+            const [siteVer, pageVer] = await Promise.all([
+                HTML_CACHE.get("site_version"),
+                HTML_CACHE.get(`v:${cleanLookupPath}`)
+            ]);
+
+            activeCacheKey = `${cleanLookupPath}:v:${siteVer || "1"}:${pageVer || "1"}`;
+
+            const cachedHtml = await HTML_CACHE.get(activeCacheKey);
+            if (cachedHtml) {
+                return new Response(cachedHtml, {
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/html; charset=utf-8",
+                        "X-Cache-Status": "HIT-KV-STATICFILE",
+                        "X-Cache-Key": activeCacheKey,
+                        "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate"
+                    }
+                });
+            }
+        } catch (e) {
+            console.warn("[Middleware] KV lookup bypass:", e);
+        }
+    }
+
+    // Process downstream SSR routes
+    const response = await next();
+
+    // 🎯 2. KV STATIC "FILE" CACHE WRITE (Save HTML under active Version Key)
+    if (
+        isHtmlPage &&
+        HTML_CACHE &&
+        response.status === 200 &&
+        response.headers.get("content-type")?.includes("text/html")
+    ) {
+        const htmlText = await response.clone().text();
+
+        const writeTask = (async () => {
+            if (activeCacheKey === cleanLookupPath || isWarmer) {
+                const forcedVersion = Date.now().toString();
+
+                await HTML_CACHE.put(`v:${cleanLookupPath}`, forcedVersion);
+
+                const siteVer = await HTML_CACHE.get("site_version") || "1";
+
+                activeCacheKey = `${cleanLookupPath}:v:${siteVer}:${forcedVersion}`;
+            }
+
+            await HTML_CACHE.put(activeCacheKey, htmlText);
+            console.log(`✅ [Middleware] Saved HTML to KV under key: ${activeCacheKey}`);
+        })();
+
+        if (cfContext && typeof cfContext.waitUntil === 'function') {
+            cfContext.waitUntil(writeTask);
+        } else {
+            writeTask.catch((e: any) => console.error("KV write error:", e));
+        }
+    }
+
+    // 🎯 3. SERVE LLMS & LLXML ENDPOINTS
+    if (pathname === "/llms.txt" || pathname === "/llms-full.txt") {
+        response.headers.set("Content-Type", "text/plain; charset=utf-8");
+        response.headers.set("Cache-Control", "public, max-age=3600");
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    if (pathname === "/llxml.txt") {
+        response.headers.set("Content-Type", "application/xml; charset=utf-8");
+        response.headers.set("Cache-Control", "public, max-age=3600");
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    // 🎯 4. IMAGE & STATIC ASSET CACHING
+    if (
+        pathname.startsWith("/media/") ||
+        pathname.startsWith("/_image") ||
+        pathname.startsWith("/cdn-cgi/image/") ||
+        pathname.match(/\.(png|jpg|jpeg|webp|avif|svg|gif|ico|woff2?|css|js)$/i)
+    ) {
+        response.headers.set(
+            "Cache-Control",
+            "public, max-age=31536000, s-maxage=31536000, immutable"
+        );
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    // 🎯 5. SECURITY HEADERS FOR HTML PAGES
+    if (response.headers.get("content-type")?.includes("text/html")) {
+        response.headers.set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload");
+        response.headers.set("X-Frame-Options", "SAMEORIGIN");
+        response.headers.set("X-Content-Type-Options", "nosniff");
+        response.headers.set("Cross-Origin-Opener-Policy", "same-origin-allow-popups");
+        response.headers.set(
+            "Content-Security-Policy",
+            "default-src 'self' https: data: 'unsafe-inline' 'unsafe-eval'; img-src 'self' https: data: blob:; connect-src 'self' https:; frame-ancestors 'self';"
+        );
+    }
+
+    return response;
+});

package/templates/astro-starter/src/pages/[...slug].astro

@@ -6,18 +6,28 @@ import Breadcrumb from "../components/global/Breadcrumb.astro";
 import { getNodeByPath, getChannelId, getTree, getTreeId } from "../lib/cms";
 import type { NodeResponse, TreeNode } from "../lib/cms";
 
+// 🎯 Import environment variables directly from Cloudflare
+import { env } from "cloudflare:workers";
+
 export const prerender = false;
 
 const { slug } = Astro.params;
+
+// Extract Preview & Revision parameters from the URL
 const searchParams = Astro.url.searchParams;
 const isPreview = searchParams.get("preview") === "true";
 const revisionId = searchParams.get("revisionId");
 
+// Smart Edge Caching Logic
+const isTimeTraveling = isPreview || !!revisionId;
+
+// 🎯 FIX: Allow Cloudflare Edge to revalidate with Worker KV middleware
 Astro.response.headers.set(
   "Cache-Control",
-  "no-store, no-cache, must-revalidate, proxy-revalidate",
+  "public, no-cache, must-revalidate",
 );
 
+// 1. STATIC ASSET CHECK
 const staticExts = [
   ".ico",
   ".png",
@@ -37,11 +47,21 @@ if (isStaticAsset) {
   return new Response(null, { status: 404 });
 }
 
-// 🎯 DUAL-ARCHITECTURE ENV RESOLUTION (No CF Imports, No runtime.env!)
-const homeSlug = String(import.meta.env.PUBLIC_HOME_SLUG || "home").trim();
+// 2. ENV & WORKER RESOLUTION
+const workerEnv = env || {};
+const cmsWorker = workerEnv.CMS_WORKER;
+
+// Extract environment configuration & fallback slug
+const envHomeSlug = import.meta.env.PUBLIC_HOME_SLUG;
+const workerHomeSlug = (workerEnv as any).PUBLIC_HOME_SLUG;
+const homeSlug = String(envHomeSlug || workerHomeSlug || "home").trim();
+
+const envApiUrl = import.meta.env.PUBLIC_API_URL;
+const workerApiUrl = workerEnv.PUBLIC_API_URL;
 const baseApiUrl = String(
-  import.meta.env.PUBLIC_API_URL || "http://localhost:8787",
+  envApiUrl || workerApiUrl || "https://admin.kamaengine.com",
 );
+
 const cleanApiUrl = baseApiUrl.endsWith("/")
   ? baseApiUrl.slice(0, -1)
   : baseApiUrl;
@@ -51,55 +71,71 @@ const customFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
   if (urlStr.startsWith("/")) urlStr = `${cleanApiUrl}${urlStr}`;
 
   const urlObj = new URL(urlStr);
-  urlObj.searchParams.set("_t", Date.now().toString());
-
-  if (revisionId) urlObj.searchParams.set("revisionId", revisionId);
-  if (isPreview) urlObj.searchParams.set("preview", "true");
-
-  return fetch(
-    new Request(urlObj.toString(), {
-      ...init,
-      cache: "no-store",
-      headers: {
-        ...init?.headers,
-        "X-Bypass-Cache": "true",
-        "Cache-Control": "no-cache, no-store, must-revalidate",
-      },
-    }),
-  );
+
+  if (isTimeTraveling) {
+    if (revisionId) urlObj.searchParams.set("revisionId", revisionId);
+    if (isPreview) urlObj.searchParams.set("preview", "true");
+    urlObj.searchParams.set("_t", Date.now().toString());
+  } else {
+    urlObj.searchParams.set("_cb", Date.now().toString());
+  }
+
+  urlStr = urlObj.toString();
+
+  const reqHeaders: Record<string, string> = {
+    ...init?.headers,
+    "Cache-Control": "no-cache, no-store, must-revalidate",
+    Pragma: "no-cache",
+    // 🎯 CRITICAL FIX: Direct Service Bindings require explicit header flags to bypass CMS KV cache!
+    "X-Bypass-Cache": "true",
+  };
+
+  const fetchOpts: RequestInit = {
+    ...init,
+    headers: reqHeaders,
+    cache: "no-store",
+  };
+
+  const req = new Request(urlStr, fetchOpts);
+
+  if (cmsWorker && typeof cmsWorker.fetch === "function") {
+    return cmsWorker.fetch(req);
+  }
+  return fetch(req);
 };
 
 const channelId = getChannelId();
 const treeId = getTreeId();
 
+// 3. PATH & CONCURRENT FETCH RESOLUTION
 const rawSlug = Array.isArray(slug) ? slug.join("/") : slugStr;
 const pathParts = rawSlug.split("/").filter(part => part.trim() !== "");
+const requestedSlug = pathParts.join("/");
+const targetSlug = requestedSlug || homeSlug;
 
 let pageData: NodeResponse | null = null;
 let navTree: TreeNode[] = [];
-let targetSlug = pathParts.join("/");
 
+// 🎯 Fetch Tree and Node in PARALLEL using the cache-busting customFetch
 try {
-  navTree = await getTree(treeId, channelId, customFetch);
-} catch (err) {
-  console.error(`❌ [SSR Error] Failed to fetch tree "${treeId}":`, err);
-}
-
-if (!targetSlug) {
-  const rootTreeSlug =
-    navTree && navTree.length > 0
-      ? navTree[0].slug || (navTree[0] as any).key
-      : "";
-  targetSlug = rootTreeSlug || homeSlug;
-}
+  const [treeResult, nodeResult] = await Promise.all([
+    getTree(treeId, channelId, customFetch).catch(err => {
+      console.error(`❌ [SSR Error] Failed to fetch tree "${treeId}":`, err);
+      return [];
+    }),
+    getNodeByPath(targetSlug, channelId, isPreview, customFetch).catch(err => {
+      console.error(
+        `❌ [SSR Error] Failed to fetch page data for path "${targetSlug}":`,
+        err,
+      );
+      return null;
+    }),
+  ]);
 
-try {
-  pageData = await getNodeByPath(targetSlug, channelId, isPreview, customFetch);
+  navTree = treeResult || [];
+  pageData = nodeResult;
 } catch (err) {
-  console.error(
-    `❌ [SSR Error] Failed to fetch page data for path "${targetSlug}":`,
-    err,
-  );
+  console.error("❌ [SSR Error] Failed concurrent fetch execution:", err);
 }
 
 if (!pageData || !pageData.node) {
@@ -113,6 +149,7 @@ const rootTreeSlug =
   navTree && navTree.length > 0
     ? navTree[0].slug || (navTree[0] as any).key
     : "";
+
 const isHomePage =
   targetSlug === homeSlug ||
   (rootTreeSlug && targetSlug === rootTreeSlug) ||
@@ -120,10 +157,13 @@ const isHomePage =
   pathParts.length === 0;
 
 const normalizedSlug = isHomePage ? "" : targetSlug;
+
 const headerBlocks = content?.header || [];
 const mainBlocks = content?.content || [];
 const sidebarBlocks = content?.sidebar || [];
 const hasSidebar = sidebarBlocks.length > 0;
+
+// Detect if this node is a standalone Page Skeleton
 const isSkeleton = node?.nodeType === "page-skeleton";
 ---