@jay-framework/stack-route-scanner 0.9.0 → 0.11.0

package/dist/index.d.mts

@@ -13,14 +13,50 @@ type JayRoute = {
     rawRoute: string;
     jayHtmlPath: string;
     compPath: string;
+    /**
+     * For static override routes, inferred params from sibling dynamic routes.
+     * e.g., /products/ceramic-flower-vase has inferredParams: { slug: 'ceramic-flower-vase' }
+     * when /products/[slug] exists as a sibling.
+     */
+    inferredParams?: Record<string, string>;
 };
 type JayRoutes = JayRoute[];
 interface ScanFilesOptions {
     jayHtmlFilename: string;
     compFilename: string;
 }
+/**
+ * Sort routes by priority so that more specific routes match first.
+ * Static routes come before dynamic routes at the same position.
+ */
+declare function sortRoutesByPriority(routes: JayRoutes): JayRoutes;
+/**
+ * Result of param inference for logging/debugging.
+ */
+interface ParamInferenceResult {
+    staticRoute: string;
+    dynamicRoute: string;
+    inferredParams: Record<string, string>;
+}
+/**
+ * Infer params for static routes based on sibling dynamic routes.
+ *
+ * For each fully-static route, find a sibling dynamic route and map
+ * the static segment values to the param names from the dynamic route.
+ *
+ * Example:
+ *   /products/ceramic-flower-vase (static)
+ *   /products/[slug] (dynamic sibling)
+ *   → inferredParams: { slug: 'ceramic-flower-vase' }
+ *
+ * Returns the routes with inferred params added, plus an inference log.
+ */
+declare function inferParamsForStaticRoutes(routes: JayRoutes): {
+    routes: JayRoutes;
+    inferenceLog: ParamInferenceResult[];
+};
 declare function scanRoutes(baseDir: string, options: ScanFilesOptions): Promise<JayRoutes>;
 
 declare function routeToExpressRoute(route: JayRoute): string;
 
-export { type JayRoute, type JayRouteParam, JayRouteParamType, type JayRouteSegment, type JayRoutes, type ScanFilesOptions, routeToExpressRoute, scanRoutes };
+export { type JayRoute, type JayRouteParam, JayRouteParamType, type JayRouteSegment, type JayRoutes, type ParamInferenceResult, type ScanFilesOptions, inferParamsForStaticRoutes, routeToExpressRoute, scanRoutes, sortRoutesByPriority };

package/dist/index.js

@@ -41,9 +41,110 @@ async function scanDirectory(BASE_DIR, directory, options) {
   }
   return routes;
 }
+function getSegmentPriority(segment) {
+  if (typeof segment === "string")
+    return 0;
+  switch (segment.type) {
+    case 0:
+      return 1;
+    case 2:
+      return 2;
+    case 1:
+      return 3;
+  }
+}
+function compareRoutes(a, b) {
+  const maxLen = Math.max(a.segments.length, b.segments.length);
+  for (let i = 0; i < maxLen; i++) {
+    const segA = a.segments[i];
+    const segB = b.segments[i];
+    if (segA === void 0)
+      return 1;
+    if (segB === void 0)
+      return -1;
+    const priorityA = getSegmentPriority(segA);
+    const priorityB = getSegmentPriority(segB);
+    if (priorityA !== priorityB)
+      return priorityA - priorityB;
+    if (typeof segA === "string" && typeof segB === "string") {
+      const cmp = segA.localeCompare(segB);
+      if (cmp !== 0)
+        return cmp;
+    }
+  }
+  return 0;
+}
+function sortRoutesByPriority(routes) {
+  return [...routes].sort(compareRoutes);
+}
+function hasDynamicSegments(route) {
+  return route.segments.some((seg) => typeof seg !== "string");
+}
+function isFullyStaticRoute(route) {
+  return route.segments.every((seg) => typeof seg === "string");
+}
+function dynamicRouteCouldMatch(staticRoute, dynamicRoute) {
+  if (staticRoute.segments.length !== dynamicRoute.segments.length)
+    return false;
+  if (staticRoute.segments.length === 0)
+    return false;
+  for (let i = 0; i < staticRoute.segments.length; i++) {
+    const staticSeg = staticRoute.segments[i];
+    const dynSeg = dynamicRoute.segments[i];
+    if (typeof staticSeg !== "string")
+      return false;
+    if (typeof dynSeg === "string") {
+      if (staticSeg !== dynSeg)
+        return false;
+    }
+  }
+  return true;
+}
+function inferParamsForStaticRoutes(routes) {
+  const inferenceLog = [];
+  const dynamicRoutes = routes.filter(hasDynamicSegments);
+  const enrichedRoutes = routes.map((route) => {
+    if (!isFullyStaticRoute(route))
+      return route;
+    if (route.segments.length === 0)
+      return route;
+    const dynamicSibling = dynamicRoutes.find((dyn) => dynamicRouteCouldMatch(route, dyn));
+    if (!dynamicSibling)
+      return route;
+    const inferredParams = {};
+    for (let i = 0; i < route.segments.length; i++) {
+      const staticSeg = route.segments[i];
+      const dynSeg = dynamicSibling.segments[i];
+      if (typeof staticSeg === "string" && typeof dynSeg !== "string") {
+        inferredParams[dynSeg.name] = staticSeg;
+      }
+    }
+    if (Object.keys(inferredParams).length === 0)
+      return route;
+    inferenceLog.push({
+      staticRoute: route.rawRoute,
+      dynamicRoute: dynamicSibling.rawRoute,
+      inferredParams
+    });
+    return { ...route, inferredParams };
+  });
+  return { routes: enrichedRoutes, inferenceLog };
+}
 async function scanRoutes(baseDir, options) {
   const BASE_DIR = path.resolve(baseDir);
-  return await scanDirectory(BASE_DIR, BASE_DIR, options);
+  const routes = await scanDirectory(BASE_DIR, BASE_DIR, options);
+  const sortedRoutes = sortRoutesByPriority(routes);
+  const { routes: enrichedRoutes, inferenceLog } = inferParamsForStaticRoutes(sortedRoutes);
+  if (inferenceLog.length > 0) {
+    console.log("[route-scanner] Inferred params for static override routes:");
+    for (const entry of inferenceLog) {
+      console.log(
+        `  ${entry.staticRoute} → params from ${entry.dynamicRoute}:`,
+        entry.inferredParams
+      );
+    }
+  }
+  return enrichedRoutes;
 }
 function routeToExpressRoute(route) {
   return "/" + route.segments.map((segment) => {
@@ -60,5 +161,7 @@ function routeToExpressRoute(route) {
   }).join("/");
 }
 exports.JayRouteParamType = JayRouteParamType;
+exports.inferParamsForStaticRoutes = inferParamsForStaticRoutes;
 exports.routeToExpressRoute = routeToExpressRoute;
 exports.scanRoutes = scanRoutes;
+exports.sortRoutesByPriority = sortRoutesByPriority;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/stack-route-scanner",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.mts",
@@ -20,7 +20,7 @@
     "test:watch": "vitest"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.9.0",
+    "@jay-framework/dev-environment": "^0.11.0",
     "@types/node": "^20.11.5",
     "nodemon": "^3.0.3",
     "replace-in-file": "^7.1.0",