effect-start 0.9.0 → 0.10.0

package/src/FileRouterPattern.ts

@@ -0,0 +1,59 @@
+import * as RouterPattern from "./RouterPattern.ts"
+
+export type GroupSegment<
+  Name extends string = string,
+> = {
+  _tag: "GroupSegment"
+  name: Name
+}
+
+export type Segment =
+  | RouterPattern.Segment
+  | GroupSegment
+
+export function parse(pattern: string): Segment[] {
+  const trimmedPath = pattern.replace(/(^\/)|(\/$)/g, "")
+
+  if (trimmedPath === "") {
+    return []
+  }
+
+  const segmentStrings = trimmedPath
+    .split("/")
+    .filter(s => s !== "")
+
+  if (segmentStrings.length === 0) {
+    return []
+  }
+
+  const segments: (Segment | null)[] = segmentStrings.map(
+    (s): Segment | null => {
+      // (group) - Groups (FileRouter-specific)
+      const groupMatch = s.match(/^\((\w+)\)$/)
+      if (groupMatch) {
+        return { _tag: "GroupSegment", name: groupMatch[1] }
+      }
+
+      // Delegate to RouterPattern for all other segment types
+      return RouterPattern.parseSegment(s)
+    },
+  )
+
+  if (segments.some((seg) => seg === null)) {
+    throw new Error(
+      `Invalid path segment in "${pattern}": contains invalid characters or format`,
+    )
+  }
+
+  return segments as Segment[]
+}
+
+export function formatSegment(seg: Segment): string {
+  if (seg._tag === "GroupSegment") return `(${seg.name})`
+  return RouterPattern.formatSegment(seg)
+}
+
+export function format(segments: Segment[]): `/${string}` {
+  const joined = segments.map(formatSegment).join("/")
+  return (joined ? `/${joined}` : "/") as `/${string}`
+}

package/src/FileRouter_path.test.ts

@@ -1,132 +1,93 @@
 import * as t from "bun:test"
 import * as FileRouter from "./FileRouter.ts"
 
-t.it("empty path as null", () => {
-  t.expect(FileRouter.segmentPath("")).toEqual([])
-  t.expect(FileRouter.segmentPath("/")).toEqual([])
+t.it("empty path", () => {
+  t.expect(FileRouter.parse("")).toEqual([])
+  t.expect(FileRouter.parse("/")).toEqual([])
 })
 
-t.it("literal segments", () => {
-  t.expect(FileRouter.segmentPath("users")).toEqual([{ literal: "users" }])
-  t.expect(FileRouter.segmentPath("/users")).toEqual([{ literal: "users" }])
-  t.expect(FileRouter.segmentPath("users/")).toEqual([{ literal: "users" }])
-  t.expect(FileRouter.segmentPath("/users/create")).toEqual([
-    { literal: "users" },
-    { literal: "create" },
+t.it("groups", () => {
+  t.expect(FileRouter.parse("(admin)")).toEqual([
+    { _tag: "GroupSegment", name: "admin" },
   ])
-  t.expect(() => FileRouter.segmentPath("path with spaces")).toThrow()
-})
-
-t.it("dynamic parameters", () => {
-  t.expect(FileRouter.segmentPath("[userId]")).toEqual([{ param: "userId" }])
-  t.expect(FileRouter.segmentPath("/users/[userId]")).toEqual([
-    { literal: "users" },
-    { param: "userId" },
+  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" },
   ])
-  t
-    .expect(FileRouter.segmentPath("/posts/[postId]/comments/[commentId]"))
-    .toEqual([
-      { literal: "posts" },
-      { param: "postId" },
-      { literal: "comments" },
-      { param: "commentId" },
-    ])
 })
 
-t.it("rest parameters", () => {
-  t.expect(FileRouter.segmentPath("[[...rest]]")).toEqual([
-    { rest: "rest", optional: true },
+t.it("handle files parsed as Literal", () => {
+  t.expect(FileRouter.parse("route.ts")).toEqual([
+    { _tag: "LiteralSegment", value: "route.ts" },
   ])
-  t.expect(FileRouter.segmentPath("[...rest]")).toEqual([{ rest: "rest" }])
-  t.expect(FileRouter.segmentPath("/docs/[[...slug]]")).toEqual([
-    { literal: "docs" },
-    { rest: "slug", optional: true },
+  t.expect(FileRouter.parse("/api/route.js")).toEqual([
+    { _tag: "LiteralSegment", value: "api" },
+    { _tag: "LiteralSegment", value: "route.js" },
   ])
-  t.expect(FileRouter.segmentPath("/api/[...path]")).toEqual([
-    { literal: "api" },
-    { rest: "path" },
+  t.expect(FileRouter.parse("layer.tsx")).toEqual([
+    { _tag: "LiteralSegment", value: "layer.tsx" },
   ])
-})
-
-t.it("groups", () => {
-  t.expect(FileRouter.segmentPath("(admin)")).toEqual([{ group: "admin" }])
-  t.expect(FileRouter.segmentPath("/(admin)/users")).toEqual([
-    { group: "admin" },
-    { literal: "users" },
-  ])
-  t.expect(FileRouter.segmentPath("(auth)/login/(step1)")).toEqual([
-    { group: "auth" },
-    { literal: "login" },
-    { group: "step1" },
+  t.expect(FileRouter.parse("/blog/layer.jsx")).toEqual([
+    { _tag: "LiteralSegment", value: "blog" },
+    { _tag: "LiteralSegment", value: "layer.jsx" },
   ])
 })
 
-t.it("route handles", () => {
-  t.expect(FileRouter.segmentPath("route.ts")).toEqual([{ handle: "route" }])
-  t.expect(FileRouter.segmentPath("/api/route.js")).toEqual([
-    { literal: "api" },
-    { handle: "route" },
+t.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" },
   ])
-  t.expect(FileRouter.segmentPath("route.tsx")).toEqual([{ handle: "route" }])
-})
 
-t.it("layer handles", () => {
-  t.expect(FileRouter.segmentPath("layer.tsx")).toEqual([{ handle: "layer" }])
-  t.expect(FileRouter.segmentPath("layer.jsx")).toEqual([{ handle: "layer" }])
-  t.expect(FileRouter.segmentPath("layer.js")).toEqual([{ handle: "layer" }])
-  t.expect(FileRouter.segmentPath("/blog/layer.jsx")).toEqual([
-    { literal: "blog" },
-    { handle: "layer" },
-  ])
+  const layer = FileRouter.parseRoute("api/layer.ts")
+  t.expect(layer.handle).toBe("layer")
+  t.expect(layer.routePath).toBe("/api")
 })
 
-t.it("complex combinations", () => {
-  t.expect(FileRouter.segmentPath("/users/[userId]/posts/route.tsx")).toEqual([
-    { literal: "users" },
-    { param: "userId" },
-    { literal: "posts" },
-    { handle: "route" },
-  ])
-  t.expect(FileRouter.segmentPath("/api/v1/[[...path]]/route.ts")).toEqual([
-    { literal: "api" },
-    { literal: "v1" },
-    { rest: "path", optional: true },
-    { handle: "route" },
-  ])
-  t.expect(FileRouter.segmentPath("(admin)/users/route.tsx")).toEqual([
-    { group: "admin" },
-    { literal: "users" },
-    { handle: "route" },
+t.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" },
   ])
 })
 
-t.it("invalid paths", () => {
-  t.expect(() => FileRouter.segmentPath("$...")).toThrow()
-  t.expect(() => FileRouter.segmentPath("invalid%char")).toThrow()
-})
+t.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" },
+  ])
 
-t.it("param and rest types", () => {
-  t.expect(FileRouter.segmentPath("[a]")).toEqual([{ param: "a" }])
-  t.expect(FileRouter.segmentPath("[...rest]")).toEqual([{ rest: "rest" }])
-  t.expect(FileRouter.segmentPath("[[...rest]]")).toEqual([
-    { rest: "rest", optional: true },
+  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 },
   ])
 })
 
-t.it("extractRoute - users/route.ts", () => {
-  t.expect(FileRouter.segmentPath("users/route.ts")).toEqual([
-    { literal: "users" },
-    { handle: "route" },
-  ])
+t.it("invalid paths", () => {
+  t.expect(() => FileRouter.parse("$...")).toThrow()
+  t.expect(() => FileRouter.parse("invalid%char")).toThrow()
+  t.expect(() => FileRouter.parse("path with spaces")).toThrow()
 })
 
-t.it("segments with extensions", () => {
-  t.expect(FileRouter.segmentPath("events.json/route.ts")).toEqual([
-    { literal: "events.json" },
-    { handle: "route" },
-  ])
-  t.expect(FileRouter.segmentPath("config.yaml.backup/route.ts")).toEqual([
-    { literal: "config.yaml.backup" },
-    { handle: "route" },
+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" },
   ])
 })

package/src/FileSystemExtra.test.ts

@@ -0,0 +1,226 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as t from "bun:test"
+import { MemoryFileSystem } from "effect-memfs"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Function from "effect/Function"
+import * as Stream from "effect/Stream"
+import * as FileSystemExtra from "./FileSystemExtra.ts"
+
+t.describe(`${FileSystemExtra.watchSource.name}`, () => {
+  t.it("emits events for file creation", () =>
+    Effect
+      .gen(function*() {
+        const fs = yield* FileSystem.FileSystem
+        const watchDir = "/watch-test"
+
+        const fiber = yield* Function.pipe(
+          FileSystemExtra.watchSource({ path: watchDir }),
+          Stream.take(1),
+          Stream.runCollect,
+          Effect.fork,
+        )
+
+        yield* Effect.sleep(1)
+
+        yield* fs.writeFileString(`${watchDir}/test.ts`, "const x = 1")
+
+        const events = yield* Fiber.join(fiber)
+
+        t.expect(Chunk.size(events)).toBeGreaterThan(0)
+        const first = Chunk.unsafeGet(events, 0)
+        t.expect(first.path).toContain("test.ts")
+        t.expect(["rename", "change"]).toContain(first.eventType)
+        t.expect(first.filename).toBe("test.ts")
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(
+          MemoryFileSystem.layerWith({ "/watch-test/.gitkeep": "" }),
+        ),
+        Effect.runPromise,
+      ))
+
+  t.it(
+    "emits change event for file modification",
+    () =>
+      Effect
+        .gen(function*() {
+          const fs = yield* FileSystem.FileSystem
+          const watchDir = "/watch-mod"
+          const filePath = `${watchDir}/file.ts`
+
+          const fiber = yield* Function.pipe(
+            FileSystemExtra.watchSource({ path: watchDir }),
+            Stream.take(1),
+            Stream.runCollect,
+            Effect.fork,
+          )
+
+          yield* Effect.sleep(1)
+          yield* fs.writeFileString(filePath, "modified")
+
+          const events = yield* Fiber.join(fiber)
+
+          t.expect(Chunk.size(events)).toBeGreaterThan(0)
+          t.expect(Chunk.unsafeGet(events, 0).eventType).toBe("change")
+        })
+        .pipe(
+          Effect.scoped,
+          Effect.provide(
+            MemoryFileSystem.layerWith({ "/watch-mod/file.ts": "initial" }),
+          ),
+          Effect.runPromise,
+        ),
+  )
+
+  t.it("applies custom filter", () =>
+    Effect
+      .gen(function*() {
+        const fs = yield* FileSystem.FileSystem
+        const watchDir = "/watch-filter"
+
+        const fiber = yield* Function.pipe(
+          FileSystemExtra.watchSource({
+            path: watchDir,
+            filter: FileSystemExtra.filterSourceFiles,
+          }),
+          Stream.take(1),
+          Stream.runCollect,
+          Effect.fork,
+        )
+
+        yield* Effect.sleep(1)
+        yield* fs.writeFileString(`${watchDir}/ignored.txt`, "ignored")
+        yield* Effect.sleep(1)
+        yield* fs.writeFileString(`${watchDir}/included.ts`, "included")
+
+        const events = yield* Fiber.join(fiber)
+
+        t.expect(Chunk.size(events)).toBe(1)
+        t.expect(Chunk.unsafeGet(events, 0).path).toContain("included.ts")
+      })
+      .pipe(
+        Effect.scoped,
+        Effect.provide(
+          MemoryFileSystem.layerWith({ "/watch-filter/.gitkeep": "" }),
+        ),
+        Effect.runPromise,
+      ))
+})
+
+t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
+  t.it("matches source file extensions", () => {
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.ts",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.tsx",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.js",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.jsx",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.json",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.css",
+        }),
+      )
+      .toBe(true)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.html",
+        }),
+      )
+      .toBe(true)
+  })
+
+  t.it("rejects non-source files", () => {
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.txt",
+        }),
+      )
+      .toBe(false)
+    t
+      .expect(
+        FileSystemExtra.filterSourceFiles({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b.md",
+        }),
+      )
+      .toBe(false)
+  })
+})
+
+t.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
+  t.it("matches directories", () => {
+    t
+      .expect(
+        FileSystemExtra.filterDirectory({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b/",
+        }),
+      )
+      .toBe(true)
+  })
+
+  t.it("rejects files", () => {
+    t
+      .expect(
+        FileSystemExtra.filterDirectory({
+          eventType: "change",
+          filename: "x",
+          path: "/a/b",
+        }),
+      )
+      .toBe(false)
+  })
+})

package/src/FileSystemExtra.ts

@@ -1,9 +1,8 @@
 import * as Error from "@effect/platform/Error"
+import * as FileSystem from "@effect/platform/FileSystem"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Stream from "effect/Stream"
-import type { WatchOptions } from "node:fs"
-import * as NFSP from "node:fs/promises"
 import * as NPath from "node:path"
 
 const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/
@@ -14,69 +13,45 @@ export type WatchEvent = {
   path: string
 }
 
-/**
- * Filter for source files based on file extension.
- */
 export const filterSourceFiles = (event: WatchEvent): boolean => {
   return SOURCE_FILENAME.test(event.path)
 }
 
-/**
- * Filter for directories (paths ending with /).
- */
 export const filterDirectory = (event: WatchEvent): boolean => {
   return event.path.endsWith("/")
 }
 
-/**
- * `@effect/platform` doesn't support recursive file watching.
- * This function implements that [2025-05-19]
- * Additionally, the filename is resolved to an absolute path.
- * If the path is a directory, it appends / to the path.
- */
 export const watchSource = (
-  opts?: WatchOptions & {
+  opts?: {
     path?: string
+    recursive?: boolean
     filter?: (event: WatchEvent) => boolean
   },
-): Stream.Stream<WatchEvent, Error.SystemError> => {
+): Stream.Stream<WatchEvent, Error.PlatformError, FileSystem.FileSystem> => {
   const baseDir = opts?.path ?? process.cwd()
   const customFilter = opts?.filter
 
-  let stream: Stream.Stream<NFSP.FileChangeInfo<string>, Error.SystemError>
-  try {
-    stream = Stream.fromAsyncIterable(
-      NFSP.watch(baseDir, {
-        persistent: opts?.persistent ?? false,
-        recursive: opts?.recursive ?? true,
-        encoding: opts?.encoding,
-        signal: opts?.signal,
-      }),
-      error => handleWatchError(error, baseDir),
-    )
-  } catch (e) {
-    const err = handleWatchError(e, baseDir)
-
-    stream = Stream.fail(err)
-  }
-
-  const changes = Function.pipe(
-    stream,
+  return Function.pipe(
+    Stream.unwrap(
+      Effect.map(
+        FileSystem.FileSystem,
+        fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
+      ),
+    ),
     Stream.mapEffect(e =>
-      Effect.promise(() => {
-        const resolvedPath = NPath.resolve(baseDir, e.filename!)
-        return NFSP
-          .stat(resolvedPath)
-          .then(stat => ({
-            eventType: e.eventType as "rename" | "change",
-            filename: e.filename!,
-            path: stat.isDirectory() ? `${resolvedPath}/` : resolvedPath,
-          }))
-          .catch(() => ({
-            eventType: e.eventType as "rename" | "change",
-            filename: e.filename!,
-            path: resolvedPath,
-          }))
+      Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem
+        const relativePath = NPath.relative(baseDir, e.path)
+        const eventType: "change" | "rename" = e._tag === "Update"
+          ? "change"
+          : "rename"
+        const info = yield* Effect.either(fs.stat(e.path))
+        const isDir = info._tag === "Right" && info.right.type === "Directory"
+        return {
+          eventType,
+          filename: relativePath,
+          path: isDir ? `${e.path}/` : e.path,
+        }
       })
     ),
     customFilter ? Stream.filter(customFilter) : Function.identity,
@@ -88,15 +63,4 @@ export const watchSource = (
       strategy: "enforce",
     }),
   )
-
-  return changes
 }
-
-const handleWatchError = (error: any, path: string) =>
-  new Error.SystemError({
-    module: "FileSystem",
-    reason: "Unknown",
-    method: "watch",
-    pathOrDescriptor: path,
-    cause: error,
-  })

package/src/HttpUtils.test.ts

@@ -0,0 +1,68 @@
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import * as t from "bun:test"
+
+import * as HttpUtils from "./HttpUtils.ts"
+
+const makeRequest = (url: string, headers: Record<string, string> = {}) =>
+  HttpServerRequest.fromWeb(
+    new Request(`http://test${url}`, { headers }),
+  )
+
+t.describe("makeUrlFromRequest", () => {
+  t.it("uses Host header for relative URL", () => {
+    const request = makeRequest("/api/users", {
+      host: "example.com",
+    })
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("http://example.com/api/users")
+  })
+
+  t.it("uses Origin header when present (takes precedence over Host)", () => {
+    const request = makeRequest("/api/users", {
+      origin: "https://app.example.com",
+      host: "example.com",
+    })
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("https://app.example.com/api/users")
+  })
+
+  t.it("uses X-Forwarded-Proto for protocol behind reverse proxy", () => {
+    const request = makeRequest("/api/users", {
+      host: "example.com",
+      "x-forwarded-proto": "https",
+    })
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("https://example.com/api/users")
+  })
+
+  t.it("falls back to http://localhost when no headers", () => {
+    const request = makeRequest("/api/users", {})
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("http://localhost/api/users")
+  })
+
+  t.it("handles URL with query parameters", () => {
+    const request = makeRequest("/search?q=test&page=1", {
+      host: "example.com",
+    })
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("http://example.com/search?q=test&page=1")
+    t.expect(url.searchParams.get("q")).toBe("test")
+    t.expect(url.searchParams.get("page")).toBe("1")
+  })
+
+  t.it("handles root path", () => {
+    const request = makeRequest("/", {
+      host: "example.com",
+    })
+    const url = HttpUtils.makeUrlFromRequest(request)
+
+    t.expect(url.href).toBe("http://example.com/")
+    t.expect(url.pathname).toBe("/")
+  })
+})