gemi 0.48.1 → 0.49.0-rc.1

package/dist/app/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{o as a,p as b}from"../chunk-r64ba1pf.js";import"../chunk-d9k245jt.js";import"../chunk-evkv0xa7.js";import"../chunk-p5r0t9jh.js";import"../chunk-xkrthw08.js";import"../chunk-4z53shav.js";import"../chunk-m0earq80.js";import"../chunk-f18weffa.js";export{b as prismaExtension,a as App};
+import{o as a,p as b}from"../chunk-b2xv683r.js";import"../chunk-w6r5jtgb.js";import"../chunk-x5f4e2fp.js";import"../chunk-p5r0t9jh.js";import"../chunk-xkrthw08.js";import"../chunk-4z53shav.js";import"../chunk-m0earq80.js";import"../chunk-f18weffa.js";export{b as prismaExtension,a as App};
 
 //# debugId=15EBDBCE0B2D702364756E2164756E21

package/dist/bin/gemi.js

@@ -50142,8 +50142,7 @@ class Store {
   req;
   cookies = new Set;
   headers = new Headers;
-  prefetchedResources = new Map;
-  prefetchPromiseQueue = new Set;
+  serverQueries = null;
   user = null;
   csrfHmac = null;
   locale = null;
@@ -50179,8 +50178,7 @@ class Store {
   destroy() {
     delete this.cookies;
     delete this.headers;
-    delete this.prefetchedResources;
-    delete this.prefetchPromiseQueue;
+    this.serverQueries = null;
     delete this.user;
   }
 }
@@ -51521,6 +51519,160 @@ class I18n {
 }
 // facades/FileStorage.ts
 import sharp from "sharp";
+// utils/omitNullishValues.ts
+function omitNullishValues(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+    return value !== null && value !== undefined;
+  }));
+}
+
+// services/router/ServerQueryStore.ts
+var LATE_DISCOVERY_THRESHOLD_MS = 50;
+
+class ServerQueryStore {
+  fetcher;
+  entries = new Map;
+  settleListener = null;
+  settledBacklog = [];
+  shipped = new Set;
+  requestStartedAt = performance.now();
+  renderStartedAt = null;
+  constructor(fetcher) {
+    this.fetcher = fetcher;
+  }
+  elapsed() {
+    return Math.round(performance.now() - this.requestStartedAt);
+  }
+  keyFor(path, variantKey) {
+    return [path, variantKey].filter((s2) => s2.length > 0).join("?");
+  }
+  markRenderStart() {
+    if (this.renderStartedAt === null) {
+      this.renderStartedAt = performance.now();
+    }
+  }
+  read(path, variantKey) {
+    return this.entries.get(this.keyFor(path, variantKey));
+  }
+  ensure(patternPath, options = {}, source = "render") {
+    const params = options.params ?? {};
+    const searchParams = new URLSearchParams(omitNullishValues(options.search ?? {}));
+    searchParams.delete("json");
+    searchParams.sort();
+    const path = applyParams(patternPath, params);
+    const variantKey = searchParams.toString();
+    const key = this.keyFor(path, variantKey);
+    const existing = this.entries.get(key);
+    if (existing)
+      return existing;
+    if (source === "render" && this.renderStartedAt !== null && true) {
+      const delay = Math.round(performance.now() - this.renderStartedAt);
+      if (delay > LATE_DISCOVERY_THRESHOLD_MS) {
+        const searchHint = variantKey ? `, { search: ${JSON.stringify(Object.fromEntries(searchParams))} }` : "";
+        console.warn(`[gemi] useQuery("${patternPath}") started ${delay}ms into the server render \u2014 ` + `it was discovered under a suspended segment, so its fetch could not overlap ` + `the others. It still streams, but \`Query.prefetch("${patternPath}"${searchHint})\` ` + `in the route's view handler would start it at request time.`);
+      }
+    }
+    let settle;
+    const promise = new Promise((resolve) => {
+      settle = resolve;
+    });
+    const entry = {
+      path,
+      variantKey,
+      status: "pending",
+      promise,
+      source,
+      startedAt: this.elapsed()
+    };
+    this.entries.set(key, entry);
+    this.fetcher(patternPath, params, searchParams).then((data) => {
+      entry.status = "resolved";
+      entry.data = data;
+    }, (error) => {
+      entry.status = "rejected";
+      entry.error = error;
+    }).then(() => {
+      entry.settledAt = this.elapsed();
+      if (this.settleListener) {
+        this.settleListener(entry);
+      } else {
+        this.settledBacklog.push(entry);
+      }
+      settle();
+    });
+    return entry;
+  }
+  async allSettled() {
+    let count = 0;
+    while (count !== this.entries.size) {
+      count = this.entries.size;
+      await Promise.all(Array.from(this.entries.values(), (e2) => e2.promise));
+    }
+  }
+  snapshotResolved() {
+    const snapshot = {};
+    for (const [key, entry] of this.entries) {
+      if (entry.status !== "resolved")
+        continue;
+      this.shipped.add(key);
+      snapshot[entry.path] ??= {};
+      snapshot[entry.path][entry.variantKey] = entry.data;
+    }
+    return snapshot;
+  }
+  onSettle(listener) {
+    this.settleListener = (entry) => {
+      if (this.shipped.has(this.keyFor(entry.path, entry.variantKey)))
+        return;
+      listener(entry);
+    };
+    const backlog = this.settledBacklog;
+    this.settledBacklog = [];
+    for (const entry of backlog) {
+      this.settleListener(entry);
+    }
+  }
+}
+
+// client/QueryError.ts
+class QueryError extends Error {
+  path;
+  variantKey;
+  status;
+  body;
+  constructor(path, variantKey, status, body) {
+    super(typeof body?.message === "string" ? body.message : `Request to /api${path} failed with status ${status}`);
+    this.path = path;
+    this.variantKey = variantKey;
+    this.status = status;
+    this.body = body;
+    this.name = "QueryError";
+  }
+}
+
+// services/router/serverQueryFetcher.ts
+function createServerQueryFetcher(req) {
+  const kernelStore = kernelContext.getStore();
+  return (patternPath, params, searchParams) => {
+    const origin = new URL(req.url).origin;
+    const pathnameWithSearch = [applyParams(patternPath, params), searchParams.toString()].filter((s2) => s2.length > 0).join("?");
+    const newReq = new Request(`${origin}/${pathnameWithSearch}`, {
+      headers: req.headers
+    });
+    const httpRequest = new HttpRequest(newReq, params);
+    return kernelContext.run(kernelStore, () => RequestContext.run(httpRequest, async () => {
+      const data = await ApiRouterServiceContainer.use().getRouteData(patternPath);
+      if (data instanceof Response) {
+        const body = await data.json().catch(() => null);
+        if (!data.ok) {
+          throw new QueryError(applyParams(patternPath, params), searchParams.toString(), data.status, body);
+        }
+        return body;
+      }
+      return data;
+    }));
+  };
+}
 // services/logging/LoggingServiceContainer.ts
 import { mkdir, readdir, access } from "fs/promises";
 async function exists(path) {
@@ -68327,7 +68479,60 @@ class KernelIdServiceContainer extends ServiceContainer {
   }
 }
 
+// services/router/streamQueryInjection.ts
+function htmlSafeJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function queryPayloadScript(entry) {
+  const payload = htmlSafeJson([entry.path, entry.variantKey, entry.data]);
+  return `<script>(self.__GEMI_STREAM__=self.__GEMI_STREAM__||[]).push(${payload})</script>`;
+}
+function injectQueryPayloads(source, store) {
+  const encoder = new TextEncoder;
+  const queue = [];
+  let sentFirstChunk = false;
+  store.onSettle((entry) => {
+    if (entry.status !== "resolved")
+      return;
+    queue.push(queryPayloadScript(entry));
+  });
+  const reader = source.getReader();
+  const flush = (controller) => {
+    while (queue.length > 0) {
+      controller.enqueue(encoder.encode(queue.shift()));
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await reader.read();
+      if (done) {
+        flush(controller);
+        controller.close();
+        return;
+      }
+      if (!sentFirstChunk) {
+        sentFirstChunk = true;
+        controller.enqueue(value);
+        flush(controller);
+        return;
+      }
+      flush(controller);
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+}
+var BOT_UA = /bot|crawler|spider|crawling|slurp|bingpreview|mediapartners|headless|lighthouse|prerender|facebookexternalhit|whatsapp|telegram|discord|twitterbot|linkedinbot/i;
+function isBotUserAgent(userAgent) {
+  if (!userAgent)
+    return false;
+  return BOT_UA.test(userAgent);
+}
+
 // services/router/ViewRouterServiceContainer.ts
+var STREAM_DEADLINE_MS = 1e4;
 var themeScript = `
 !function(){try{var d=document.documentElement,c=d.classList;
 c.remove('light','dark');
@@ -68404,7 +68609,8 @@ class ViewRouterServiceContainer extends ServiceContainer {
       i18n,
       params,
       pathname,
-      prefetchedData,
+      serverQueries,
+      userAgent,
       url,
       user,
       viewData,
@@ -68423,7 +68629,7 @@ class ViewRouterServiceContainer extends ServiceContainer {
           [pageDataKey]: viewData
         },
         __csrf: csrfTokenHMAC.toString("base64"),
-        prefetchedData,
+        prefetchedData: {},
         i18n,
         auth: { user },
         routeManifest: this.clientRouteManifest,
@@ -68444,7 +68650,15 @@ class ViewRouterServiceContainer extends ServiceContainer {
     const Root = this.root;
     const currentViews = this.routeManifest[currentPathName];
     return async (params2) => {
-      const { bootstrapModules, loaders, getStyles, viewImportMap, cssManifest, ogMap } = params2;
+      const {
+        bootstrapModules,
+        loaders,
+        getStyles,
+        viewImportMap,
+        cssManifest,
+        ogMap,
+        viewModules
+      } = params2;
       if (isOgRequest) {
         let ogHandler = null;
         let ogComponent = null;
@@ -68483,6 +68697,10 @@ class ViewRouterServiceContainer extends ServiceContainer {
       }
       result.data["cssManifest"] = cssManifest;
       const styles = await getStyles(currentViews);
+      result.data.prefetchedData = serverQueries.snapshotResolved();
+      serverQueries.markRenderStart();
+      const deadline = new AbortController;
+      const deadlineTimer = setTimeout(() => deadline.abort(), STREAM_DEADLINE_MS);
       try {
         const stream = await renderToReadableStream(import_react.createElement(import_react.Fragment, {
           children: [
@@ -68496,18 +68714,31 @@ class ViewRouterServiceContainer extends ServiceContainer {
             import_react.createElement(Root, {
               data: result.data,
               viewImportMap,
+              viewModules,
+              serverQueries,
               key: "root"
             })
           ]
         }), {
           bootstrapScriptContent: `window.__GEMI_DATA__ = ${JSON.stringify(result.data)}; window.loaders=${loaders}`,
-          bootstrapModules
+          bootstrapModules,
+          signal: deadline.signal,
+          onError(error) {
+            if (true) {
+              console.error(error);
+            }
+          }
         });
-        return new Response(stream, {
+        stream.allReady.catch(() => {}).finally(() => clearTimeout(deadlineTimer));
+        if (isBotUserAgent(userAgent)) {
+          await stream.allReady.catch(() => {});
+        }
+        return new Response(injectQueryPayloads(stream, serverQueries), {
           status: !currentPathName ? 404 : 200,
           headers
         });
       } catch (err2) {
+        clearTimeout(deadlineTimer);
         const stream = await renderToReadableStream(import_react.createElement("div"), {
           bootstrapScriptContent: `window.error= ${JSON.stringify(err2.message)}; window.stack_trace=${JSON.stringify(err2.stack)};window.__GEMI_DATA__ = ${JSON.stringify(result.data)}; window.loaders=${loaders}`,
           bootstrapModules: ["/render-error.js", ...bootstrapModules]
@@ -68584,6 +68815,7 @@ class ViewRouterServiceContainer extends ServiceContainer {
     return await RequestContext.run(httpRequest, async () => {
       let pageData = null;
       const ctx = RequestContext.getStore();
+      ctx.serverQueries = new ServerQueryStore(createServerQueryFetcher(req));
       if (urlLocale) {
         const locale = urlLocale.replaceAll("/", "");
         I18n.setLocale(locale);
@@ -68615,21 +68847,18 @@ class ViewRouterServiceContainer extends ServiceContainer {
             defaultLocale: i18nServiceContainer2.service.defaultLocale
           };
         }
-        const handlerPromises = handlers.map((fn2) => fn2(httpRequest2));
-        const prefetchPromises = Array.from(ctx.prefetchPromiseQueue).map((fn2) => fn2());
-        const [data] = await Promise.all([
-          Promise.all(handlerPromises),
-          Promise.all(prefetchPromises)
-        ]);
+        const data = await Promise.all(handlers.map((fn2) => fn2(httpRequest2)));
+        if (isViewDataRequest) {
+          await ctx.serverQueries.allSettled();
+        }
         const cookies = ctx.cookies;
         const headers = ctx.headers;
-        const prefetchedResources = ctx.prefetchedResources;
         pageData = {
           data,
           cookies,
           headers,
           user: ctx.user,
-          prefetchedData: Object.fromEntries(prefetchedResources.entries()),
+          prefetchedData: ctx.serverQueries.snapshotResolved(),
           currentPathName: httpRequest2.routePath,
           params: httpRequest2.params,
           urlLocaleSegment,
@@ -68701,7 +68930,8 @@ class ViewRouterServiceContainer extends ServiceContainer {
           i18n,
           params: params2,
           pathname: url.pathname,
-          prefetchedData: pageData.prefetchedData,
+          serverQueries: ctx.serverQueries,
+          userAgent: req.headers.get("user-agent"),
           url,
           user,
           viewData,
@@ -69749,5 +69979,5 @@ program.command("app:route-manifest").action(async () => {
 });
 program.parse();
 
-//# debugId=971DE98EAA769ECD64756E2164756E21
+//# debugId=8FF3EC642A31F68D64756E2164756E21
 //# sourceMappingURL=gemi.js.map