effect-start 0.14.0 → 0.16.0

package/src/FileRouterCodegen.ts

@@ -6,8 +6,6 @@ import * as Schema from "effect/Schema"
 import * as NPath from "node:path"
 import * as FileRouter from "./FileRouter.ts"
 import * as FileRouterPattern from "./FileRouterPattern.ts"
-import * as Route from "./Route.ts"
-import * as Router from "./Router.ts"
 import * as SchemaExtra from "./SchemaExtra.ts"
 
 export function validateRouteModule(
@@ -16,10 +14,13 @@ export function validateRouteModule(
   if (typeof module !== "object" || module === null) {
     return false
   }
+
   if (!("default" in module)) {
     return false
   }
-  return Route.isRouteSet(module.default)
+
+  // TODO: verify we're exporting a proper shape
+  return true
 }
 
 export function generatePathParamsSchema(
@@ -79,7 +80,8 @@ export function validateRouteModules(
       }
 
       const routeSet = module.default
-      const userSchema = routeSet.schema?.PathParams
+      // extract user schema
+      const userSchema = undefined
 
       if (
         expectedSchema
@@ -187,8 +189,6 @@ export function generateCode(
 
   return `${header}
 
-import type { Router } from "${routerModuleId}"
-
 export const routes = ${routesArray} as const
 `
 }

package/src/FileRouterPattern.test.ts

@@ -1,71 +1,100 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as FileRouterPattern from "./FileRouterPattern.ts"
 
-t.it("empty path", () => {
-  t.expect(FileRouterPattern.parse("")).toEqual([])
-  t.expect(FileRouterPattern.parse("/")).toEqual([])
+test.it("empty path", () => {
+  test
+    .expect(FileRouterPattern.parse(""))
+    .toEqual([])
+  test
+    .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" },
-  ])
+test.it("groups", () => {
+  test
+    .expect(FileRouterPattern.parse("(admin)"))
+    .toEqual([
+      { _tag: "GroupSegment", name: "admin" },
+    ])
+  test
+    .expect(FileRouterPattern.parse("/(admin)/users"))
+    .toEqual([
+      { _tag: "GroupSegment", name: "admin" },
+      { _tag: "LiteralSegment", value: "users" },
+    ])
+  test
+    .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" },
-  ])
+test.it("handle files parsed as Literal", () => {
+  test
+    .expect(FileRouterPattern.parse("route.ts"))
+    .toEqual([
+      { _tag: "LiteralSegment", value: "route.ts" },
+    ])
+  test
+    .expect(FileRouterPattern.parse("/api/route.js"))
+    .toEqual([
+      { _tag: "LiteralSegment", value: "api" },
+      { _tag: "LiteralSegment", value: "route.js" },
+    ])
+  test
+    .expect(FileRouterPattern.parse("layer.tsx"))
+    .toEqual([
+      { _tag: "LiteralSegment", value: "layer.tsx" },
+    ])
+  test
+    .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 },
-  ])
+test.it("params and rest", () => {
+  test
+    .expect(FileRouterPattern.parse("users/[userId]/posts"))
+    .toEqual([
+      { _tag: "LiteralSegment", value: "users" },
+      { _tag: "ParamSegment", name: "userId" },
+      { _tag: "LiteralSegment", value: "posts" },
+    ])
+  test
+    .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()
+test.it("invalid paths", () => {
+  test
+    .expect(() => FileRouterPattern.parse("$..."))
+    .toThrow()
+  test
+    .expect(() => FileRouterPattern.parse("invalid%char"))
+    .toThrow()
+  test
+    .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" },
-  ])
+test.it("segments with extensions (literal with dots)", () => {
+  test
+    .expect(FileRouterPattern.parse("events.json/route.ts"))
+    .toEqual([
+      { _tag: "LiteralSegment", value: "events.json" },
+      { _tag: "LiteralSegment", value: "route.ts" },
+    ])
 })
 
-t.it("formatSegment", () => {
-  t
+test.it("formatSegment", () => {
+  test
     .expect(
       FileRouterPattern.formatSegment({
         _tag: "LiteralSegment",
@@ -73,31 +102,33 @@ t.it("formatSegment", () => {
       }),
     )
     .toBe("users")
-  t
+  test
     .expect(
       FileRouterPattern.formatSegment({ _tag: "ParamSegment", name: "id" }),
     )
     .toBe("[id]")
-  t
+  test
     .expect(
       FileRouterPattern.formatSegment({ _tag: "GroupSegment", name: "admin" }),
     )
     .toBe("(admin)")
-  t
+  test
     .expect(
       FileRouterPattern.formatSegment({ _tag: "RestSegment", name: "path" }),
     )
     .toBe("[...path]")
 })
 
-t.it("format", () => {
-  t.expect(FileRouterPattern.format([])).toBe("/")
-  t
+test.it("format", () => {
+  test
+    .expect(FileRouterPattern.format([]))
+    .toBe("/")
+  test
     .expect(
       FileRouterPattern.format([{ _tag: "LiteralSegment", value: "users" }]),
     )
     .toBe("/users")
-  t
+  test
     .expect(
       FileRouterPattern.format([
         { _tag: "GroupSegment", name: "admin" },
@@ -105,7 +136,7 @@ t.it("format", () => {
       ]),
     )
     .toBe("/(admin)/users")
-  t
+  test
     .expect(
       FileRouterPattern.format([
         { _tag: "LiteralSegment", value: "users" },

package/src/FileRouter_files.test.ts

@@ -1,4 +1,4 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import { MemoryFileSystem } from "effect-memfs"
 import * as Effect from "effect/Effect"
 import * as FileRouter from "./FileRouter.ts"
@@ -15,13 +15,13 @@ const Files = {
 
 const effect = effectFn()
 
-t.it("walks routes", () =>
+test.it("walks routes", () =>
   effect(function*() {
     const files = yield* FileRouter.walkRoutesDirectory("/routes").pipe(
       Effect.provide(MemoryFileSystem.layerWith(Files)),
     )
 
-    t
+    test
       .expect(
         files.map(v => v.modulePath),
       )
@@ -35,7 +35,7 @@ t.it("walks routes", () =>
       ])
   }))
 
-t.it("walks routes with rest", () =>
+test.it("walks routes with rest", () =>
   effect(function*() {
     const files = yield* FileRouter.walkRoutesDirectory("/routes").pipe(
       Effect.provide(
@@ -47,7 +47,7 @@ t.it("walks routes with rest", () =>
       ),
     )
 
-    t
+    test
       .expect(
         files.map(v => v.modulePath),
       )

package/src/FileRouter_path.test.ts

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

package/src/FileRouter_tree.test.ts

@@ -1,7 +1,7 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as FileRouter from "./FileRouter.ts"
 
-t.it("tree with root only", () => {
+test.it("tree with root only", () => {
   const handles = [
     "route.tsx",
     "layer.tsx",
@@ -9,31 +9,35 @@ t.it("tree with root only", () => {
     .map(FileRouter.parseRoute)
   const tree = FileRouter.treeFromRouteHandles(handles)
 
-  t.expect(tree).toEqual({
-    path: "/",
-    handles: [
-      t.expect.objectContaining({
-        handle: "route",
-      }),
-      t.expect.objectContaining({
-        handle: "layer",
-      }),
-    ],
-  })
+  test
+    .expect(tree)
+    .toEqual({
+      path: "/",
+      handles: [
+        test.expect.objectContaining({
+          handle: "route",
+        }),
+        test.expect.objectContaining({
+          handle: "layer",
+        }),
+      ],
+    })
 })
 
-t.it("tree without root", () => {
+test.it("tree without root", () => {
   const handles = []
     .map(FileRouter.parseRoute)
   const tree = FileRouter.treeFromRouteHandles(handles)
 
-  t.expect(tree).toEqual({
-    path: "/",
-    handles: [],
-  })
+  test
+    .expect(tree)
+    .toEqual({
+      path: "/",
+      handles: [],
+    })
 })
 
-t.it("deep tree", () => {
+test.it("deep tree", () => {
   const handles = [
     "users/route.tsx",
     "users/layer.tsx",
@@ -43,41 +47,43 @@ t.it("deep tree", () => {
     .map(FileRouter.parseRoute)
   const tree = FileRouter.treeFromRouteHandles(handles)
 
-  t.expect(tree).toEqual({
-    path: "/",
-    handles: [
-      t.expect.objectContaining({
-        handle: "layer",
-      }),
-    ],
-    children: [
-      {
-        path: "/users",
-        handles: [
-          t.expect.objectContaining({
-            handle: "route",
-          }),
-          t.expect.objectContaining({
-            handle: "layer",
-          }),
-        ],
-        children: [
-          {
-            path: "/[userId]",
-            handles: [
-              t.expect.objectContaining({
-                handle: "route",
-              }),
-            ],
-          },
-        ],
-      },
-    ],
-  })
+  test
+    .expect(tree)
+    .toEqual({
+      path: "/",
+      handles: [
+        test.expect.objectContaining({
+          handle: "layer",
+        }),
+      ],
+      children: [
+        {
+          path: "/users",
+          handles: [
+            test.expect.objectContaining({
+              handle: "route",
+            }),
+            test.expect.objectContaining({
+              handle: "layer",
+            }),
+          ],
+          children: [
+            {
+              path: "/[userId]",
+              handles: [
+                test.expect.objectContaining({
+                  handle: "route",
+                }),
+              ],
+            },
+          ],
+        },
+      ],
+    })
 })
 
-t.it("throws on overlapping routes from groups", () => {
-  t
+test.it("throws on overlapping routes from groups", () => {
+  test
     .expect(() => {
       const handles = [
         "(admin)/users/route.tsx",
@@ -92,8 +98,8 @@ t.it("throws on overlapping routes from groups", () => {
     .toThrow("Conflicting routes detected at path /users")
 })
 
-t.it("throws on overlapping routes with same path", () => {
-  t
+test.it("throws on overlapping routes with same path", () => {
+  test
     .expect(() => {
       const handles = [
         "about/route.tsx",
@@ -108,8 +114,8 @@ t.it("throws on overlapping routes with same path", () => {
     .toThrow("Conflicting routes detected at path /about")
 })
 
-t.it("allows route and layer at same path", () => {
-  t
+test.it("allows route and layer at same path", () => {
+  test
     .expect(() => {
       const handles = [
         "users/route.tsx",