@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/runtime-package-resolution.mjs

@@ -0,0 +1,61 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = node_path.resolve(fromDirectory);
+    for(;;){
+        const candidate = node_path.join(directory, 'node_modules');
+        if (node_fs.existsSync(node_path.join(candidate, packageName))) return candidate;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = node_path.dirname(fileURLToPath(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        createRequire(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+export { canResolveRuntimePackage, collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin, findHostingModuleDirectory };

package/dist/esm-node/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -24,9 +24,6 @@ const ASSET_CORS_HEADERS = {
   'access-control-allow-origin': '*',
 };
 
-globalThis.__dirname ??= '/';
-globalThis.__filename ??= '/index.js';
-
 function getAllowedAppCorsOrigin(request) {
   if (APP_CORS_ALLOWED_ORIGINS.length === 0) {
     return null;

package/dist/esm-node/templates/cloudflare-entry.002-assets-routes.mjs

@@ -20,7 +20,7 @@ function withAssetHeaders(response, request) {
   });
 }
 
-async function createCorsPreflightResponse(request, env) {
+async function createCorsPreflightResponse(request, _env) {
   if (request.method !== 'OPTIONS') {
     return null;
   }

package/dist/esm-node/templates/cloudflare-entry.004-rendering-css.mjs

@@ -2,9 +2,13 @@ function createNoopMonitors() {
   const noop = () => {};
 
   return {
+    counter: noop,
     debug: noop,
     error: noop,
     info: noop,
+    push: noop,
+    timing: noop,
+    trace: noop,
     warn: noop,
   };
 }
@@ -1134,7 +1138,7 @@ async function withRouteCssLinks(
     seenCssHrefs.add(entry.preloadHref);
     return true;
   });
-  for (const { href, preloadHref } of uniqueCssEntries) {
+  for (const { preloadHref } of uniqueCssEntries) {
     const preloadUrl = new URL(preloadHref);
     const preloadReference =
       preloadUrl.origin === requestOrigin

package/dist/esm-node/templates/cloudflare-entry.005-worker-dispatch.mjs

@@ -52,6 +52,52 @@ async function getRequestHandler(workerModule) {
   );
 }
 
+const ROUTE_DATA_REQUEST_PARAM = '__loader';
+
+// Route data requests (`?__loader=`) are answered by the entry's route data
+// worker, like the Node server's data handler. Without a match the request
+// falls through to page rendering, as it does on Node.
+async function dispatchRouteDataRequest(route, request) {
+  const routeDataWorkerPath = route.routeDataWorker;
+  if (
+    !routeDataWorkerPath ||
+    !new URL(request.url).searchParams.has(ROUTE_DATA_REQUEST_PARAM)
+  ) {
+    return undefined;
+  }
+
+  const routeDataWorkerModule = await loadWorkerModule(routeDataWorkerPath);
+  const handleRouteDataRequest = routeDataWorkerModule
+    ? getRuntimeModule(routeDataWorkerModule).handleRouteDataRequest
+    : undefined;
+
+  if (typeof handleRouteDataRequest !== 'function') {
+    return new Response(
+      `Route data worker bundle has no handleRouteDataRequest export: ${routeDataWorkerPath}`,
+      {
+        status: 500,
+        headers: {
+          'content-type': 'text/plain; charset=utf-8',
+          'x-modern-js-route-data-worker': routeDataWorkerPath,
+        },
+      },
+    );
+  }
+
+  return handleRouteDataRequest({
+    request,
+    serverRoutes: MODERN_WORKER_MANIFEST.routeSpec.routes,
+    context: {
+      loaderContext: new Map(),
+      monitors: createNoopMonitors(),
+      reporter: {
+        reportTiming: () => {},
+      },
+    },
+    onTiming() {},
+  });
+}
+
 async function dispatchRouteWorker(route, request, env, ctx) {
   const workerPath = route.worker;
   if (!workerPath) {
@@ -114,14 +160,46 @@ async function dispatchRouteWorker(route, request, env, ctx) {
   );
 }
 
-function matchesPrefix(pathname, prefix) {
+// Worker Static Assets decode percent-encoded paths, so an encoded spelling
+// of a mounted prefix (`/%70refix/...`, `/prefix%2F...`) would otherwise skip
+// the BFF or service binding that owns the prefix and reach ASSETS directly.
+// Resolve such spellings to the canonical pathname the owner sees; a
+// backslash or undecodable spelling becomes a path the owner rejects.
+function resolvePrefixPathname(pathname, prefix) {
   if (!prefix || prefix === '/') {
-    return true;
+    return pathname;
   }
 
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  let candidate = pathname;
+
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    if (candidate === normalized || candidate.startsWith(`${normalized}/`)) {
+      return candidate;
+    }
+    if (candidate.startsWith(`${normalized}\\`)) {
+      return `${normalized}/__invalid_encoded_path__`;
+    }
 
-  return pathname === normalized || pathname.startsWith(`${normalized}/`);
+    let decoded;
+    try {
+      decoded = decodeURIComponent(candidate);
+    } catch {
+      return candidate.toLowerCase().startsWith(normalized.toLowerCase())
+        ? `${normalized}/__invalid_encoded_path__`
+        : null;
+    }
+    if (decoded === candidate) {
+      return null;
+    }
+    candidate = decoded;
+  }
+
+  return null;
+}
+
+function matchesPrefix(pathname, prefix) {
+  return resolvePrefixPathname(pathname, prefix) !== null;
 }
 
 function createRequestForMountedPrefix(request, prefix) {
@@ -131,12 +209,13 @@ function createRequestForMountedPrefix(request, prefix) {
 
   const url = new URL(request.url);
   const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  const matchedPathname = resolvePrefixPathname(url.pathname, normalized);
 
-  if (!matchesPrefix(url.pathname, normalized)) {
+  if (matchedPathname === null) {
     return request;
   }
 
-  const nextPath = url.pathname.slice(normalized.length) || '/';
+  const nextPath = matchedPathname.slice(normalized.length) || '/';
   url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
 
   return new Request(url, request);
@@ -263,12 +342,21 @@ function getEffectBffDispatcher(bff, runtime) {
 async function dispatchBffRequest(request, env) {
   const bff = MODERN_WORKER_MANIFEST.bff;
 
-  if (
-    !bff?.worker ||
-    !matchesPrefix(new URL(request.url).pathname, bff.prefix)
-  ) {
+  const requestUrl = new URL(request.url);
+  const matchedPathname = resolvePrefixPathname(
+    requestUrl.pathname,
+    bff?.prefix,
+  );
+  if (!bff?.worker || matchedPathname === null) {
     return null;
   }
+  const canonicalRequest =
+    matchedPathname === requestUrl.pathname
+      ? request
+      : new Request(
+          Object.assign(requestUrl, { pathname: matchedPathname }),
+          request,
+        );
   if (bff.runtimeFramework !== 'effect') {
     return createEffectBffDispatcherErrorResponse(
       bff,
@@ -301,7 +389,7 @@ async function dispatchBffRequest(request, env) {
       return createEffectBffDispatcherErrorResponse(bff, error);
     }
 
-    return effectDispatcher.dispatch(request, { env });
+    return effectDispatcher.dispatch(canonicalRequest, { env });
   }
 
   const directHandler =

package/dist/esm-node/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -62,11 +62,18 @@ export default {
     }
 
     if (route?.worker) {
-      const renderableRequest = createRenderableRequest(request);
+      // Route data requests keep their method, as on the Node server.
+      const routeDataResponse = await dispatchRouteDataRequest(route, request);
 
       return finalizeResponseForRequest(
         withAppCorsHeaders(
-          await dispatchRouteWorker(route, renderableRequest, env, ctx),
+          routeDataResponse ??
+            (await dispatchRouteWorker(
+              route,
+              createRenderableRequest(request),
+              env,
+              ctx,
+            )),
           request,
         ),
         request,