effect-start 0.17.2 → 0.19.0

package/src/bun/BunHttpServer.test.ts

@@ -1,251 +0,0 @@
-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"
-
-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
-  test.test.skipIf(process.stdout.isTTY)(
-    "uses random port when PORT not set, isTTY=false, CLAUDECODE set",
-    async () => {
-      const originalPort = process.env.PORT
-      const originalClaudeCode = process.env.CLAUDECODE
-
-      try {
-        delete process.env.PORT
-        process.env.CLAUDECODE = "1"
-
-        const port = await Effect.runPromise(
-          Effect.scoped(
-            Effect.gen(function*() {
-              const bunServer = yield* BunHttpServer.make({})
-              return bunServer.server.port
-            }),
-          ),
-        )
-
-        test
-          .expect(port)
-          .not
-          .toBe(3000)
-      } finally {
-        if (originalPort !== undefined) {
-          process.env.PORT = originalPort
-        } else {
-          delete process.env.PORT
-        }
-        if (originalClaudeCode !== undefined) {
-          process.env.CLAUDECODE = originalClaudeCode
-        } else {
-          delete process.env.CLAUDECODE
-        }
-      }
-    },
-  )
-
-  test.test("uses explicit PORT even when CLAUDECODE is set", async () => {
-    const originalPort = process.env.PORT
-    const originalClaudeCode = process.env.CLAUDECODE
-
-    try {
-      process.env.PORT = "5678"
-      process.env.CLAUDECODE = "1"
-
-      const port = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function*() {
-            const bunServer = yield* BunHttpServer.make({})
-            return bunServer.server.port
-          }),
-        ),
-      )
-
-      test
-        .expect(port)
-        .toBe(5678)
-    } finally {
-      if (originalPort !== undefined) {
-        process.env.PORT = originalPort
-      } else {
-        delete process.env.PORT
-      }
-      if (originalClaudeCode !== undefined) {
-        process.env.CLAUDECODE = originalClaudeCode
-      } else {
-        delete process.env.CLAUDECODE
-      }
-    }
-  })
-})
-
-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")
-  })
-})

package/src/bun/BunImportTrackerPlugin.test.ts

@@ -1,77 +0,0 @@
-import * as test from "bun:test"
-import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
-import * as BunVirtualFilesPlugin from "./BunVirtualFilesPlugin.ts"
-
-const Files = {
-  "index.html": `
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Dashboard</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script src="client.tsx" />
-  </body>
-</html>
-`,
-
-  "client.ts": `
-import { message } from "./config.ts"
-
-alert(message)
-`,
-
-  ".config.ts": `
-export const message = "Hello, World!"
-`,
-}
-
-test.it("virtual import", async () => {
-  const trackerPlugin = BunImportTrackerPlugin.make({
-    baseDir: Bun.fileURLToPath(import.meta.resolve("../..")),
-  })
-
-  await Bun.build({
-    target: "bun",
-    entrypoints: [
-      import.meta.path,
-    ],
-    plugins: [
-      trackerPlugin,
-    ],
-  })
-
-  test
-    .expect(
-      [...trackerPlugin.state.entries()],
-    )
-    .toEqual([
-      [
-        "src/bun/BunImportTrackerPlugin.test.ts",
-        [
-          {
-            kind: "import-statement",
-            path: "bun:test",
-          },
-          {
-            kind: "import-statement",
-            path: "src/bun/BunImportTrackerPlugin.ts",
-          },
-          {
-            kind: "import-statement",
-            path: "src/bun/BunVirtualFilesPlugin.ts",
-          },
-        ],
-      ],
-      [
-        "src/bun/BunImportTrackerPlugin.ts",
-        [
-          {
-            kind: "import-statement",
-            path: "node:path",
-          },
-        ],
-      ],
-    ])
-})

package/src/bun/BunRoute.test.ts

@@ -1,162 +0,0 @@
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Route from "../Route.ts"
-import * as BunHttpServer from "./BunHttpServer.ts"
-import * as BunRoute from "./BunRoute.ts"
-
-const layerServer = Layer.scoped(
-  BunHttpServer.BunHttpServer,
-  BunHttpServer.make({ port: 0 }),
-)
-
-const testLayer = (routes: ReturnType<typeof Route.tree>) =>
-  Layer.provideMerge(
-    BunHttpServer.layerRoutes(routes),
-    layerServer,
-  )
-
-test.describe(BunRoute.htmlBundle, () => {
-  test.test("wraps child content with layout", async () => {
-    const routes = Route.tree({
-      "/": Route.get(
-        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
-        Route.html("<p>Hello World</p>"),
-      ),
-    })
-
-    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)
-    const html = await response.text()
-    test.expect(html).toContain("<p>Hello World</p>")
-    test.expect(html).toContain("<body>")
-    test.expect(html).toContain("</body>")
-  })
-
-  test.test("replaces %yield% with child content", async () => {
-    const routes = Route.tree({
-      "/page": Route.get(
-        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
-        Route.html("<div>Page Content</div>"),
-      ),
-    })
-
-    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}/page`)
-            )
-          })
-          .pipe(Effect.provide(testLayer(routes))),
-      ),
-    )
-
-    const html = await response.text()
-    test.expect(html).toContain("<div>Page Content</div>")
-    test.expect(html).not.toContain("%children%")
-  })
-
-  test.test("works with use() for wildcard routes", async () => {
-    const routes = Route.tree({
-      "*": Route.use(
-        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
-      ),
-      "/:path*": Route.get(Route.html("<section>Catch All</section>")),
-    })
-
-    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}/any/path`)
-            )
-          })
-          .pipe(Effect.provide(testLayer(routes))),
-      ),
-    )
-
-    test.expect(response.status).toBe(200)
-    const html = await response.text()
-    test.expect(html).toContain("<section>Catch All</section>")
-  })
-
-  test.test("has format: html descriptor", async () => {
-    const routes = Route.tree({
-      "/": Route.get(
-        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
-        Route.html("<p>content</p>"),
-      ),
-    })
-
-    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)
-    const contentType = response.headers.get("content-type")
-    test.expect(contentType).toContain("text/html")
-  })
-})
-
-test.describe(BunRoute.validateBunPattern, () => {
-  test.test("returns none for valid patterns", () => {
-    test
-      .expect(Option.isNone(BunRoute.validateBunPattern("/users")))
-      .toBe(true)
-    test
-      .expect(Option.isNone(BunRoute.validateBunPattern("/users/[id]")))
-      .toBe(true)
-    test
-      .expect(Option.isNone(BunRoute.validateBunPattern("/[...rest]")))
-      .toBe(true)
-  })
-
-  test.test("returns error for prefixed params", () => {
-    const result = BunRoute.validateBunPattern("/pk_[id]")
-    test.expect(Option.isSome(result)).toBe(true)
-  })
-
-  test.test("returns error for suffixed params", () => {
-    const result = BunRoute.validateBunPattern("/[id]_suffix")
-    test.expect(Option.isSome(result)).toBe(true)
-  })
-})
-
-test.describe(BunRoute.isHtmlBundle, () => {
-  test.test("returns false for non-objects", () => {
-    test.expect(BunRoute.isHtmlBundle(null)).toBe(false)
-    test.expect(BunRoute.isHtmlBundle(undefined)).toBe(false)
-    test.expect(BunRoute.isHtmlBundle("string")).toBe(false)
-  })
-
-  test.test("returns true for object with index property", () => {
-    test.expect(BunRoute.isHtmlBundle({ index: "index.html" })).toBe(true)
-  })
-})

package/src/bundler/BundleHttp.test.ts

@@ -1,132 +0,0 @@
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as test from "bun:test"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import IndexHtml from "../../static/react-dashboard.html" with { type: "file" }
-import * as BunBundle from "../bun/BunBundle.ts"
-import { effectFn } from "../testing"
-import * as TestHttpClient from "../testing/TestHttpClient.ts"
-import * as Bundle from "./Bundle.ts"
-import * as BundleHttp from "./BundleHttp.ts"
-
-const effect = effectFn(
-  Layer.effect(
-    Bundle.ClientBundle,
-    BunBundle.buildClient(IndexHtml as any),
-  ),
-)
-
-test.it("entrypoint with specific uri", () =>
-  effect(function*() {
-    const App = HttpRouter.empty.pipe(
-      HttpRouter.get(
-        "/react-dashboard",
-        BundleHttp.entrypoint("../static/react-dashboard.html"),
-      ),
-    )
-    const Client = TestHttpClient.make(App)
-
-    const dashboardRes = yield* Client.get("/react-dashboard")
-    test
-      .expect(dashboardRes.status)
-      .toBe(200)
-    test
-      .expect(yield* dashboardRes.text)
-      .toStartWith("<!DOCTYPE html>")
-  }))
-
-test.it("entrypoint without uri parameter", () =>
-  effect(function*() {
-    const App = HttpRouter.empty.pipe(
-      HttpRouter.get(
-        "/",
-        BundleHttp.entrypoint(),
-      ),
-      HttpRouter.get(
-        "/index",
-        BundleHttp.entrypoint(),
-      ),
-      HttpRouter.get(
-        "/react-dashboard",
-        BundleHttp.entrypoint(),
-      ),
-      HttpRouter.get(
-        "/nonexistent",
-        BundleHttp.entrypoint(),
-      ),
-    )
-    const Client = TestHttpClient.make(App)
-
-    const indexRes = yield* Client.get("/").pipe(
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-    test
-      .expect(indexRes.status)
-      .toBe(404)
-
-    const indexPathRes = yield* Client.get("/index").pipe(
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-    test
-      .expect(indexPathRes.status)
-      .toBe(404)
-
-    const dashboardRes = yield* Client.get("/react-dashboard")
-    test
-      .expect(dashboardRes.status)
-      .toBe(200)
-    test
-      .expect(yield* dashboardRes.text)
-      .toStartWith("<!DOCTYPE html>")
-
-    const nonexistentRes = yield* Client.get("/nonexistent").pipe(
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-    test
-      .expect(nonexistentRes.status)
-      .toBe(404)
-  }))
-
-test.it("withEntrypoints middleware", () =>
-  effect(function*() {
-    const fallbackApp = Effect.succeed(
-      HttpServerResponse.text("Fallback", { status: 404 }),
-    )
-
-    const App = BundleHttp.withEntrypoints()(fallbackApp)
-    const Client = TestHttpClient.make(App)
-
-    const rootRes = yield* Client.get("/")
-    test
-      .expect(rootRes.status)
-      .toBe(404)
-    test
-      .expect(yield* rootRes.text)
-      .toBe("Fallback")
-
-    const dashboardRes = yield* Client.get("/react-dashboard")
-    test
-      .expect(dashboardRes.status)
-      .toBe(200)
-    test
-      .expect(yield* dashboardRes.text)
-      .toStartWith("<!DOCTYPE html>")
-
-    const nonexistentRes = yield* Client.get("/nonexistent")
-    test
-      .expect(nonexistentRes.status)
-      .toBe(404)
-    test
-      .expect(yield* nonexistentRes.text)
-      .toBe("Fallback")
-  }))