effect-start 0.9.0 → 0.10.0

package/src/FileRouterCodegen.test.ts

@@ -22,17 +22,13 @@ t.it("generates code for routes only", () => {
 
 import type { Router } from "effect-start"
 
-export const modules = [
+export const routes = [
   {
     path: "/",
-    segments: [],
     load: () => import("./route.tsx"),
   },
   {
     path: "/about",
-    segments: [
-      { literal: "about" },
-    ],
     load: () => import("./about/route.tsx"),
   },
 ] as const
@@ -58,10 +54,9 @@ t.it("generates code with layers", () => {
 
 import type { Router } from "effect-start"
 
-export const modules = [
+export const routes = [
   {
     path: "/",
-    segments: [],
     load: () => import("./route.tsx"),
     layers: [
       () => import("./layer.tsx"),
@@ -69,9 +64,6 @@ export const modules = [
   },
   {
     path: "/about",
-    segments: [
-      { literal: "about" },
-    ],
     load: () => import("./about/route.tsx"),
     layers: [
       () => import("./layer.tsx"),
@@ -101,12 +93,9 @@ t.it("generates code with nested layers", () => {
 
 import type { Router } from "effect-start"
 
-export const modules = [
+export const routes = [
   {
     path: "/dashboard",
-    segments: [
-      { literal: "dashboard" },
-    ],
     load: () => import("./dashboard/route.tsx"),
     layers: [
       () => import("./layer.tsx"),
@@ -115,10 +104,6 @@ export const modules = [
   },
   {
     path: "/dashboard/settings",
-    segments: [
-      { literal: "dashboard" },
-      { literal: "settings" },
-    ],
     load: () => import("./dashboard/settings/route.tsx"),
     layers: [
       () => import("./layer.tsx"),
@@ -163,9 +148,6 @@ t.it("only includes group layers for routes in that group", () => {
   // /movies should only have root layer, not (admin) layer
   const expectedMovies = `  {
     path: "/movies",
-    segments: [
-      { literal: "movies" },
-    ],
     load: () => import("./movies/route.tsx"),
     layers: [
       () => import("./layer.tsx"),
@@ -194,16 +176,7 @@ t.it("handles dynamic routes with params", () => {
     .toContain("path: \"/users/[userId]\"")
   t
     .expect(code)
-    .toContain("{ literal: \"users\" }")
-  t
-    .expect(code)
-    .toContain("{ param: \"userId\" }")
-  t
-    .expect(code)
-    .toContain("{ param: \"postId\" }")
-  t
-    .expect(code)
-    .toContain("{ param: \"commentId\" }")
+    .toContain("path: \"/posts/[postId]/comments/[commentId]\"")
 })
 
 t.it("handles rest parameters", () => {
@@ -220,12 +193,6 @@ t.it("handles rest parameters", () => {
   t
     .expect(code)
     .toContain("path: \"/api/[...path]\"")
-  t
-    .expect(code)
-    .toContain("{ rest: \"slug\", optional: true }")
-  t
-    .expect(code)
-    .toContain("{ rest: \"path\" }")
 })
 
 t.it("handles groups in path", () => {
@@ -239,9 +206,6 @@ t.it("handles groups in path", () => {
   t
     .expect(code)
     .toContain("path: \"/users\"") // groups stripped from URL
-  t
-    .expect(code)
-    .toContain("{ group: \"admin\" }")
   t
     .expect(code)
     .toContain("layers: [\n      () => import(\"./(admin)/layer.tsx\"),\n    ]")
@@ -257,9 +221,6 @@ t.it("generates correct variable names for root routes", () => {
   t
     .expect(code)
     .toContain("path: \"/\"")
-  t
-    .expect(code)
-    .toContain("segments: []")
 })
 
 t.it("handles routes with dots in path segments", () => {
@@ -276,12 +237,6 @@ t.it("handles routes with dots in path segments", () => {
   t
     .expect(code)
     .toContain("path: \"/config.yaml.backup\"")
-  t
-    .expect(code)
-    .toContain("{ literal: \"events.json\" }")
-  t
-    .expect(code)
-    .toContain("{ literal: \"config.yaml.backup\" }")
 })
 
 t.it("uses default module identifier", () => {
@@ -296,17 +251,17 @@ t.it("uses default module identifier", () => {
     .toContain("import type { Router } from \"effect-start\"")
 })
 
-t.it("generates empty modules array when no handles provided", () => {
+t.it("generates empty routes array when no handles provided", () => {
   const handles: RouteHandle[] = []
 
   const code = FileRouterCodegen.generateCode(handles)
 
   t
     .expect(code)
-    .toContain("export const modules = [] as const")
+    .toContain("export const routes = [] as const")
 })
 
-t.it("only includes routes in modules, not layers", () => {
+t.it("only includes routes, not layers", () => {
   const handles: RouteHandle[] = [
     parseRoute("layer.tsx"),
     parseRoute("users/layer.tsx"),
@@ -316,7 +271,7 @@ t.it("only includes routes in modules, not layers", () => {
 
   t
     .expect(code)
-    .toContain("export const modules = [] as const")
+    .toContain("export const routes = [] as const")
 })
 
 t.it("complex nested routes with multiple layers", () => {
@@ -371,12 +326,6 @@ t.it("handles routes with hyphens and underscores in path segments", () => {
   t
     .expect(code)
     .toContain("path: \"/my_resource\"")
-  t
-    .expect(code)
-    .toContain("{ literal: \"api-v1\" }")
-  t
-    .expect(code)
-    .toContain("{ literal: \"my_resource\" }")
 })
 
 t.it("validateRouteModule returns true for valid modules", () => {
@@ -454,10 +403,247 @@ t.it("mixed params and rest in same route", () => {
 
   t
     .expect(code)
-    .toContain("{ param: \"userId\" }")
-  t
-    .expect(code)
-    .toContain("{ rest: \"path\" }")
+    .toContain("path: \"/users/[userId]/files/[...path]\"")
+})
+
+t.describe("layerMatchesRoute", () => {
+  t.it("layer in dynamic param dir only applies to routes in that dir", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("[userId]/layer.tsx"),
+      parseRoute("[userId]/posts/route.tsx"),
+      parseRoute("[otherId]/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expectedUserIdPosts = `  {
+    path: "/[userId]/posts",
+    load: () => import("./[userId]/posts/route.tsx"),
+    layers: [
+      () => import("./[userId]/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedUserIdPosts)
+
+    const expectedOtherId = `  {
+    path: "/[otherId]",
+    load: () => import("./[otherId]/route.tsx"),
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedOtherId)
+  })
+
+  t.it("nested groups only apply to routes in those groups", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("layer.tsx"),
+      parseRoute("(admin)/(dashboard)/layer.tsx"),
+      parseRoute("(admin)/(dashboard)/users/route.tsx"),
+      parseRoute("(admin)/settings/route.tsx"),
+      parseRoute("(other)/(dashboard)/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expectedAdminDashboardUsers = `  {
+    path: "/users",
+    load: () => import("./(admin)/(dashboard)/users/route.tsx"),
+    layers: [
+      () => import("./layer.tsx"),
+      () => import("./(admin)/(dashboard)/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedAdminDashboardUsers)
+
+    const expectedAdminSettings = `  {
+    path: "/settings",
+    load: () => import("./(admin)/settings/route.tsx"),
+    layers: [
+      () => import("./layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedAdminSettings)
+
+    const expectedOtherDashboard = `  {
+    path: "/",
+    load: () => import("./(other)/(dashboard)/route.tsx"),
+    layers: [
+      () => import("./layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedOtherDashboard)
+  })
+
+  t.it("similar directory names do not match (user vs users)", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("user/layer.tsx"),
+      parseRoute("user/route.tsx"),
+      parseRoute("users/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expectedUser = `  {
+    path: "/user",
+    load: () => import("./user/route.tsx"),
+    layers: [
+      () => import("./user/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedUser)
+
+    const expectedUsers = `  {
+    path: "/users",
+    load: () => import("./users/route.tsx"),
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedUsers)
+  })
+
+  t.it("mixed groups and literals layer matching", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("(admin)/users/layer.tsx"),
+      parseRoute("(admin)/users/[userId]/route.tsx"),
+      parseRoute("users/route.tsx"),
+      parseRoute("(admin)/posts/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expectedAdminUsersId = `  {
+    path: "/users/[userId]",
+    load: () => import("./(admin)/users/[userId]/route.tsx"),
+    layers: [
+      () => import("./(admin)/users/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedAdminUsersId)
+
+    const expectedUsers = `  {
+    path: "/users",
+    load: () => import("./users/route.tsx"),
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedUsers)
+
+    const expectedAdminPosts = `  {
+    path: "/posts",
+    load: () => import("./(admin)/posts/route.tsx"),
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedAdminPosts)
+  })
+
+  t.it("param directory layer only applies to routes in that dir", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("[tenantId]/layer.tsx"),
+      parseRoute("[tenantId]/settings/route.tsx"),
+      parseRoute("other/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expectedTenantSettings = `  {
+    path: "/[tenantId]/settings",
+    load: () => import("./[tenantId]/settings/route.tsx"),
+    layers: [
+      () => import("./[tenantId]/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedTenantSettings)
+
+    const expectedOther = `  {
+    path: "/other",
+    load: () => import("./other/route.tsx"),
+  },`
+
+    t
+      .expect(code)
+      .toContain(expectedOther)
+  })
+
+  t.it(
+    "optional param directory layer only applies to routes in that dir",
+    () => {
+      const handles: RouteHandle[] = [
+        parseRoute("[[id]]/layer.tsx"),
+        parseRoute("[[id]]/settings/route.tsx"),
+        parseRoute("other/route.tsx"),
+      ]
+
+      const code = FileRouterCodegen.generateCode(handles)
+
+      const expectedIdSettings = `  {
+    path: "/[[id]]/settings",
+    load: () => import("./[[id]]/settings/route.tsx"),
+    layers: [
+      () => import("./[[id]]/layer.tsx"),
+    ],
+  },`
+
+      t
+        .expect(code)
+        .toContain(expectedIdSettings)
+
+      const expectedOther = `  {
+    path: "/other",
+    load: () => import("./other/route.tsx"),
+  },`
+
+      t
+        .expect(code)
+        .toContain(expectedOther)
+    },
+  )
+
+  t.it("layer and route at same directory level", () => {
+    const handles: RouteHandle[] = [
+      parseRoute("users/layer.tsx"),
+      parseRoute("users/route.tsx"),
+    ]
+
+    const code = FileRouterCodegen.generateCode(handles)
+
+    const expected = `  {
+    path: "/users",
+    load: () => import("./users/route.tsx"),
+    layers: [
+      () => import("./users/layer.tsx"),
+    ],
+  },`
+
+    t
+      .expect(code)
+      .toContain(expected)
+  })
 })
 
 const effect = effectFn()
@@ -478,7 +664,7 @@ t.it("update() > writes file", () =>
 
       t
         .expect(content)
-        .toContain("export const modules =")
+        .toContain("export const routes =")
     })
     .pipe(
       Effect.provide(MemoryFileSystem.layerWith(update_FilesWithRoutes)),

package/src/FileRouterCodegen.ts

@@ -52,29 +52,6 @@ export function validateRouteModules(
   })
 }
 
-/**
- * Converts a segment to RouteModuleSegment format
- */
-function segmentToModuleSegment(segment: FileRouter.Segment): string | null {
-  if ("literal" in segment) {
-    return `{ literal: "${segment.literal}" }`
-  }
-  if ("group" in segment) {
-    return `{ group: "${segment.group}" }`
-  }
-  if ("param" in segment) {
-    return segment.optional
-      ? `{ param: "${segment.param}", optional: true }`
-      : `{ param: "${segment.param}" }`
-  }
-  if ("rest" in segment) {
-    return segment.optional
-      ? `{ rest: "${segment.rest}", optional: true }`
-      : `{ rest: "${segment.rest}" }`
-  }
-  return null
-}
-
 export function generateCode(
   handles: FileRouter.OrderedRouteHandles,
 ): string {
@@ -96,30 +73,22 @@ export function generateCode(
     routesByPath.set(handle.routePath, existing)
   }
 
-  // Generate module definitions
-  const modules: string[] = []
+  // Generate route definitions
+  const routes: string[] = []
 
   // Helper to check if layer's path is an ancestor of route's path
   const layerMatchesRoute = (
     layer: FileRouter.RouteHandle,
     route: FileRouter.RouteHandle,
   ): boolean => {
-    // Exclude handle segment (last segment) from comparison
-    const layerLength = layer.segments.length - 1
-    const routeLength = route.segments.length - 1
+    // Get the directory of the layer (strip the filename like layer.tsx)
+    const layerDir = layer.modulePath.replace(/\/?(layer)\.(tsx?|jsx?)$/, "")
 
-    // Layer's segments must be a prefix of route's segments
-    if (layerLength > routeLength) {
-      return false
-    }
+    // Layer at root (empty layerDir) applies to all routes
+    if (layerDir === "") return true
 
-    for (let i = 0; i < layerLength; i++) {
-      if (!FileRouter.isSegmentEqual(layer.segments[i], route.segments[i])) {
-        return false
-      }
-    }
-
-    return true
+    // Route's modulePath must start with the layer's directory
+    return route.modulePath.startsWith(layerDir + "/")
   }
 
   // Find layers for each route by walking up the path hierarchy
@@ -146,17 +115,6 @@ export function generateCode(
       currentPath = parentPath || "/"
     }
 
-    // Generate segments array
-    const pathSegments = route.segments.filter(seg => !("handle" in seg))
-    const segmentsCode = pathSegments
-      .map(segmentToModuleSegment)
-      .filter(Boolean)
-      .join(",\n      ") + (pathSegments.length > 0 ? "," : "")
-
-    const segmentsArray = segmentsCode
-      ? `[\n      ${segmentsCode}\n    ]`
-      : "[]"
-
     // Generate layers array
     const layersCode = allLayers.length > 0
       ? `\n    layers: [\n      ${
@@ -166,28 +124,27 @@ export function generateCode(
       },\n    ],`
       : ""
 
-    const moduleCode = `  {
+    const routeCode = `  {
     path: "${path}",
-    segments: ${segmentsArray},
     load: () => import("./${route.modulePath}"),${layersCode}
   },`
 
-    modules.push(moduleCode)
+    routes.push(routeCode)
   }
 
   const header = `/**
  * Auto-generated by effect-start.
  */`
 
-  const modulesArray = modules.length > 0
-    ? `[\n${modules.join("\n")}\n]`
+  const routesArray = routes.length > 0
+    ? `[\n${routes.join("\n")}\n]`
     : "[]"
 
   return `${header}
 
 import type { Router } from "${routerModuleId}"
 
-export const modules = ${modulesArray} as const
+export const routes = ${routesArray} as const
 `
 }
 

package/src/FileRouterPattern.test.ts

@@ -0,0 +1,116 @@
+import * as t from "bun:test"
+import * as FileRouterPattern from "./FileRouterPattern.ts"
+
+t.it("empty path", () => {
+  t.expect(FileRouterPattern.parse("")).toEqual([])
+  t.expect(FileRouterPattern.parse("/")).toEqual([])
+})
+
+t.it("groups", () => {
+  t.expect(FileRouterPattern.parse("(admin)")).toEqual([
+    { _tag: "GroupSegment", name: "admin" },
+  ])
+  t.expect(FileRouterPattern.parse("/(admin)/users")).toEqual([
+    { _tag: "GroupSegment", name: "admin" },
+    { _tag: "LiteralSegment", value: "users" },
+  ])
+  t.expect(FileRouterPattern.parse("(auth)/login/(step1)")).toEqual([
+    { _tag: "GroupSegment", name: "auth" },
+    { _tag: "LiteralSegment", value: "login" },
+    { _tag: "GroupSegment", name: "step1" },
+  ])
+})
+
+t.it("handle files parsed as Literal", () => {
+  t.expect(FileRouterPattern.parse("route.ts")).toEqual([
+    { _tag: "LiteralSegment", value: "route.ts" },
+  ])
+  t.expect(FileRouterPattern.parse("/api/route.js")).toEqual([
+    { _tag: "LiteralSegment", value: "api" },
+    { _tag: "LiteralSegment", value: "route.js" },
+  ])
+  t.expect(FileRouterPattern.parse("layer.tsx")).toEqual([
+    { _tag: "LiteralSegment", value: "layer.tsx" },
+  ])
+  t.expect(FileRouterPattern.parse("/blog/layer.jsx")).toEqual([
+    { _tag: "LiteralSegment", value: "blog" },
+    { _tag: "LiteralSegment", value: "layer.jsx" },
+  ])
+})
+
+t.it("params and rest", () => {
+  t.expect(FileRouterPattern.parse("users/[userId]/posts")).toEqual([
+    { _tag: "LiteralSegment", value: "users" },
+    { _tag: "ParamSegment", name: "userId" },
+    { _tag: "LiteralSegment", value: "posts" },
+  ])
+
+  t.expect(FileRouterPattern.parse("api/[[...path]]")).toEqual([
+    { _tag: "LiteralSegment", value: "api" },
+    { _tag: "RestSegment", name: "path", optional: true },
+  ])
+})
+
+t.it("invalid paths", () => {
+  t.expect(() => FileRouterPattern.parse("$...")).toThrow()
+  t.expect(() => FileRouterPattern.parse("invalid%char")).toThrow()
+  t.expect(() => FileRouterPattern.parse("path with spaces")).toThrow()
+})
+
+t.it("segments with extensions (literal with dots)", () => {
+  t.expect(FileRouterPattern.parse("events.json/route.ts")).toEqual([
+    { _tag: "LiteralSegment", value: "events.json" },
+    { _tag: "LiteralSegment", value: "route.ts" },
+  ])
+})
+
+t.it("formatSegment", () => {
+  t
+    .expect(
+      FileRouterPattern.formatSegment({
+        _tag: "LiteralSegment",
+        value: "users",
+      }),
+    )
+    .toBe("users")
+  t
+    .expect(
+      FileRouterPattern.formatSegment({ _tag: "ParamSegment", name: "id" }),
+    )
+    .toBe("[id]")
+  t
+    .expect(
+      FileRouterPattern.formatSegment({ _tag: "GroupSegment", name: "admin" }),
+    )
+    .toBe("(admin)")
+  t
+    .expect(
+      FileRouterPattern.formatSegment({ _tag: "RestSegment", name: "path" }),
+    )
+    .toBe("[...path]")
+})
+
+t.it("format", () => {
+  t.expect(FileRouterPattern.format([])).toBe("/")
+  t
+    .expect(
+      FileRouterPattern.format([{ _tag: "LiteralSegment", value: "users" }]),
+    )
+    .toBe("/users")
+  t
+    .expect(
+      FileRouterPattern.format([
+        { _tag: "GroupSegment", name: "admin" },
+        { _tag: "LiteralSegment", value: "users" },
+      ]),
+    )
+    .toBe("/(admin)/users")
+  t
+    .expect(
+      FileRouterPattern.format([
+        { _tag: "LiteralSegment", value: "users" },
+        { _tag: "ParamSegment", name: "id" },
+      ]),
+    )
+    .toBe("/users/[id]")
+})