@emeryld/rrroutes-server 2.6.5 → 2.6.7

package/dist/index.cjs

@@ -499,6 +499,9 @@ var defaultSend = (res, data) => {
   res.json(data);
 };
 var REGISTERED_ROUTES_SYMBOL = /* @__PURE__ */ Symbol.for("routesV3.registeredRoutes");
+var REGISTERED_ROUTE_ENTRIES_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "routesV3.registeredRouteEntries"
+);
 function getRegisteredRouteStore(router) {
   const existing = router[REGISTERED_ROUTES_SYMBOL];
   if (existing) return existing;
@@ -506,6 +509,101 @@ function getRegisteredRouteStore(router) {
   router[REGISTERED_ROUTES_SYMBOL] = store;
   return store;
 }
+function parseRegisteredRouteKey(key) {
+  const firstSpace = key.indexOf(" ");
+  if (firstSpace <= 0) return void 0;
+  const method = key.slice(0, firstSpace).toUpperCase();
+  const path = key.slice(firstSpace + 1);
+  if (!path) return void 0;
+  return { method, path, key, origin: "unknown (pre-existing router stack)" };
+}
+function getRegistrationOrigin() {
+  const stack = new Error().stack;
+  if (!stack) return "unknown";
+  const lines = stack.split("\n").map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    if (/^Error:?$/.test(line)) continue;
+    if (line.includes("getRegistrationOrigin") || line.includes("findShadowingPriorRoute") || line.includes("createRRRoute") || line.includes("register (") || line.includes("routesV3.server.ts") || line.includes("<anonymous>") || line.includes("node_modules") || line.includes("internal/")) {
+      continue;
+    }
+    return line.replace(/^at\s+/, "");
+  }
+  return lines.find((line) => !/^Error:?$/.test(line))?.replace(/^at\s+/, "") ?? "unknown";
+}
+function getRegisteredRouteEntriesStore(router) {
+  const existing = router[REGISTERED_ROUTE_ENTRIES_SYMBOL];
+  if (existing) return existing;
+  const seeded = collectRoutesFromStack(router).map(parseRegisteredRouteKey).filter((entry) => Boolean(entry));
+  router[REGISTERED_ROUTE_ENTRIES_SYMBOL] = seeded;
+  return seeded;
+}
+function toParsedRouteSegments(path) {
+  const segments = path.split("/").filter(Boolean);
+  return segments.map((segment) => {
+    if (segment.startsWith("*") && segment.length > 1) return { kind: "wildcard" };
+    if (segment.startsWith(":") && segment.length > 1) return { kind: "param" };
+    return { kind: "static", value: segment };
+  });
+}
+function buildProbePathForRoute(path) {
+  const parsed = toParsedRouteSegments(path);
+  const segments = [];
+  for (const segment of parsed) {
+    if (segment.kind === "static") {
+      segments.push(segment.value);
+      continue;
+    }
+    if (segment.kind === "param") {
+      segments.push("__rrroutes_param__");
+      continue;
+    }
+    segments.push("__rrroutes_splat__", "__rrroutes_tail__");
+  }
+  return `/${segments.join("/")}`.replace(/\/+/g, "/");
+}
+function routePatternMatchesConcretePath(routePattern, concretePath) {
+  const patternSegments = toParsedRouteSegments(routePattern);
+  const pathSegments = concretePath.split("/").filter(Boolean);
+  let i = 0;
+  let j = 0;
+  while (i < patternSegments.length) {
+    const pattern = patternSegments[i];
+    if (pattern.kind === "wildcard") {
+      return j < pathSegments.length;
+    }
+    if (j >= pathSegments.length) return false;
+    if (pattern.kind === "param") {
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (pattern.value !== pathSegments[j]) return false;
+    i += 1;
+    j += 1;
+  }
+  return j === pathSegments.length;
+}
+function findShadowingPriorRoute(entries, method, path) {
+  const probePath = buildProbePathForRoute(path);
+  return entries.find((entry) => {
+    if (entry.method !== method) return false;
+    if (entry.path === path) return true;
+    return routePatternMatchesConcretePath(entry.path, probePath);
+  });
+}
+function formatRouteShadowWarning(args) {
+  const { method, path, currentOrigin, prior } = args;
+  const newRoute = `${method} ${path}`;
+  const priorRoute = `${prior.method} ${prior.path}`;
+  return [
+    "[rrroutes-server][route-shadow-warning]",
+    `  New route:        ${newRoute}`,
+    `  Existing route:   ${priorRoute}`,
+    `  Precedence:       ${priorRoute} takes precedence (registered first)`,
+    `  New origin:       ${currentOrigin}`,
+    `  Existing origin:  ${prior.origin}`
+  ].join("\n");
+}
 function collectRoutesFromStack(appOrRouter) {
   const result = [];
   const stack = appOrRouter.stack ?? (appOrRouter._router ? appOrRouter._router.stack : void 0) ?? [];
@@ -542,6 +640,7 @@ function createRRRoute(router, config) {
   const preCtxMws = [...middlewareConfig.preCtx ?? []];
   const sanitizerMw = middlewareConfig.sanitizer === void 0 ? void 0 : typeof middlewareConfig.sanitizer === "function" ? middlewareConfig.sanitizer : createRequestSanitizationMiddleware(middlewareConfig.sanitizer);
   const registered = getRegisteredRouteStore(router);
+  const registeredEntries = getRegisteredRouteEntriesStore(router);
   const getMulterOptions = (fields) => {
     if (!fields || fields.length === 0) return void 0;
     const resolved = typeof config.multerOptions === "function" ? config.multerOptions(fields) : config.multerOptions;
@@ -584,6 +683,18 @@ function createRRRoute(router, config) {
     const activeDebugMode = routeDebugEmitter?.mode ?? defaultDebugMode;
     const emit = (event) => activeEmit(event, debugName);
     const isVerboseDebug = activeDebugMode === "complete";
+    const origin = getRegistrationOrigin();
+    const shadowingEntry = findShadowingPriorRoute(registeredEntries, methodUpper, path);
+    if (shadowingEntry) {
+      console.warn(
+        formatRouteShadowWarning({
+          method: methodUpper,
+          path,
+          currentOrigin: origin,
+          prior: shadowingEntry
+        })
+      );
+    }
     emit({ type: "register", method: methodUpper, path });
     const routeSpecific = (def?.before ?? []).map(
       (mw) => adaptRouteBeforeMw(mw)
@@ -832,6 +943,7 @@ function createRRRoute(router, config) {
     };
     router[method](path, ...before, wrapped);
     registered.add(key);
+    registeredEntries.push({ method: methodUpper, path, key, origin });
     registeredDefs.set(key, {
       leaf,
       def