@rpcbase/server 0.508.0 → 0.510.0

package/dist/index.js

@@ -4,7 +4,7 @@ import MongoStore from "connect-mongo";
 import { createClient } from "redis";
 import { MongoClient } from "mongodb";
 import env from "@rpcbase/env";
-import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
+import { initApiClient, STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY, RtsSsrRuntimeProvider, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
 import { dirname, posix, sep } from "path";
 import fs, { createReadStream, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
@@ -16,11 +16,12 @@ import fsPromises from "node:fs/promises";
 import inspector from "node:inspector";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Transform } from "node:stream";
+import { Writable, Transform } from "node:stream";
 import { StrictMode, createElement } from "react";
 import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
 import { jsx } from "react/jsx-runtime";
 import { createPath, matchRoutes, parsePath, createStaticRouter, StaticRouterProvider } from "@rpcbase/router";
+import { r as resolveRtsRequestTenantId, i as isRtsRequestAuthorized, b as buildRtsAbilityFromRequest, n as normalizeRtsQueryOptions, a as runRtsQuery } from "./queryExecutor-Xh88REQn.js";
 import { s } from "./email-DEw8keax.js";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -4423,6 +4424,142 @@ async function applyRouteLoaders(req, dataRoutes) {
     statusCode
   };
 }
+const DEFAULT_MAX_QUERIES = 32;
+const DEFAULT_MAX_DOCS_PER_QUERY = 500;
+const DEFAULT_MAX_SERIALIZED_BYTES = 200 * 1024;
+const makeRegistrationKey = (modelName, queryKey) => `${modelName}.${queryKey}`;
+const hasSessionUser = (req) => {
+  const id = req.session?.user?.id;
+  return typeof id === "string" && id.trim().length > 0;
+};
+const escapeForInlineScript = (value) => {
+  return value.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+};
+const createRtsSsrCollector = (req, opts) => {
+  const maxQueries = DEFAULT_MAX_QUERIES;
+  const maxDocsPerQuery = DEFAULT_MAX_DOCS_PER_QUERY;
+  const maxSerializedBytes = DEFAULT_MAX_SERIALIZED_BYTES;
+  const registrations = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  const runtime = {
+    registerQuery(query) {
+      const modelName = typeof query.modelName === "string" ? query.modelName.trim() : "";
+      const queryKey = typeof query.queryKey === "string" ? query.queryKey.trim() : "";
+      if (!modelName || !queryKey) return;
+      const key = makeRegistrationKey(modelName, queryKey);
+      if (registrations.has(key)) return;
+      if (registrations.size >= maxQueries) return;
+      registrations.set(key, {
+        modelName,
+        queryKey,
+        query: query.query ?? {},
+        options: query.options ?? {}
+      });
+    },
+    getQueryData(modelName, queryKey) {
+      return resolved.get(makeRegistrationKey(modelName, queryKey));
+    }
+  };
+  const resolve = async () => {
+    if (!registrations.size) return null;
+    const tenantId = resolveRtsRequestTenantId(req);
+    if (!tenantId) return null;
+    if (hasSessionUser(req) && !isRtsRequestAuthorized(req, tenantId)) {
+      return null;
+    }
+    const { ability, userId } = await buildRtsAbilityFromRequest(req, tenantId);
+    const queryEntries = [];
+    for (const registration of registrations.values()) {
+      const options = normalizeRtsQueryOptions(registration.options);
+      try {
+        const data = await runRtsQuery({
+          tenantId,
+          ability,
+          modelName: registration.modelName,
+          query: registration.query,
+          options
+        });
+        const boundedData = maxDocsPerQuery > 0 ? data.slice(0, maxDocsPerQuery) : data;
+        queryEntries.push({
+          modelName: registration.modelName,
+          queryKey: registration.queryKey,
+          data: boundedData
+        });
+      } catch {
+        continue;
+      }
+    }
+    if (!queryEntries.length) return null;
+    const payload = {
+      v: 1,
+      tenantId,
+      uid: userId,
+      queries: []
+    };
+    for (const entry of queryEntries) {
+      payload.queries.push(entry);
+      const bytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+      if (bytes > maxSerializedBytes) {
+        payload.queries.pop();
+        break;
+      }
+    }
+    resolved.clear();
+    for (const entry of payload.queries) {
+      resolved.set(makeRegistrationKey(entry.modelName, entry.queryKey), entry.data);
+    }
+    return payload.queries.length ? payload : null;
+  };
+  const hasRegistrations = () => registrations.size > 0;
+  return { runtime, hasRegistrations, resolve };
+};
+const renderRtsHydrationScript = (data) => {
+  if (!data) return "";
+  const serialized = escapeForInlineScript(JSON.stringify(data));
+  return `<script>window.${STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY}=${serialized};<\/script>`;
+};
+const RTS_SSR_PREPASS_TIMEOUT_MS = 4e3;
+const runRtsPrepass = async (element) => {
+  return await new Promise((resolve) => {
+    let isDone = false;
+    let timeoutId = null;
+    const finish = (ok) => {
+      if (isDone) return;
+      isDone = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(ok);
+    };
+    const sink = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    sink.on("finish", () => {
+      finish(true);
+    });
+    sink.on("error", () => {
+      finish(false);
+    });
+    const { pipe, abort } = renderToPipeableStream(element, {
+      onAllReady() {
+        if (isDone) return;
+        pipe(sink);
+      },
+      onShellError() {
+        finish(false);
+        abort();
+      },
+      onError() {
+      }
+    });
+    timeoutId = setTimeout(() => {
+      abort();
+      finish(false);
+    }, RTS_SSR_PREPASS_TIMEOUT_MS);
+  });
+};
 async function renderSSR(req, dataRoutes) {
   const routerContext = await applyRouteLoaders(req, dataRoutes);
   const isMatched = routerContext.matches.length > 0;
@@ -4433,7 +4570,8 @@ async function renderSSR(req, dataRoutes) {
       statusCode: routerContext.statusCode ?? routerContext.redirectResponse.status ?? 302,
       redirectResponse: routerContext.redirectResponse,
       redirectRouteId: routerContext.redirectRouteId,
-      redirectRoutePath: routerContext.redirectRoutePath
+      redirectRoutePath: routerContext.redirectRoutePath,
+      rtsHydrationData: null
     };
   }
   if (routerContext.errors) {
@@ -4468,18 +4606,34 @@ async function renderSSR(req, dataRoutes) {
       throw error;
     }
   }
-  const router = createStaticRouter(dataRoutes, routerContext);
-  const element = /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(
-    StaticRouterProvider,
-    {
-      router,
-      context: routerContext
+  const buildElement = (runtime2) => {
+    const router = createStaticRouter(dataRoutes, routerContext);
+    const app = /* @__PURE__ */ jsx(
+      StaticRouterProvider,
+      {
+        router,
+        context: routerContext
+      }
+    );
+    return /* @__PURE__ */ jsx(StrictMode, { children: runtime2 ? /* @__PURE__ */ jsx(RtsSsrRuntimeProvider, { value: runtime2, children: app }) : app });
+  };
+  const tenantId = resolveRtsRequestTenantId(req);
+  let rtsHydrationData = null;
+  let runtime = null;
+  if (tenantId) {
+    const collector = createRtsSsrCollector(req);
+    const prepassOk = await runRtsPrepass(buildElement(collector.runtime));
+    if (prepassOk && collector.hasRegistrations()) {
+      rtsHydrationData = await collector.resolve();
     }
-  ) });
+    runtime = collector.runtime;
+  }
+  const element = buildElement(runtime);
   return {
     element,
     isMatched,
-    statusCode: routerContext.statusCode ?? (routerContext.errors ? 500 : 200)
+    statusCode: routerContext.statusCode ?? (routerContext.errors ? 500 : 200),
+    rtsHydrationData
   };
 }
 const ABORT_DELAY_MS = 1e4;
@@ -4630,6 +4784,7 @@ const ssrMiddleware = ({
       element,
       isMatched,
       statusCode,
+      rtsHydrationData,
       redirectResponse,
       redirectRouteId,
       redirectRoutePath
@@ -4697,9 +4852,10 @@ const ssrMiddleware = ({
           });
           const start = htmlStart;
           const end = htmlEnd;
+          const rtsHydrationScript = renderRtsHydrationScript(rtsHydrationData);
           res.write(start);
           transformStream.on("finish", () => {
-            res.end(end);
+            res.end(`${rtsHydrationScript}${end}`);
           });
           pipe(transformStream);
         }