@rpcbase/router 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/router",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "type": "module",
   "main": "./src/index.ts",
   "scripts": {

package/src/applyRouteLoaders.ts

@@ -0,0 +1,166 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {Request} from "express"
+
+import {
+  StaticHandlerContext,
+  matchRoutes,
+  createPath,
+  Location,
+  parsePath,
+  To,
+} from "./index"
+
+
+function createKey() {
+  return Math.random().toString(36).substring(2, 10)
+}
+
+function createLocation(
+  current: string | Location,
+  to: To,
+  state: any = null,
+  key?: string,
+): Readonly<Location> {
+  const location: Readonly<Location> = {
+    pathname: typeof current === "string" ? current : current.pathname,
+    search: "",
+    hash: "",
+    ...(typeof to === "string" ? parsePath(to) : to),
+    state,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: (to && (to as Location).key) || key || createKey(),
+  }
+  return location
+}
+
+function getShortCircuitMatches(routes: any[]): {
+  matches: any[];
+  route: any;
+} {
+  // Prefer a root layout route if present, otherwise shim in a route object
+  const route =
+    routes.length === 1
+      ? routes[0]
+      : routes.find((r) => r.index || !r.path || r.path === "/") || {
+          id: "__shim-error-route__",
+        }
+
+  return {
+    matches: [
+      {
+        params: {},
+        pathname: "",
+        pathnameBase: "",
+        route,
+      },
+    ],
+    route,
+  }
+}
+
+
+export async function applyRouteLoaders(
+  req: Request,
+  dataRoutes: any[],
+): Promise<StaticHandlerContext> {
+
+  const baseUrl = `${req.protocol}://${req.get("host")}`
+  const url = new URL(req.originalUrl, baseUrl)
+
+  const method = req.method
+  const location = createLocation("", createPath(url), null, "default")
+
+  const baseContext = {
+    basename: "",
+    location,
+    loaderHeaders: {},
+    actionHeaders: {},
+  }
+
+  // Match routes to the current location
+  const matches = matchRoutes(dataRoutes, location) || []
+
+  // Handle 404 (no matches)
+  if (!matches) {
+    const error = {
+      status: 404,
+      message: `No route matches URL: ${req.originalUrl}`,
+    }
+    const { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes)
+
+    return {
+      ...baseContext,
+      matches: notFoundMatches,
+      loaderData: {},
+      actionData: null,
+      errors: { [route.id]: error },
+      statusCode: 404,
+    }
+  }
+
+  // Skip if anything but GET
+  if (method !== "GET") {
+    return {
+      ...baseContext,
+      matches,
+      loaderData: {},
+      actionData: null,
+      errors: null,
+      statusCode: 200,
+    }
+  }
+
+  // Collect loader data and errors
+  const loaderPromisesResults = await Promise.allSettled(
+    matches.map(async (match) => {
+      const { route, params } = match
+      if (!route.loader) return null
+
+      try {
+        return {
+          id: route.id,
+          data: await route.loader({
+            params,
+            ctx: {req},
+          }),
+        }
+      } catch (error) {
+        // Include the route ID in the error for better traceability
+        throw { id: route.id, reason: error }
+      }
+    }),
+  )
+
+  const loaderData: Record<string, any> = {}
+  // TODO: add i18n error handling
+  let errors: Record<string, any> | null = null
+
+  for (const result of loaderPromisesResults) {
+    if (result.status === "fulfilled") {
+      if (result.value) {
+        loaderData[result.value.id] = result.value.data
+      }
+    } else if (result.status === "rejected") {
+      const id = result.reason?.id
+      if (!id) {
+        throw new Error(`missing route ID in error: ${result.reason}`)
+      }
+      if (!errors) {
+        errors = {}
+      }
+      errors[id] = result.reason
+    }
+  }
+
+  return {
+    ...baseContext,
+    matches,
+    loaderData,
+    actionData: null,
+    errors,
+    statusCode: Object.keys(errors || {}).length > 0 ? 500 : 200,
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "react-router"
+export * from "./applyRouteLoaders"
 export * from "./loadRoute"
 export * from "./useApplyMeta"