@rangojs/router 0.0.0-experimental.d20dd405 → 0.0.0-experimental.d5d3070a

package/src/router/revalidation.ts

@@ -4,7 +4,7 @@
  * Evaluates whether segments should revalidate based on params, actions, and custom functions.
  */
 
-import type { ResolvedSegment, HandlerContext } from "../types";
+import type { ResolvedSegment, HandlerContext, ActionRef } from "../types";
 import type { ActionContext } from "./types";
 import {
   debugLog,
@@ -14,21 +14,52 @@ import {
 import type { RevalidationTraceEntry } from "./logging.js";
 import { _getRequestContext } from "../server/request-context.js";
 import { isAutoGeneratedRouteName } from "../route-name.js";
+import { paramsEqual } from "./params-util.js";
 
-function paramsEqual(
-  a: Record<string, string>,
-  b: Record<string, string>,
-): boolean {
-  if (a === b) return true;
-
-  const keysA = Object.keys(a);
-  if (keysA.length !== Object.keys(b).length) return false;
-
-  for (const key of keysA) {
-    if (a[key] !== b[key]) return false;
-  }
+/**
+ * Resolve a server-action reference's stable id, mirroring how the action
+ * boundary derives `actionContext.actionId` in `rsc/server-action.ts`
+ * (`$id ?? $$id`): the file-path `$id` set by the expose-action-id plugin in a
+ * production RSC build when present, otherwise React's `$$id`. Resolving both
+ * the incoming `actionId` and the reference with the same precedence makes
+ * `isAction()` form-agnostic across dev and production.
+ */
+function resolveActionRefId(ref: unknown): string | undefined {
+  if (ref == null) return undefined;
+  const r = ref as { $id?: unknown; $$id?: unknown };
+  if (typeof r.$id === "string") return r.$id;
+  if (typeof r.$$id === "string") return r.$$id;
+  return undefined;
+}
 
-  return true;
+/**
+ * Build the `isAction()` helper bound to the current action's id. Called with no
+ * arguments it answers "is this request an action at all?" (any action) — `true`
+ * during action handling, `false` on plain navigation. Called with one or more
+ * action references it narrows to those: a single imported action, several
+ * (variadic), or any export of a namespace import (`import * as Mod`). Returns
+ * `false` when there is no action (plain navigation) or nothing matches.
+ */
+function makeIsAction(
+  currentActionId: string | undefined,
+): (...actions: ActionRef[]) => boolean {
+  return (...actions: ActionRef[]): boolean => {
+    if (!currentActionId) return false;
+    // Bare isAction(): an action is in flight (currentActionId is set) and the
+    // caller did not narrow to a specific action, so this is "any action".
+    if (actions.length === 0) return true;
+    for (const action of actions) {
+      if (typeof action === "function") {
+        if (resolveActionRefId(action) === currentActionId) return true;
+      } else if (action && typeof action === "object") {
+        // Namespace import: match any export of the module.
+        for (const value of Object.values(action)) {
+          if (resolveActionRefId(value) === currentActionId) return true;
+        }
+      }
+    }
+    return false;
+  };
 }
 
 /**
@@ -95,8 +126,6 @@ export async function evaluateRevalidation<TEnv>(
   const paramsChanged = !paramsEqual(nextParams, prevParams);
   const searchChanged = prevUrl.search !== nextUrl.search;
 
-  // Trace helper: push a structured entry to the request-scoped trace buffer.
-  // Guarded by isTraceActive() so object construction is skipped in production.
   function pushTrace(
     defaultVal: boolean,
     finalVal: boolean,
@@ -115,43 +144,28 @@ export async function evaluateRevalidation<TEnv>(
     });
   }
 
-  // Calculate default revalidation based on segment type and request method
   let defaultShouldRevalidate: boolean;
   let defaultReason: string;
 
   if (defaultOverride) {
-    // Caller injected the seed (e.g. parallel slot not in clientSegmentIds).
-    // Skip the type-derived heuristic — caller knows better in this context.
     defaultShouldRevalidate = defaultOverride.value;
     defaultReason = defaultOverride.reason;
   } else if (request.method === "POST") {
-    // Actions: revalidate segments that belong to the route, skip parent chain
     if (segment.type === "route") {
-      // Route segment always revalidates on actions
       defaultShouldRevalidate = true;
       defaultReason = "action:route-segment";
     } else if (segment.type === "loader") {
-      // Loaders always revalidate on actions - they often contain action-sensitive data
-      // (e.g., cart count after add-to-cart action)
       defaultShouldRevalidate = true;
       defaultReason = "action:loader-segment";
     } else if (segment.belongsToRoute) {
-      // Segment belongs to route (orphan layouts/parallels) - revalidate
       defaultShouldRevalidate = true;
       defaultReason = "action:belongs-to-route";
     } else {
-      // Parent chain segment (shared layouts/parallels) - don't revalidate
       defaultShouldRevalidate = false;
       defaultReason = "action:parent-chain-skip";
     }
   } else {
-    // Navigation (GET): Conservative defaults to minimize unnecessary revalidations
-    // Only the route segment revalidates by default - all others require explicit opt-in
-
     if (segment.type === "route") {
-      // Route segments revalidate when path params OR search params change.
-      // Search params (e.g., ?page=2&sort=price) are server-parsed via ctx.search,
-      // so the handler must re-execute to produce updated content.
       const routeChanged = paramsChanged || searchChanged;
       defaultShouldRevalidate = routeChanged;
       defaultReason = paramsChanged
@@ -167,8 +181,6 @@ export async function evaluateRevalidation<TEnv>(
         });
       }
     } else if (segment.belongsToRoute && (paramsChanged || searchChanged)) {
-      // Children of the route path (loaders, orphan layouts/parallels)
-      // revalidate when path params or search params change
       defaultShouldRevalidate = true;
       defaultReason = paramsChanged
         ? "nav:route-child-params-changed"
@@ -180,9 +192,6 @@ export async function evaluateRevalidation<TEnv>(
         searchChanged,
       });
     } else {
-      // Parent layouts and parallels default to no revalidation
-      // Cannot assume these segments depend on params without explicit declaration
-      // Use custom revalidation functions to opt-in when needed
       defaultShouldRevalidate = false;
       defaultReason = "nav:non-route-skip";
       debugLog("revalidation", "non-route segment skipped by default", {
@@ -192,7 +201,6 @@ export async function evaluateRevalidation<TEnv>(
     }
   }
 
-  // No custom revalidations defined - return default behavior without prev segment
   if (revalidations.length === 0) {
     if (defaultShouldRevalidate) {
       debugLog("revalidation", "default revalidate=true", {
@@ -209,14 +217,10 @@ export async function evaluateRevalidation<TEnv>(
     return defaultShouldRevalidate;
   }
 
-  // Custom revalidations exist - may need full prev segment
-  // Lazy load prev segment only if getPrevSegment provided
   const prevSegment = getPrevSegment ? await getPrevSegment() : null;
 
-  // Execute revalidation functions with soft/hard decision pattern
   let currentSuggestion = defaultShouldRevalidate;
 
-  // Compute public route names (filtered: undefined for auto-generated routes)
   const toRouteName =
     routeKey && !isAutoGeneratedRouteName(routeKey) ? routeKey : undefined;
   const reqCtx = _getRequestContext();
@@ -227,36 +231,73 @@ export async function evaluateRevalidation<TEnv>(
       : undefined;
 
   for (const { name, fn } of revalidations) {
-    const result = fn({
-      currentParams: prevSegment?.params || prevParams, // Use segment params if available, else route params
-      currentUrl: prevUrl,
-      nextParams,
-      nextUrl,
-      defaultShouldRevalidate: currentSuggestion,
-      context,
-      // Segment metadata (which segment is being evaluated)
-      segmentType: segment.type,
-      layoutName: segment.layoutName,
-      slotName: segment.slot,
-      // Action context (only populated when triggered by server action)
-      actionId: actionContext?.actionId,
-      actionUrl: actionContext?.actionUrl,
-      actionResult: actionContext?.actionResult,
-      formData: actionContext?.formData,
-      method: request.method, // GET for navigation, POST for actions
-      routeName: toRouteName, // Navigation target route name (filtered)
-      fromRouteName, // Navigation source route name (filtered)
-      toRouteName, // Navigation target route name (filtered)
-      // Stale cache context (only true for background revalidation after stale cache render)
-      stale,
-    });
+    let result: any;
+    try {
+      result = fn({
+        currentParams: prevSegment?.params || prevParams, // Use segment params if available, else route params
+        currentUrl: prevUrl,
+        nextParams,
+        nextUrl,
+        defaultShouldRevalidate: currentSuggestion,
+        context,
+        // Segment metadata (which segment is being evaluated)
+        segmentType: segment.type,
+        layoutName: segment.layoutName,
+        slotName: segment.slot,
+        // Action context (only populated when triggered by server action)
+        actionId: actionContext?.actionId,
+        isAction: makeIsAction(actionContext?.actionId),
+        actionUrl: actionContext?.actionUrl,
+        actionResult: actionContext?.actionResult,
+        formData: actionContext?.formData,
+        method: request.method,
+        routeName: toRouteName,
+        fromRouteName,
+        toRouteName,
+        stale,
+      });
+    } catch (error) {
+      // A thrown Response is control flow (e.g. `throw redirect(...)`), not a
+      // failure: re-throw it so the handler chokepoint (match-handlers.ts)
+      // turns it into the intended redirect/response. This mirrors how that
+      // catch special-cases `error instanceof Response`.
+      if (error instanceof Response) throw error;
+      // Fail open for genuine errors: a buggy user revalidate fn must not
+      // collapse the whole entry's loader batch into a failed partial render.
+      // Mirror the dynamic-tags fail-open in cache/cache-policy.ts: log and
+      // defer to the current default decision, leaving currentSuggestion
+      // unchanged. TODO: route through callOnError(phase "revalidation") once
+      // evaluateRevalidation is given the onError seam (today the error only
+      // reaches onError via the entry-collapse path in match-handlers.ts).
+      console.error(
+        `[revalidate] "${name}" threw for segment "${segment.id}"; using default decision:`,
+        error,
+      );
+      continue;
+    }
+
+    // The revalidate fn contract (handler-context.ts) is SYNCHRONOUS: it must
+    // return a boolean, a { defaultShouldRevalidate } object, or null/undefined.
+    // A Promise-returning (async) fn matches none of the decision branches below
+    // and silently falls through keeping the current default — a hard-to-find
+    // misuse. We do NOT await it (that would change the sync contract); instead
+    // we surface it as a dev-mode warning so the silent drop is diagnosable.
+    // Mirrors defer.ts: gated to dev, stripped from production builds.
+    if (
+      process.env.NODE_ENV !== "production" &&
+      result != null &&
+      typeof (result as { then?: unknown }).then === "function"
+    ) {
+      console.warn(
+        `[rango] revalidate fn "${name}" returned a Promise; revalidate ` +
+          `functions must be synchronous (return a boolean, ` +
+          `{ defaultShouldRevalidate }, or null/undefined). The async result ` +
+          `was IGNORED and the default (${currentSuggestion}) was kept. ` +
+          `Move async work into a loader instead.`,
+      );
+    }
 
-    // Check return type:
-    // - boolean: hard decision, short-circuit immediately
-    // - { defaultShouldRevalidate: boolean }: soft decision, update suggestion and continue
-    // - null/undefined: use default behavior (equivalent to returning { defaultShouldRevalidate })
     if (typeof result === "boolean") {
-      // Hard decision - short-circuit
       debugLog("revalidation", "hard decision", {
         segmentId: segment.id,
         revalidator: name,
@@ -269,7 +310,6 @@ export async function evaluateRevalidation<TEnv>(
       typeof result === "object" &&
       "defaultShouldRevalidate" in result
     ) {
-      // Soft decision - update suggestion and continue
       currentSuggestion = result.defaultShouldRevalidate;
       debugLog("revalidation", "soft decision", {
         segmentId: segment.id,
@@ -277,18 +317,14 @@ export async function evaluateRevalidation<TEnv>(
         revalidate: currentSuggestion,
       });
     } else if (result === null || result === undefined) {
-      // Defer to default - equivalent to { defaultShouldRevalidate: currentSuggestion }
-      // This means "I don't care, use whatever the default is"
       debugLog("revalidation", "deferred to current default", {
         segmentId: segment.id,
         revalidator: name,
         revalidate: currentSuggestion,
       });
-      // currentSuggestion stays the same, continue to next function
     }
   }
 
-  // All revalidators completed - use final suggestion
   debugLog("revalidation", "final decision", {
     segmentId: segment.id,
     revalidate: currentSuggestion,

package/src/router/route-snapshot.ts

@@ -230,7 +230,6 @@ export function createRouteSnapshot<TEnv = any>(
       entry: {} as any,
       routeKey: "test",
       params: {},
-      optionalParams: new Set(),
     } as RouteMatchResult<TEnv>,
     manifestEntry: { type: "route", shortCode: "R0", parent: null } as any,
     entries: [],

package/src/router/router-context.ts

@@ -19,6 +19,7 @@ import type {
 } from "../types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import type { TelemetrySink } from "./telemetry.js";
+import type { ResolveSegmentOptions } from "./segment-resolution.js";
 
 /**
  * Revalidation context passed to segment resolution
@@ -54,10 +55,8 @@ export interface InterceptResult {
  * Instead of passing 20+ parameters, middleware calls getRouterContext() to access them.
  */
 export interface RouterContext<TEnv = any> {
-  // Route matching
   findMatch: (pathname: string) => RouteMatchResult | null;
 
-  // Manifest loading
   loadManifest: (
     entry: any,
     routeKey: string,
@@ -66,10 +65,8 @@ export interface RouterContext<TEnv = any> {
     isSSR?: boolean,
   ) => Promise<EntryData>;
 
-  // Entry traversal
   traverseBack: (entry: EntryData) => Generator<EntryData>;
 
-  // Handler context creation
   createHandlerContext: (
     params: Record<string, string>,
     request: Request,
@@ -83,7 +80,6 @@ export interface RouterContext<TEnv = any> {
     isPassthroughRoute?: boolean,
   ) => HandlerContext<any, TEnv>;
 
-  // Loader setup
   setupLoaderAccess: (
     ctx: HandlerContext<any, TEnv>,
     loaderPromises: Map<string, Promise<any>>,
@@ -94,7 +90,6 @@ export interface RouterContext<TEnv = any> {
     loaderPromises: Map<string, Promise<any>>,
   ) => void;
 
-  // Context access
   getContext: () => {
     getOrCreateStore: (key: string) => any;
     runWithStore: <T>(
@@ -105,16 +100,13 @@ export interface RouterContext<TEnv = any> {
     ) => T;
   };
 
-  // Metrics
   getMetricsStore: () => MetricsStore | undefined;
 
-  // Cache
   createCacheScope: (
     cacheConfig: any,
     parent: CacheScope | null,
   ) => CacheScope | null;
 
-  // Intercept detection
   findInterceptForRoute: (
     routeKey: string,
     parentEntry: EntryData | null,
@@ -122,7 +114,6 @@ export interface RouterContext<TEnv = any> {
     isAction: boolean,
   ) => InterceptResult | null;
 
-  // Segment resolution (with revalidation)
   resolveAllSegmentsWithRevalidation: (
     entries: EntryData[],
     routeKey: string,
@@ -133,7 +124,6 @@ export interface RouterContext<TEnv = any> {
     request: Request,
     prevUrl: URL,
     nextUrl: URL,
-    loaderPromises: Map<string, Promise<any>>,
     actionContext: any | undefined,
     interceptResult: InterceptResult | null,
     localRouteName: string,
@@ -164,14 +154,13 @@ export interface RouterContext<TEnv = any> {
     handlerContext: HandlerContext<any, TEnv>,
     belongsToRoute: boolean,
     revalidationContext?: RevalidationContext,
+    options?: { skipMiddleware?: boolean },
   ) => Promise<ResolvedSegment[]>;
 
-  // Collect with markers
   collectWithMarkers?: <T>(
     gen: AsyncGenerator<T | { __type: "id"; id: string }>,
   ) => Promise<{ items: T[]; matchedIds: string[] }>;
 
-  // Revalidation evaluation
   evaluateRevalidation: (params: {
     segment: ResolvedSegment;
     prevParams: Record<string, string>;
@@ -195,7 +184,6 @@ export interface RouterContext<TEnv = any> {
       | "intercept-loader";
   }) => Promise<boolean>;
 
-  // Request context
   getRequestContext: () =>
     | {
         waitUntil: (fn: () => Promise<void>) => void;
@@ -203,17 +191,15 @@ export interface RouterContext<TEnv = any> {
       }
     | undefined;
 
-  // Simple segment resolution (without revalidation - for full match)
   resolveAllSegments: (
     entries: EntryData[],
     routeKey: string,
     params: Record<string, string>,
     handlerContext: HandlerContext<any, TEnv>,
     loaderPromises: Map<string, Promise<any>>,
-    options?: { skipLoaders?: boolean },
+    options?: ResolveSegmentOptions,
   ) => Promise<ResolvedSegment[]>;
 
-  // Generator-based simple resolution
   resolveAllSegmentsGenerator?: (
     entries: EntryData[],
     routeKey: string,
@@ -222,21 +208,17 @@ export interface RouterContext<TEnv = any> {
     loaderPromises: Map<string, Promise<any>>,
   ) => AsyncGenerator<ResolvedSegment | { __type: "id"; id: string }>;
 
-  // Collect segments from generator
   collectSegmentsFromGenerator?: <T>(
     gen: AsyncGenerator<T | { __type: "id"; id: string }>,
   ) => Promise<T[]>;
 
-  // Handle store
   createHandleStore: () => any;
 
-  // Loaders-only resolution (for full match cache hit - no revalidation)
   resolveLoadersOnly?: (
     entries: EntryData[],
     handlerContext: HandlerContext<any, TEnv>,
   ) => Promise<ResolvedSegment[]>;
 
-  // Loaders-only resolution (for cache hit scenarios)
   resolveLoadersOnlyWithRevalidation?: (
     entries: EntryData[],
     handlerContext: HandlerContext<any, TEnv>,
@@ -258,10 +240,8 @@ export interface RouterContext<TEnv = any> {
   // Telemetry sink (optional, no-op when undefined)
   telemetry?: TelemetrySink;
 
-  // Request ID for telemetry span correlation (set per-request in match handlers)
   requestId?: string;
 
-  // Intercept loaders only (for cache hit + intercept scenarios)
   resolveInterceptLoadersOnly?: (
     intercept: InterceptEntry,
     entry: EntryData,
@@ -284,7 +264,6 @@ export interface RouterContext<TEnv = any> {
   } | null>;
 }
 
-// AsyncLocalStorage instance for router context
 const routerContext = new AsyncLocalStorage<RouterContext<any>>();
 
 /**
@@ -308,10 +287,6 @@ export function getRouterContext<TEnv = any>(): RouterContext<TEnv> {
  *
  * All async code within fn() can call getRouterContext() to access router closures.
  * This works across async boundaries thanks to AsyncLocalStorage.
- *
- * @param deps Router dependencies to make available
- * @param fn Function to run with dependencies available
- * @returns Result of fn()
  */
 export function runWithRouterContext<T, TEnv = any>(
   deps: RouterContext<TEnv>,