effect-start 0.14.0 → 0.15.0

package/src/RouterPattern.ts

@@ -1,4 +1,4 @@
-import type * as Route from "./Route.ts"
+export type RouterPattern = `/${string}`
 
 export type ParamDelimiter = "_" | "-" | "." | "," | ";" | "!" | "@" | "~"
 export type ParamPrefix = `${string}${ParamDelimiter}` | ""
@@ -206,7 +206,7 @@ function colonParamSegment(segment: Segment): string {
  * - `[[...param]]` → `/`, `/*`
  * - `pk_[id]` → `pk_:id`
  */
-export function toColon(path: Route.RoutePattern): string[] {
+export function toColon(path: RouterPattern): string[] {
   return buildPaths(parse(path), colonParamSegment, "/*")
 }
 
@@ -221,7 +221,7 @@ export const toHono = toColon
  * - `[[...param]]` → `/`, `/*param`
  * - `pk_[id]` → `pk_:id`
  */
-export function toExpress(path: Route.RoutePattern): string[] {
+export function toExpress(path: RouterPattern): string[] {
   const segments = parse(path)
   const optionalRestIndex = segments.findIndex(
     (s) => s._tag === "RestSegment" && s.optional,
@@ -291,7 +291,7 @@ export function toExpress(path: Route.RoutePattern): string[] {
  * - `[[...param]]` → `/`, `/*`
  * - `pk_[id]` → `pk_:id`
  */
-export function toEffect(path: Route.RoutePattern): string[] {
+export function toEffect(path: RouterPattern): string[] {
   return buildPaths(parse(path), colonParamSegment, "/*")
 }
 
@@ -304,7 +304,7 @@ export function toEffect(path: Route.RoutePattern): string[] {
  * - `[[...param]]` → `:param*`
  * - `pk_[id]` → `pk_:id`
  */
-export function toURLPattern(path: Route.RoutePattern): string[] {
+export function toURLPattern(path: RouterPattern): string[] {
   const segments = parse(path)
   const joined = segments
     .map((segment) => {
@@ -332,7 +332,7 @@ export function toURLPattern(path: Route.RoutePattern): string[] {
  * - `[[...param]]` → `/`, `$`
  * - `pk_[id]` → (not supported, emits `pk_$id`)
  */
-export function toRemix(path: Route.RoutePattern): string[] {
+export function toRemix(path: RouterPattern): string[] {
   const segments = parse(path)
   const optionalRestIndex = segments.findIndex(
     (s) => s._tag === "RestSegment" && s.optional,
@@ -377,7 +377,7 @@ export function toRemix(path: Route.RoutePattern): string[] {
  * - `[[...param]]` → `/`, `/*` (two routes)
  * - `pk_[id]` → `pk_:id`
  */
-export function toBun(path: Route.RoutePattern): string[] {
+export function toBun(path: RouterPattern): string[] {
   const segments = parse(path)
 
   const optionalIndex = segments.findIndex(

package/src/Start.ts

@@ -8,7 +8,7 @@ import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as BunHttpServer from "./bun/BunHttpServer.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
-import * as NodeFileSystem from "./NodeFileSystem.ts"
+import * as NodeFileSystem from "./node/FileSystem.ts"
 import * as StartApp from "./StartApp.ts"
 
 export function layer<
@@ -45,13 +45,13 @@ export function serve<ROut, E>(
   )
 
   return Function.pipe(
-    BunHttpServer.layerFileRouter(),
+    BunHttpServer.layerAuto(),
     HttpServer.withLogAddress,
     Layer.provide(appLayer),
     Layer.provide([
       FetchHttpClient.layer,
       HttpRouter.Default.Live,
-      BunHttpServer.layerServer(),
+      BunHttpServer.layer(),
       NodeFileSystem.layer,
       StartApp.layer(),
     ]),

package/src/TuplePathPattern.ts

@@ -0,0 +1,64 @@
+export type PathTuple = ReadonlyArray<
+  string | [string, string?, string?] | [[string]]
+>
+
+export function format(tuple: PathTuple): `/${string}` {
+  return "/" + tuple
+    .map((el) => {
+      if (typeof el === "string") return el
+      if (Array.isArray(el[0])) return "[[" + el[0][0] + "]]"
+      const [name, suffix, prefix] = el
+      return (prefix ?? "") + "[" + name + "]" + (suffix ?? "")
+    })
+    .join("/") as `/${string}`
+}
+
+export function toColon(tuple: PathTuple): string {
+  return "/" + tuple
+    .map((el) => {
+      if (typeof el === "string") return el
+      if (Array.isArray(el[0])) return "*"
+      const [name, suffix, prefix] = el
+      return (prefix ?? "") + ":" + name + (suffix ?? "")
+    })
+    .join("/")
+}
+
+export const toHono = toColon
+
+export function toExpress(tuple: PathTuple): string {
+  return "/" + tuple
+    .map((el) => {
+      if (typeof el === "string") return el
+      if (Array.isArray(el[0])) return "*" + el[0][0]
+      const [name, suffix, prefix] = el
+      return (prefix ?? "") + ":" + name + (suffix ?? "")
+    })
+    .join("/")
+}
+
+export const toEffect = toColon
+
+export function toURLPattern(tuple: PathTuple): string {
+  return "/" + tuple
+    .map((el) => {
+      if (typeof el === "string") return el
+      if (Array.isArray(el[0])) return ":" + el[0][0] + "+"
+      const [name, suffix, prefix] = el
+      return (prefix ?? "") + ":" + name + (suffix ?? "")
+    })
+    .join("/")
+}
+
+export function toRemix(tuple: PathTuple): string {
+  return "/" + tuple
+    .map((el) => {
+      if (typeof el === "string") return el
+      if (Array.isArray(el[0])) return "$"
+      const [name, suffix, prefix] = el
+      return (prefix ?? "") + "$" + name + (suffix ?? "")
+    })
+    .join("/")
+}
+
+export const toBun = toColon

package/src/Values.ts

@@ -0,0 +1,16 @@
+type JsonPrimitives =
+  | string
+  | number
+  | boolean
+  | null
+
+export type Json =
+  | JsonPrimitives
+  | Json[]
+  | {
+    [key: string]:
+      | Json
+      // undefined won't be included in JSON objects but this will allow
+      // to use Json type in functions that return object of multiple shapes
+      | undefined
+  }

package/src/bun/BunBundle.test.ts

@@ -1,17 +1,17 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as NFS from "node:fs/promises"
 import * as NOS from "node:os"
 import * as NPath from "node:path"
-import * as Bundle from "../Bundle.ts"
-import * as BundleHttp from "../BundleHttp.ts"
+import * as Bundle from "../bundler/Bundle.ts"
+import * as BundleHttp from "../bundler/BundleHttp.ts"
 import * as TestHttpClient from "../testing/TestHttpClient.ts"
 import * as BunBundle from "./BunBundle.ts"
 
-t.describe("BunBundle manifest structure", () => {
-  t.it("should generate manifest with inputs and outputs arrays", async () => {
+test.describe("BunBundle manifest structure", () => {
+  test.it("should generate manifest with inputs and outputs arrays", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -41,43 +41,41 @@ export const greeting = "Hello World";`
         }),
       )
 
-      t
+      test
         .expect(bundle.entrypoints)
         .toBeObject()
-      t
+      test
         .expect(bundle.artifacts)
         .toBeArray()
-
-      t
+      test
         .expect(Object.keys(bundle.entrypoints).length)
         .toBe(1)
-      t
+      test
         .expect(bundle.artifacts.length)
         .toBe(3)
 
       const entrypointKeys = Object.keys(bundle.entrypoints)
       const firstEntrypoint = entrypointKeys[0]
 
-      t
+      test
         .expect(firstEntrypoint)
         .toBeString()
-      t
+      test
         .expect(bundle.entrypoints[firstEntrypoint])
         .toBeString()
 
       const firstArtifact = bundle.artifacts[0]
 
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("path")
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("type")
-      t
+      test
         .expect(firstArtifact)
         .toHaveProperty("size")
-
-      t
+      test
         .expect(firstArtifact.size)
         .toBeGreaterThan(0)
     } finally {
@@ -88,7 +86,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should serve manifest via HTTP with correct structure", async () => {
+  test.it("should serve manifest via HTTP with correct structure", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -136,46 +134,44 @@ export const greeting = "Hello World";`
           ),
       )
 
-      t
+      test
         .expect(result)
         .toHaveProperty("entrypoints")
-      t
+      test
         .expect(result)
         .toHaveProperty("artifacts")
-
-      t
+      test
         .expect(result.entrypoints)
         .toBeObject()
-      t
+      test
         .expect(result.artifacts)
         .toBeArray()
-
-      t
+      test
         .expect(Object.keys(result.entrypoints).length)
         .toBe(1)
-      t
+      test
         .expect(result.artifacts.length)
         .toBe(3)
 
       const entrypointKeys = Object.keys(result.entrypoints)
       const firstKey = entrypointKeys[0]
 
-      t
+      test
         .expect(firstKey)
         .toBeString()
-      t
+      test
         .expect(result.entrypoints[firstKey])
         .toBeString()
 
       const artifact = result.artifacts[0]
 
-      t
+      test
         .expect(artifact)
         .toHaveProperty("path")
-      t
+      test
         .expect(artifact)
         .toHaveProperty("type")
-      t
+      test
         .expect(artifact)
         .toHaveProperty("size")
     } finally {
@@ -186,7 +182,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should resolve entrypoints to artifacts correctly", async () => {
+  test.it("should resolve entrypoints to artifacts correctly", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -210,18 +206,17 @@ export const greeting = "Hello World";`
       const expectedOutput = bundle.entrypoints[firstEntrypoint]
       const resolvedOutput = bundle.resolve(firstEntrypoint)
 
-      t
+      test
         .expect(resolvedOutput)
         .toBe(expectedOutput)
 
       const artifact = bundle.getArtifact(resolvedOutput!)
 
-      t
+      test
         .expect(artifact)
         .not
         .toBeNull()
-
-      t
+      test
         .expect(artifact)
         .toBeTruthy()
     } finally {
@@ -232,7 +227,7 @@ export const greeting = "Hello World";`
     }
   })
 
-  t.it("should include all artifact metadata", async () => {
+  test.it("should include all artifact metadata", async () => {
     const tmpDir = await NFS.mkdtemp(
       NPath.join(NOS.tmpdir(), "effect-start-test-"),
     )
@@ -251,17 +246,16 @@ export const greeting = "Hello World";`
 
       const artifact = bundle.artifacts[0]
 
-      t
+      test
         .expect(artifact.path)
         .toBeString()
-      t
+      test
         .expect(artifact.type)
         .toBeString()
-      t
+      test
         .expect(artifact.size)
         .toBeNumber()
-
-      t
+      test
         .expect(artifact.type)
         .toContain("javascript")
     } finally {

package/src/bun/BunBundle.ts

@@ -18,8 +18,8 @@ import * as NPath from "node:path"
 import type {
   BundleContext,
   BundleManifest,
-} from "../Bundle.ts"
-import * as Bundle from "../Bundle.ts"
+} from "../bundler/Bundle.ts"
+import * as Bundle from "../bundler/Bundle.ts"
 import * as FileSystemExtra from "../FileSystemExtra.ts"
 import { BunImportTrackerPlugin } from "./index.ts"
 

package/src/bun/BunBundle_imports.test.ts

@@ -1,11 +1,11 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import { effectFn } from "../testing"
 import * as BunBundle from "./BunBundle.ts"
 import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 
 const effect = effectFn()
 
-t.it("imports", () =>
+test.it("imports", () =>
   effect(function*() {
     const importTracker = BunImportTrackerPlugin.make()
     yield* BunBundle.build({
@@ -22,10 +22,8 @@ t.it("imports", () =>
       e0,
     ] = importTracker.state.entries()
 
-    t
-      .expect(
-        e0,
-      )
+    test
+      .expect(e0)
       .toEqual([
         "src/bun/BunBundle_imports.test.ts",
         [

package/src/bun/BunHttpServer.test.ts

@@ -1,11 +1,13 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Route from "../Route.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
 
-t.describe("BunHttpServer smart port selection", () => {
+test.describe("smart port selection", () => {
   // Skip when running in TTY because the random port logic requires !isTTY && CLAUDECODE,
   // and process.stdout.isTTY cannot be mocked
-  t.test.skipIf(process.stdout.isTTY)(
+  test.test.skipIf(process.stdout.isTTY)(
     "uses random port when PORT not set, isTTY=false, CLAUDECODE set",
     async () => {
       const originalPort = process.env.PORT
@@ -24,7 +26,10 @@ t.describe("BunHttpServer smart port selection", () => {
           ),
         )
 
-        t.expect(port).not.toBe(3000)
+        test
+          .expect(port)
+          .not
+          .toBe(3000)
       } finally {
         if (originalPort !== undefined) {
           process.env.PORT = originalPort
@@ -40,7 +45,7 @@ t.describe("BunHttpServer smart port selection", () => {
     },
   )
 
-  t.test("uses explicit PORT even when CLAUDECODE is set", async () => {
+  test.test("uses explicit PORT even when CLAUDECODE is set", async () => {
     const originalPort = process.env.PORT
     const originalClaudeCode = process.env.CLAUDECODE
 
@@ -57,7 +62,9 @@ t.describe("BunHttpServer smart port selection", () => {
         ),
       )
 
-      t.expect(port).toBe(5678)
+      test
+        .expect(port)
+        .toBe(5678)
     } finally {
       if (originalPort !== undefined) {
         process.env.PORT = originalPort
@@ -72,3 +79,173 @@ t.describe("BunHttpServer smart port selection", () => {
     }
   })
 })
+
+const BunHttpServerTest = Layer.scoped(
+  BunHttpServer.BunHttpServer,
+  BunHttpServer.make({ port: 0 }),
+)
+
+const testLayer = (routes: ReturnType<typeof Route.tree>) =>
+  Layer.provideMerge(
+    BunHttpServer.layerRoutes(routes),
+    BunHttpServerTest,
+  )
+
+test.describe("routes", () => {
+  test.test("serves static text route", async () => {
+    const routes = Route.tree({
+      "/": Route.get(Route.text("Hello, World!")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(await response.text()).toBe("Hello, World!")
+  })
+
+  test.test("serves JSON route", async () => {
+    const routes = Route.tree({
+      "/api/data": Route.get(Route.json({ message: "success", value: 42 })),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/api/data`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(response.headers.get("Content-Type")).toBe("application/json")
+    test.expect(await response.json()).toEqual({
+      message: "success",
+      value: 42,
+    })
+  })
+
+  test.test("returns 404 for unknown routes", async () => {
+    const routes = Route.tree({
+      "/": Route.get(Route.text("Home")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/unknown`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(404)
+  })
+
+  test.test("handles content negotiation", async () => {
+    const routes = Route.tree({
+      "/data": Route
+        .get(Route.json({ type: "json" }))
+        .get(Route.html("<div>html</div>")),
+    })
+
+    const [jsonResponse, htmlResponse] = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            const baseUrl = `http://localhost:${bunServer.server.port}`
+
+            const json = yield* Effect.promise(() =>
+              fetch(`${baseUrl}/data`, {
+                headers: { Accept: "application/json" },
+              })
+            )
+
+            const html = yield* Effect.promise(() =>
+              fetch(`${baseUrl}/data`, {
+                headers: { Accept: "text/html" },
+              })
+            )
+
+            return [json, html] as const
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(jsonResponse.headers.get("Content-Type")).toBe(
+      "application/json",
+    )
+    test.expect(await jsonResponse.json()).toEqual({ type: "json" })
+
+    test.expect(htmlResponse.headers.get("Content-Type")).toBe(
+      "text/html; charset=utf-8",
+    )
+    test.expect(await htmlResponse.text()).toBe("<div>html</div>")
+  })
+
+  test.test("returns 406 for unacceptable content type", async () => {
+    const routes = Route.tree({
+      "/data": Route.get(Route.json({ type: "json" })),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/data`, {
+                headers: { Accept: "image/png" },
+              })
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(406)
+  })
+
+  test.test("handles parameterized routes", async () => {
+    const routes = Route.tree({
+      "/users/:id": Route.get(Route.text("user")),
+    })
+
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/users/123`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+
+    test.expect(response.status).toBe(200)
+    test.expect(await response.text()).toBe("user")
+  })
+})