one 1.12.5 → 1.12.6

package/dist/cjs/server/workerHandler.cjs

@@ -0,0 +1,492 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var workerHandler_exports = {};
+__export(workerHandler_exports, {
+  createWorkerHandler: () => createWorkerHandler
+});
+module.exports = __toCommonJS(workerHandler_exports);
+var import_constants = require("../constants.cjs"),
+  import_createHandleRequest = require("../createHandleRequest.cjs"),
+  import_cleanUrl = require("../utils/cleanUrl.cjs"),
+  import_isResponse = require("../utils/isResponse.cjs"),
+  import_resolveResponse = require("../vite/resolveResponse.cjs"),
+  import_ssrLoaderData = require("./ssrLoaderData.cjs"),
+  import_staticHtmlFetcher = require("./staticHtmlFetcher.cjs");
+function createWorkerHandler(options) {
+  const {
+    oneOptions
+  } = options;
+  let currentLazyRoutes = options.lazyRoutes,
+    compiledManifest = (0, import_createHandleRequest.compileManifest)(options.buildInfo.manifest),
+    routeToBuildInfo = options.buildInfo.routeToBuildInfo,
+    routeMap = options.buildInfo.routeMap,
+    currentPreloads = options.buildInfo.preloads,
+    currentCssPreloads = options.buildInfo.cssPreloads;
+  const debugRouter = process.env.ONE_DEBUG_ROUTER,
+    redirects = oneOptions.web?.redirects;
+  let compiledRedirects = null;
+  redirects?.length && (compiledRedirects = redirects.map(r => {
+    const regexSource = r.source.replace(/:(\w+)/g, (_, name) => `(?<${name}>[^/]+)`);
+    return {
+      regex: new RegExp(`^${regexSource}$`),
+      destination: r.destination,
+      permanent: r.permanent || !1
+    };
+  }));
+  const useStreaming = !process.env.ONE_BUFFERED_SSR,
+    htmlHeaders = {
+      "content-type": "text/html"
+    },
+    ssrHtmlHeaders = {
+      "content-type": "text/html",
+      "cache-control": "no-cache"
+    },
+    loaderCache = /* @__PURE__ */new Map(),
+    moduleImportCache = /* @__PURE__ */new Map(),
+    loaderCacheFnMap = /* @__PURE__ */new Map(),
+    pendingLoaderResults = /* @__PURE__ */new Map();
+  let render = null,
+    renderStream = null,
+    renderLoading = null,
+    renderGeneration = 0;
+  function ensureRenderLoaded() {
+    if (render) return;
+    if (renderLoading) return renderLoading;
+    const gen = ++renderGeneration;
+    return renderLoading = (async () => {
+      const entry = await currentLazyRoutes.serverEntry();
+      gen === renderGeneration && (render = entry.default.render, renderStream = entry.default.renderStream || null);
+    })(), renderLoading;
+  }
+  function findNearestNotFoundPath(urlPath) {
+    let cur = urlPath;
+    for (; cur;) {
+      const parent = cur.lastIndexOf("/") > 0 ? cur.slice(0, cur.lastIndexOf("/")) : "";
+      if (routeMap[`${parent}/+not-found`]) return `${parent}/+not-found`;
+      if (!parent) break;
+      cur = parent;
+    }
+    return "/+not-found";
+  }
+  function make404LoaderJs(path, logReason) {
+    const nfPath = findNearestNotFoundPath(path);
+    return logReason && console.error(`[one] 404 loader for ${path}: ${logReason}`), `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
+  }
+  async function readStaticHtml(htmlPath) {
+    const fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
+    return fetchStaticHtml ? await fetchStaticHtml(htmlPath) : (debugRouter && console.warn(`[one/worker] no fetchStaticHtml set, cannot read ${htmlPath}`), null);
+  }
+  function resolveLoaderSync(lazyKey) {
+    const cacheKey = lazyKey || "",
+      cached = loaderCache.get(cacheKey);
+    return cached !== void 0 ? cached : (async () => {
+      let routeExported;
+      if (moduleImportCache.has(cacheKey)) routeExported = moduleImportCache.get(cacheKey);else if (lazyKey && currentLazyRoutes.pages[lazyKey]) routeExported = await currentLazyRoutes.pages[lazyKey](), moduleImportCache.set(cacheKey, routeExported);else return console.warn(`[one/worker] no lazy route for ${cacheKey}`), loaderCache.set(cacheKey, null), null;
+      const loader = routeExported?.loader || null;
+      return loaderCache.set(cacheKey, loader), loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null), loader;
+    })();
+  }
+  async function importAndRunLoader(routeId, lazyKey, loaderProps) {
+    if (!lazyKey) return {
+      loaderData: void 0,
+      routeId
+    };
+    const cacheMapKey = lazyKey,
+      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
+    let coalFullKey,
+      coalTtl = 0;
+    if (loaderCacheFn) {
+      const cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request),
+        cacheKey = typeof cacheResult == "string" ? cacheResult : cacheResult?.key;
+      if (coalTtl = typeof cacheResult == "string" ? 0 : cacheResult?.ttl ?? 0, cacheKey != null) {
+        coalFullKey = routeId + "\0" + cacheKey;
+        const existing = pendingLoaderResults.get(coalFullKey);
+        if (existing && (!existing.expires || Date.now() < existing.expires)) return {
+          loaderData: await existing.promise,
+          routeId
+        };
+      }
+    }
+    try {
+      const loaderOrPromise = resolveLoaderSync(lazyKey),
+        loader = loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) return {
+        loaderData: void 0,
+        routeId
+      };
+      if (coalFullKey) {
+        const promise = loader(loaderProps),
+          entry = {
+            promise,
+            expires: 0
+          };
+        return pendingLoaderResults.set(coalFullKey, entry), promise.then(() => {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0, coalTtl <= 0 && Promise.resolve().then(() => pendingLoaderResults.delete(coalFullKey));
+        }, () => pendingLoaderResults.delete(coalFullKey)), {
+          loaderData: await promise,
+          routeId
+        };
+      }
+      return {
+        loaderData: await loader(loaderProps),
+        routeId
+      };
+    } catch (err) {
+      if ((0, import_isResponse.isResponse)(err)) throw err;
+      return err?.code === "ENOENT" ? {
+        loaderData: void 0,
+        routeId,
+        isEnoent: !0
+      } : (console.error(`[one] Error running loader for ${routeId}:`, err), {
+        loaderData: void 0,
+        routeId
+      });
+    }
+  }
+  const requestHandlers = {
+    async handleStaticFile() {
+      return null;
+    },
+    async handleAPI({
+      route
+    }) {
+      return currentLazyRoutes.api[route.page] ? await currentLazyRoutes.api[route.page]() : (console.warn(`[one/worker] no lazy API route for ${route.page}`), null);
+    },
+    async loadMiddleware(route) {
+      return currentLazyRoutes.middlewares[route.contextKey] ? await currentLazyRoutes.middlewares[route.contextKey]() : (console.warn(`[one/worker] no lazy middleware for ${route.contextKey}`), null);
+    },
+    async handleLoader({
+      route,
+      loaderProps
+    }) {
+      const routeFile = route.routeFile || route.file;
+      let loader;
+      try {
+        const loaderResult = resolveLoaderSync(routeFile);
+        loader = loaderResult instanceof Promise ? await loaderResult : loaderResult;
+      } catch (err) {
+        if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
+        throw err;
+      }
+      if (!loader) return null;
+      let json;
+      try {
+        json = await loader(loaderProps);
+      } catch (err) {
+        if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+        throw err;
+      }
+      if ((0, import_isResponse.isResponse)(json)) throw json;
+      return `export function loader() { return ${JSON.stringify(json)} }`;
+    },
+    async handlePage({
+      route,
+      url,
+      loaderProps
+    }) {
+      const routeBuildInfo = routeToBuildInfo[route.file];
+      if (route.type === "ssr") {
+        if (!routeBuildInfo) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
+  ${Object.keys(routeToBuildInfo).join(`
+  `)}`);
+        try {
+          const layoutRoutes = route.layouts || [],
+            layoutLoaderPromises = [],
+            noLoaderResults = [];
+          for (const layout of layoutRoutes) {
+            const cacheKey = layout.contextKey || "";
+            loaderCache.get(cacheKey) === null ? noLoaderResults.push({
+              loaderData: void 0,
+              routeId: layout.contextKey
+            }) : layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps));
+          }
+          const pageLoaderPromise = importAndRunLoader(route.file, route.file, loaderProps);
+          let layoutResults, pageResult;
+          try {
+            if (layoutLoaderPromises.length === 0) layoutResults = noLoaderResults, pageResult = await pageLoaderPromise;else {
+              const [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults], pageResult = pr;
+            }
+          } catch (err) {
+            if ((0, import_isResponse.isResponse)(err)) return err;
+            throw err;
+          }
+          if (pageResult.isEnoent) {
+            const nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
+              nfHtml = routeMap[nfPath];
+            if (nfHtml) {
+              const html = await readStaticHtml(nfHtml);
+              if (html) return new Response(html, {
+                headers: {
+                  "content-type": "text/html"
+                },
+                status: 404
+              });
+            }
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
+          const matchPathname = loaderProps?.path || "/",
+            matchParams = loaderProps?.params || {},
+            matches = new Array(layoutResults.length + 1);
+          for (let i = 0; i < layoutResults.length; i++) {
+            const result = layoutResults[i];
+            matches[i] = {
+              routeId: result.routeId,
+              pathname: matchPathname,
+              params: matchParams,
+              loaderData: result.loaderData
+            };
+          }
+          matches[layoutResults.length] = {
+            routeId: pageResult.routeId,
+            pathname: matchPathname,
+            params: matchParams,
+            loaderData: pageResult.loaderData
+          };
+          const loaderData = pageResult.loaderData;
+          for (const layout of layoutRoutes) {
+            const key = layout.contextKey,
+              loaderFn = loaderCache.get(key);
+            if (loaderFn) {
+              const result = layoutResults.find(r => r.routeId === key);
+              result && (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result.loaderData);
+            }
+          }
+          const pageLoaderFn = loaderCache.get(route.file);
+          pageLoaderFn && (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData), globalThis.__vxrnresetState?.();
+          const renderProps = {
+              mode: route.type,
+              loaderData,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: routeBuildInfo.criticalPreloads || routeBuildInfo.preloads,
+              deferredPreloads: routeBuildInfo.deferredPreloads,
+              css: routeBuildInfo.css,
+              cssContents: routeBuildInfo.cssContents,
+              matches
+            },
+            _rl = ensureRenderLoaded();
+          _rl && (await _rl);
+          const status = route.isNotFound ? 404 : 200,
+            responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
+          if (useStreaming) {
+            const stream = await renderStream(renderProps);
+            return new Response(stream, {
+              headers: responseHeaders,
+              status
+            });
+          }
+          const rendered = await render(renderProps);
+          return new Response(rendered, {
+            headers: responseHeaders,
+            status
+          });
+        } catch (err) {
+          return (0, import_isResponse.isResponse)(err) ? err : (console.error(`[one] Error rendering SSR route ${route.file}
+${err?.stack ?? err}
+url: ${url}`), null);
+        }
+      } else {
+        const layoutRoutes = route.layouts || [];
+        if (route.type === "spa" && layoutRoutes.some(layout => layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr")) try {
+          const matches = (await Promise.all(layoutRoutes.map(layout => importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps)))).map(result => ({
+            routeId: result.routeId,
+            pathname: loaderProps?.path || "/",
+            params: loaderProps?.params || {},
+            loaderData: result.loaderData
+          }));
+          globalThis.__vxrnresetState?.();
+          const _rl = ensureRenderLoaded();
+          _rl && (await _rl);
+          const spaRouteBuildInfo = routeToBuildInfo[route.file],
+            rendered = await render({
+              mode: "spa-shell",
+              loaderData: void 0,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: spaRouteBuildInfo?.criticalPreloads || spaRouteBuildInfo?.preloads,
+              deferredPreloads: spaRouteBuildInfo?.deferredPreloads,
+              css: spaRouteBuildInfo?.css,
+              cssContents: spaRouteBuildInfo?.cssContents,
+              matches
+            });
+          return new Response(rendered, {
+            headers: htmlHeaders,
+            status: route.isNotFound ? 404 : 200
+          });
+        } catch (err) {
+          if ((0, import_isResponse.isResponse)(err)) return err;
+          console.error(`[one] Error rendering spa-shell for ${route.file}
+${err?.stack ?? err}
+url: ${url}`);
+        }
+        const isDynamicRoute = Object.keys(route.routeKeys).length > 0,
+          routeCleanPath = route.urlCleanPath.replace(/\?/g, ""),
+          notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
+          htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[routeBuildInfo?.cleanPath];
+        if (htmlPath) {
+          const html = await readStaticHtml(htmlPath);
+          if (html) return new Response(html, {
+            headers: htmlHeaders,
+            status: route.isNotFound ? 404 : 200
+          });
+        }
+        if (isDynamicRoute) {
+          const notFoundRoute = findNearestNotFoundPath(url.pathname),
+            notFoundHtmlPath = routeMap[notFoundRoute];
+          if (notFoundHtmlPath) {
+            const notFoundHtml = await readStaticHtml(notFoundHtmlPath);
+            if (notFoundHtml) {
+              const notFoundMarker = `<script>window.__one404=${JSON.stringify({
+                  originalPath: url.pathname,
+                  notFoundPath: notFoundRoute
+                })}</script>`,
+                injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
+              return new Response(injectedHtml, {
+                headers: htmlHeaders,
+                status: 404
+              });
+            }
+          }
+          return new Response("404 Not Found", {
+            status: 404
+          });
+        }
+        return null;
+      }
+    }
+  };
+  function setCacheHeaders(response, route, isAPI) {
+    if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) try {
+      isAPI ? response.headers.set("cache-control", "no-store") : route.type === "ssg" || route.type === "spa" ? response.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120") : response.headers.set("cache-control", "no-cache");
+    } catch {}
+    return response;
+  }
+  async function handleRequest(request) {
+    const url = (0, import_createHandleRequest.getURLfromRequestURL)(request),
+      pathname = url.pathname,
+      method = request.method;
+    if (compiledRedirects) for (const redirect of compiledRedirects) {
+      const match = redirect.regex.exec(pathname);
+      if (match) {
+        let destination = redirect.destination;
+        if (match.groups) for (const [name, value] of Object.entries(match.groups)) destination = destination.replace(`:${name}`, value);
+        return debugRouter && console.info(`[one] \u21AA redirect ${pathname} \u2192 ${destination}`), new Response(null, {
+          status: redirect.permanent ? 301 : 302,
+          headers: {
+            location: new URL(destination, url.origin).toString()
+          }
+        });
+      }
+    }
+    if (pathname.endsWith(import_constants.PRELOAD_JS_POSTFIX)) return currentPreloads[pathname] ? null : new Response("", {
+      headers: {
+        "Content-Type": "text/javascript"
+      }
+    });
+    if (pathname.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) return currentCssPreloads?.[pathname] ? null : new Response("export default Promise.resolve()", {
+      headers: {
+        "Content-Type": "text/javascript"
+      }
+    });
+    if (pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+      const originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
+      for (const route of compiledManifest.pageRoutes) {
+        if (route.file === "" || !route.compiledRegex.test(originalUrl)) continue;
+        if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
+          headers: {
+            "Content-Type": "text/javascript"
+          }
+        });
+        const loaderRoute = {
+            ...route,
+            routeFile: route.file,
+            file: route.loaderServerPath || pathname
+          },
+          finalUrl = new URL(originalUrl, url.origin);
+        finalUrl.search = url.search;
+        const cleanedRequest = new Request(finalUrl, request);
+        try {
+          return await (0, import_createHandleRequest.resolveLoaderRoute)(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
+        } catch (err) {
+          return err?.code === "ERR_MODULE_NOT_FOUND" ? new Response("export function loader() { return undefined }", {
+            headers: {
+              "Content-Type": "text/javascript"
+            }
+          }) : (console.error(`Error running loader: ${err}`), null);
+        }
+      }
+      return null;
+    }
+    if (pathname.endsWith(".js") || pathname.endsWith(".css")) return null;
+    for (const route of compiledManifest.apiRoutes) if (route.compiledRegex.test(pathname)) {
+      debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${route.page}`);
+      const response = await (0, import_createHandleRequest.resolveAPIRoute)(requestHandlers, request, url, route);
+      return response && (0, import_isResponse.isResponse)(response) ? setCacheHeaders(response, route, !0) : null;
+    }
+    if (method === "GET") {
+      for (const route of compiledManifest.pageRoutes) if (route.compiledRegex.test(pathname)) {
+        if (debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`), route.type === "ssr" && !route.middlewares?.length) {
+          const params = {},
+            match = route.compiledRegex.exec(pathname);
+          if (match?.groups) for (const [key, value] of Object.entries(match.groups)) params[route.routeKeys[key]] = value;
+          const loaderProps = {
+              path: pathname,
+              search: url.search,
+              request,
+              params
+            },
+            response = await (0, import_resolveResponse.withRequestContext)(async () => {
+              try {
+                return await requestHandlers.handlePage({
+                  request,
+                  route,
+                  url,
+                  loaderProps
+                });
+              } catch (err) {
+                if ((0, import_isResponse.isResponse)(err)) return err;
+                throw err;
+              }
+            });
+          return response && (0, import_isResponse.isResponse)(response) ? setCacheHeaders(response, route, !1) : null;
+        }
+        try {
+          const response = await (0, import_createHandleRequest.resolvePageRoute)(requestHandlers, request, url, route);
+          if (response && (0, import_isResponse.isResponse)(response)) return setCacheHeaders(response, route, !1);
+        } catch (err) {
+          console.error(` [one] Error handling request: ${err.stack}`);
+        }
+        return null;
+      }
+    }
+    return null;
+  }
+  function updateRoutes(newBuildInfo, newLazyRoutes) {
+    compiledManifest = (0, import_createHandleRequest.compileManifest)(newBuildInfo.manifest), routeToBuildInfo = newBuildInfo.routeToBuildInfo, routeMap = newBuildInfo.routeMap, currentPreloads = newBuildInfo.preloads, currentCssPreloads = newBuildInfo.cssPreloads, newLazyRoutes && (currentLazyRoutes = newLazyRoutes), loaderCache.clear(), moduleImportCache.clear(), loaderCacheFnMap.clear(), pendingLoaderResults.clear(), render = null, renderStream = null, renderLoading = null;
+  }
+  return {
+    handleRequest,
+    updateRoutes
+  };
+}