@rangojs/router 0.0.0-experimental.8 → 0.0.0-experimental.80

package/src/router/match-handlers.ts

@@ -0,0 +1,440 @@
+import type { ReactNode } from "react";
+import { sanitizeError } from "../errors";
+import type { ErrorInfo, ErrorPhase, MatchResult } from "../types";
+import type {
+  EntryData,
+  InterceptEntry,
+  InterceptSelectorContext,
+} from "../server/context";
+import type { MatchApiDeps } from "./types.js";
+import type { RouterContext } from "./router-context.js";
+import { runWithRouterContext } from "./router-context.js";
+import {
+  type ActionContext,
+  type MatchContext,
+  createPipelineState,
+} from "./match-context.js";
+import { createMatchPartialPipeline } from "./match-pipelines.js";
+import { collectMatchResult } from "./match-result.js";
+import {
+  createMatchContextForFull as _createMatchContextForFull,
+  createMatchContextForPartial as _createMatchContextForPartial,
+  matchError as _matchError,
+} from "./match-api.js";
+import { previewMatch as _previewMatch } from "./preview-match.js";
+import {
+  runWithRouterLogContext,
+  withRouterLogScope,
+  isRouterDebugEnabled,
+  startRevalidationTrace,
+  flushRevalidationTrace,
+} from "./logging.js";
+import type { ErrorBoundaryHandler, NotFoundBoundaryHandler } from "../types";
+import type { MiddlewareFn } from "./middleware.js";
+import {
+  type TelemetrySink,
+  safeEmit,
+  resolveSink,
+  getRequestId,
+} from "./telemetry.js";
+
+export interface MatchHandlerDeps<TEnv = any> {
+  buildRouterContext: () => RouterContext<TEnv>;
+  callOnError: (error: unknown, phase: ErrorPhase, context: any) => void;
+  matchApiDeps: MatchApiDeps<TEnv>;
+  defaultErrorBoundary: ReactNode | ErrorBoundaryHandler | undefined;
+  findMatch: (pathname: string, ms?: any) => any;
+  findInterceptForRoute: (
+    routeKey: string,
+    parentEntry: EntryData | null,
+    selectorContext: InterceptSelectorContext | null,
+    isAction: boolean,
+  ) => { intercept: InterceptEntry; entry: EntryData } | null;
+  telemetry?: TelemetrySink;
+}
+
+export interface MatchHandlers<TEnv = any> {
+  match: (request: Request, env: TEnv) => Promise<MatchResult>;
+  matchPartial: (
+    request: Request,
+    context: TEnv,
+    actionContext?: ActionContext,
+  ) => Promise<MatchResult | null>;
+  matchError: (
+    request: Request,
+    _context: TEnv,
+    error: unknown,
+    segmentType?: ErrorInfo["segmentType"],
+  ) => Promise<MatchResult | null>;
+  previewMatch: (
+    request: Request,
+    _context: TEnv,
+  ) => Promise<{
+    routeMiddleware?: Array<{
+      handler: MiddlewareFn;
+      params: Record<string, string>;
+    }>;
+    responseType?: string;
+    handler?: Function;
+    params?: Record<string, string>;
+    negotiated?: boolean;
+    manifestEntry?: EntryData;
+  } | null>;
+  createMatchContextForFull: (
+    request: Request,
+    env: TEnv,
+  ) => Promise<MatchContext<TEnv> | { type: "redirect"; redirectUrl: string }>;
+  createMatchContextForPartial: (
+    request: Request,
+    env: TEnv,
+    actionContext?: {
+      actionId?: string;
+      actionUrl?: URL;
+      actionResult?: any;
+      formData?: FormData;
+    },
+  ) => Promise<MatchContext<TEnv> | null>;
+}
+
+/**
+ * Create match handler functions bound to router closure state.
+ * These are the main request-handling entry points for SSR, navigation,
+ * error recovery, and preview matching.
+ */
+export function createMatchHandlers<TEnv = any>(
+  deps: MatchHandlerDeps<TEnv>,
+): MatchHandlers<TEnv> {
+  const {
+    buildRouterContext,
+    callOnError,
+    matchApiDeps,
+    defaultErrorBoundary,
+    findInterceptForRoute,
+  } = deps;
+  const hasTelemetry = !!deps.telemetry;
+  const telemetry = resolveSink(deps.telemetry);
+
+  async function createMatchContextForFull(
+    request: Request,
+    env: TEnv,
+  ): Promise<MatchContext<TEnv> | { type: "redirect"; redirectUrl: string }> {
+    return _createMatchContextForFull(
+      request,
+      env,
+      matchApiDeps,
+      findInterceptForRoute,
+    );
+  }
+
+  async function createMatchContextForPartial(
+    request: Request,
+    env: TEnv,
+    actionContext?: {
+      actionId?: string;
+      actionUrl?: URL;
+      actionResult?: any;
+      formData?: FormData;
+    },
+  ): Promise<MatchContext<TEnv> | null> {
+    return _createMatchContextForPartial(
+      request,
+      env,
+      matchApiDeps,
+      findInterceptForRoute,
+      actionContext,
+    );
+  }
+
+  /**
+   * Match request and return segments (document/SSR requests)
+   *
+   * Uses generator middleware pipeline for clean separation of concerns:
+   * - cache-lookup: Check cache first
+   * - segment-resolution: Resolve segments on cache miss
+   * - cache-store: Store results in cache
+   * - background-revalidation: SWR revalidation
+   */
+  async function match(request: Request, env: TEnv): Promise<MatchResult> {
+    const requestId = hasTelemetry ? getRequestId(request) : undefined;
+    return runWithRouterLogContext({ request, transaction: "match" }, () => {
+      const routerCtx = buildRouterContext();
+      routerCtx.requestId = requestId;
+      return runWithRouterContext(routerCtx, async () =>
+        withRouterLogScope("match", async () => {
+          const matchStart = performance.now();
+          const pathname = new URL(request.url).pathname;
+          if (hasTelemetry) {
+            safeEmit(telemetry, {
+              type: "request.start",
+              timestamp: matchStart,
+              requestId,
+              method: request.method,
+              pathname,
+              transaction: "match",
+              isPartial: false,
+            });
+          }
+
+          const result = await createMatchContextForFull(request, env);
+
+          // Handle redirect case
+          if ("type" in result && result.type === "redirect") {
+            if (hasTelemetry) {
+              safeEmit(telemetry, {
+                type: "request.end",
+                timestamp: performance.now(),
+                requestId,
+                method: request.method,
+                pathname,
+                transaction: "match",
+                durationMs: performance.now() - matchStart,
+                segmentCount: 0,
+                cacheHit: false,
+              });
+            }
+            return {
+              segments: [],
+              matched: [],
+              diff: [],
+              params: {},
+              redirect: result.redirectUrl,
+            };
+          }
+
+          const ctx = result as MatchContext<TEnv>;
+
+          try {
+            const state = createPipelineState();
+            const pipeline = createMatchPartialPipeline(ctx, state);
+            const matchResult = await collectMatchResult(pipeline, ctx, state);
+            if (hasTelemetry) {
+              safeEmit(telemetry, {
+                type: "cache.decision",
+                timestamp: performance.now(),
+                requestId,
+                pathname,
+                routeKey: ctx.routeKey,
+                hit: state.cacheHit,
+                shouldRevalidate: !!state.shouldRevalidate,
+                source: state.cacheSource,
+              });
+              safeEmit(telemetry, {
+                type: "request.end",
+                timestamp: performance.now(),
+                requestId,
+                method: request.method,
+                pathname,
+                transaction: "match",
+                durationMs: performance.now() - matchStart,
+                segmentCount: matchResult.segments.length,
+                cacheHit: state.cacheHit,
+              });
+            }
+            return matchResult;
+          } catch (error) {
+            if (hasTelemetry) {
+              const errorObj =
+                error instanceof Error ? error : new Error(String(error));
+              safeEmit(telemetry, {
+                type: "request.error",
+                timestamp: performance.now(),
+                requestId,
+                method: request.method,
+                pathname,
+                transaction: "match",
+                error: errorObj,
+                phase: error instanceof Response ? "redirect" : "routing",
+                durationMs: performance.now() - matchStart,
+              });
+            }
+            if (error instanceof Response) throw error;
+            // Report unhandled errors during full match pipeline
+            callOnError(error, "routing", {
+              request,
+              url: ctx.url,
+              env,
+              isPartial: false,
+              handledByBoundary: false,
+            });
+            throw sanitizeError(error);
+          }
+        }),
+      );
+    });
+  }
+
+  async function matchError(
+    request: Request,
+    _context: TEnv,
+    error: unknown,
+    segmentType: ErrorInfo["segmentType"] = "route",
+  ): Promise<MatchResult | null> {
+    return runWithRouterLogContext({ request, transaction: "matchError" }, () =>
+      withRouterLogScope("matchError", () =>
+        _matchError(
+          request,
+          _context,
+          error,
+          matchApiDeps,
+          defaultErrorBoundary,
+          segmentType,
+        ),
+      ),
+    );
+  }
+
+  /**
+   * Match partial request with revalidation
+   *
+   * Uses generator middleware pipeline for clean separation of concerns:
+   * - cache-lookup: Check cache first
+   * - segment-resolution: Resolve segments on cache miss
+   * - intercept-resolution: Handle intercept routes
+   * - cache-store: Store results in cache
+   * - background-revalidation: SWR revalidation
+   */
+  async function matchPartial(
+    request: Request,
+    context: TEnv,
+    actionContext?: ActionContext,
+  ): Promise<MatchResult | null> {
+    const partialRequestId = hasTelemetry ? getRequestId(request) : undefined;
+    return runWithRouterLogContext(
+      { request, transaction: "matchPartial" },
+      () => {
+        const routerCtx = buildRouterContext();
+        routerCtx.requestId = partialRequestId;
+        return runWithRouterContext(routerCtx, async () =>
+          withRouterLogScope("matchPartial", async () => {
+            const matchStart = performance.now();
+            const pathname = new URL(request.url).pathname;
+            if (hasTelemetry) {
+              safeEmit(telemetry, {
+                type: "request.start",
+                timestamp: matchStart,
+                requestId: partialRequestId,
+                method: request.method,
+                pathname,
+                transaction: "matchPartial",
+                isPartial: true,
+              });
+            }
+
+            const ctx = await createMatchContextForPartial(
+              request,
+              context,
+              actionContext,
+            );
+            if (!ctx) {
+              if (hasTelemetry) {
+                safeEmit(telemetry, {
+                  type: "request.end",
+                  timestamp: performance.now(),
+                  requestId: partialRequestId,
+                  method: request.method,
+                  pathname,
+                  transaction: "matchPartial",
+                  durationMs: performance.now() - matchStart,
+                  segmentCount: 0,
+                  cacheHit: false,
+                });
+              }
+              return null;
+            }
+
+            if (isRouterDebugEnabled()) {
+              startRevalidationTrace({
+                method: request.method,
+                prevUrl: ctx.prevUrl.href,
+                nextUrl: ctx.url.href,
+                routeKey: ctx.routeKey,
+                isAction: !!actionContext,
+                stale: ctx.stale || undefined,
+              });
+            }
+
+            try {
+              const state = createPipelineState();
+              const pipeline = createMatchPartialPipeline(ctx, state);
+              const matchResult = await collectMatchResult(
+                pipeline,
+                ctx,
+                state,
+              );
+              flushRevalidationTrace();
+              if (hasTelemetry) {
+                safeEmit(telemetry, {
+                  type: "cache.decision",
+                  timestamp: performance.now(),
+                  requestId: partialRequestId,
+                  pathname,
+                  routeKey: ctx.routeKey,
+                  hit: state.cacheHit,
+                  shouldRevalidate: !!state.shouldRevalidate,
+                  source: state.cacheSource,
+                });
+                safeEmit(telemetry, {
+                  type: "request.end",
+                  timestamp: performance.now(),
+                  requestId: partialRequestId,
+                  method: request.method,
+                  pathname,
+                  transaction: "matchPartial",
+                  durationMs: performance.now() - matchStart,
+                  segmentCount: matchResult.segments.length,
+                  cacheHit: state.cacheHit,
+                });
+              }
+              return matchResult;
+            } catch (error) {
+              flushRevalidationTrace();
+              if (hasTelemetry) {
+                const errorObj =
+                  error instanceof Error ? error : new Error(String(error));
+                const phase = actionContext ? "action" : "revalidation";
+                safeEmit(telemetry, {
+                  type: "request.error",
+                  timestamp: performance.now(),
+                  requestId: partialRequestId,
+                  method: request.method,
+                  pathname,
+                  transaction: "matchPartial",
+                  error: errorObj,
+                  phase: error instanceof Response ? "redirect" : phase,
+                  durationMs: performance.now() - matchStart,
+                });
+              }
+              if (error instanceof Response) throw error;
+              // Report unhandled errors during partial match pipeline
+              callOnError(error, actionContext ? "action" : "revalidation", {
+                request,
+                url: ctx.url,
+                env: context,
+                actionId: actionContext?.actionId,
+                isPartial: true,
+                handledByBoundary: false,
+              });
+              throw sanitizeError(error);
+            }
+          }),
+        );
+      },
+    );
+  }
+
+  async function previewMatch(
+    request: Request,
+    _context: TEnv,
+  ): ReturnType<typeof _previewMatch> {
+    return _previewMatch(request, _context, { findMatch: deps.findMatch });
+  }
+
+  return {
+    match: match,
+    matchPartial: matchPartial,
+    matchError: matchError,
+    previewMatch: previewMatch,
+    createMatchContextForFull: createMatchContextForFull,
+    createMatchContextForPartial: createMatchContextForPartial,
+  };
+}