@pylonsync/sdk 0.3.246 → 0.3.248

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.246",
+  "version": "0.3.248",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -331,8 +331,11 @@ export interface RouteDefinition {
    * NOT matched as navigable URLs — the host renders `not-found` for
    * unmatched URLs (HTTP 404) and `error` on render failure (HTTP 500).
    * `path` records the segment prefix the boundary covers (`/` for root).
+   * `"route"` is a form/method handler (`app/.../route.ts` exporting
+   * POST/PUT/PATCH/DELETE) — matched on its `path` for non-GET requests only,
+   * never rendered as a page.
    */
-  kind?: "page" | "not-found" | "error";
+  kind?: "page" | "not-found" | "error" | "route";
 }
 
 export function defineRoute(route: RouteDefinition): RouteDefinition {
@@ -506,8 +509,8 @@ export interface ManifestRoute {
   auth?: string;
   component?: string;
   layouts?: string[];
-  /** "not-found" / "error" boundary modules; omitted for normal pages. */
-  kind?: "page" | "not-found" | "error";
+  /** "not-found" / "error" boundaries, or "route" form handlers; omitted for normal pages. */
+  kind?: "page" | "not-found" | "error" | "route";
 }
 
 export interface ManifestInputField {
@@ -669,8 +672,9 @@ export function routesToManifest(routes: RouteDefinition[]): ManifestRoute[] {
  * ones at each depth — so the Rust matcher's first-match-wins
  * lookup picks the right route.
  *
- * Phase 1 only: no `loading.tsx` / `error.tsx` / `not-found.tsx`
- * support yet.
+ * `not-found.tsx` / `error.tsx` boundaries are emitted as `kind`-tagged
+ * routes here; `loading.tsx` is resolved at render time by the SSR runtime
+ * (filesystem walk), so it needs no discovery entry.
  */
 export async function discoverAppRoutes(opts?: {
   appDir?: string;
@@ -719,8 +723,10 @@ export async function discoverAppRoutes(opts?: {
     layouts: string[];
     kind: "not-found" | "error";
   };
+  type RouteHandlerHit = { segments: string[]; component: string };
   const pages: PageHit[] = [];
   const boundaries: BoundaryHit[] = [];
+  const routeHandlers: RouteHandlerHit[] = [];
 
   // Resolve the first existing `<base>.{tsx,ts,jsx,js}` in `dir` and
   // return it as a cwd-relative, extension-less module path (or null).
@@ -770,6 +776,12 @@ export async function discoverAppRoutes(opts?: {
         kind: "error",
       });
     }
+    // Form/method handler (`route.ts` exporting POST/PUT/PATCH/DELETE). Matched
+    // on its path for non-GET requests only — never rendered, no layouts.
+    const routeHere = findModule(dir, "route");
+    if (routeHere) {
+      routeHandlers.push({ segments: [...segments], component: routeHere });
+    }
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       if (e.name.startsWith(".") || e.name === "node_modules") continue;
@@ -781,14 +793,27 @@ export async function discoverAppRoutes(opts?: {
   }
   walk(appDir, [], []);
 
+  // Segment kinds, least-to-most greedy:
+  //   static            "blog"          rank 0  (most specific)
+  //   dynamic param     "[slug]"        rank 1  → :slug
+  //   catch-all         "[...slug]"     rank 2  → *slug   (matches ≥1 segment)
+  //   optional catch-all"[[...slug]]"   rank 3  → *?slug  (matches ≥0 segments)
+  // A catch-all is only valid as the LAST segment of a route (it consumes
+  // the rest of the path); Next.js enforces the same.
+  const isOptionalCatchAll = (s: string): boolean =>
+    s.startsWith("[[...") && s.endsWith("]]");
+  const isCatchAll = (s: string): boolean =>
+    s.startsWith("[...") && s.endsWith("]") && !isOptionalCatchAll(s);
   const isParam = (s: string): boolean =>
-    s.startsWith("[") && s.endsWith("]");
+    s.startsWith("[") && s.endsWith("]") && !isCatchAll(s) && !isOptionalCatchAll(s);
+  const segRank = (s: string): number =>
+    isOptionalCatchAll(s) ? 3 : isCatchAll(s) ? 2 : isParam(s) ? 1 : 0;
   pages.sort((a, b) => {
     const minLen = Math.min(a.segments.length, b.segments.length);
     for (let i = 0; i < minLen; i++) {
-      const ap = isParam(a.segments[i]);
-      const bp = isParam(b.segments[i]);
-      if (ap !== bp) return ap ? 1 : -1;
+      const ar = segRank(a.segments[i]);
+      const br = segRank(b.segments[i]);
+      if (ar !== br) return ar - br; // more specific (lower rank) first
       if (a.segments[i] !== b.segments[i]) {
         return a.segments[i] < b.segments[i] ? -1 : 1;
       }
@@ -796,9 +821,17 @@ export async function discoverAppRoutes(opts?: {
     return a.segments.length - b.segments.length;
   });
 
+  // Convert a discovered file segment to its route-pattern token. The Rust
+  // matcher (frontend.rs `match_ssr_route`) reads these markers back:
+  //   :name   dynamic param      *name   catch-all      *?name  optional catch-all
+  const segmentToToken = (s: string): string => {
+    if (isOptionalCatchAll(s)) return `*?${s.slice(5, -2)}`; // [[...x]] → *?x
+    if (isCatchAll(s)) return `*${s.slice(4, -1)}`; //          [...x]   → *x
+    if (isParam(s)) return `:${s.slice(1, -1)}`; //             [x]      → :x
+    return s;
+  };
   const segmentsToPath = (segments: string[]): string =>
-    "/" +
-    segments.map((s) => (isParam(s) ? `:${s.slice(1, -1)}` : s)).join("/");
+    "/" + segments.map(segmentToToken).join("/");
 
   const pageRoutes: RouteDefinition[] = pages.map((p) => ({
     path: segmentsToPath(p.segments),
@@ -821,7 +854,16 @@ export async function discoverAppRoutes(opts?: {
       kind: b.kind,
     }));
 
-  return [...pageRoutes, ...boundaryRoutes];
+  // Form/method handlers. Keyed by the SAME path token form as pages
+  // (`:param` / `*catch-all`), matched by the host for non-GET methods only.
+  const routeRoutes: RouteDefinition[] = routeHandlers.map((r) => ({
+    path: segmentsToPath(r.segments),
+    mode: "ssr" as const,
+    component: r.component,
+    kind: "route" as const,
+  }));
+
+  return [...pageRoutes, ...boundaryRoutes, ...routeRoutes];
 }
 
 export function queriesToManifest(queries: QueryDefinition[]): ManifestQuery[] {