effect-start 0.14.0 → 0.15.0

package/src/FileSystemExtra.test.ts

@@ -1,5 +1,5 @@
 import * as FileSystem from "@effect/platform/FileSystem"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import { MemoryFileSystem } from "effect-memfs"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
@@ -8,8 +8,8 @@ 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", () =>
+test.describe(`${FileSystemExtra.watchSource.name}`, () => {
+  test.it("emits events for file creation", () =>
     Effect
       .gen(function*() {
         const fs = yield* FileSystem.FileSystem
@@ -28,11 +28,19 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
         const events = yield* Fiber.join(fiber)
 
-        t.expect(Chunk.size(events)).toBeGreaterThan(0)
+        test
+          .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")
+        test
+          .expect(first.path)
+          .toContain("test.ts")
+        test
+          .expect(["rename", "change"])
+          .toContain(first.eventType)
+        test
+          .expect(first.filename)
+          .toBe("test.ts")
       })
       .pipe(
         Effect.scoped,
@@ -42,7 +50,7 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
         Effect.runPromise,
       ))
 
-  t.it(
+  test.it(
     "emits change event for file modification",
     () =>
       Effect
@@ -63,8 +71,12 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
           const events = yield* Fiber.join(fiber)
 
-          t.expect(Chunk.size(events)).toBeGreaterThan(0)
-          t.expect(Chunk.unsafeGet(events, 0).eventType).toBe("change")
+          test
+            .expect(Chunk.size(events))
+            .toBeGreaterThan(0)
+          test
+            .expect(Chunk.unsafeGet(events, 0).eventType)
+            .toBe("change")
         })
         .pipe(
           Effect.scoped,
@@ -75,7 +87,7 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
         ),
   )
 
-  t.it("applies custom filter", () =>
+  test.it("applies custom filter", () =>
     Effect
       .gen(function*() {
         const fs = yield* FileSystem.FileSystem
@@ -98,8 +110,12 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
 
         const events = yield* Fiber.join(fiber)
 
-        t.expect(Chunk.size(events)).toBe(1)
-        t.expect(Chunk.unsafeGet(events, 0).path).toContain("included.ts")
+        test
+          .expect(Chunk.size(events))
+          .toBe(1)
+        test
+          .expect(Chunk.unsafeGet(events, 0).path)
+          .toContain("included.ts")
       })
       .pipe(
         Effect.scoped,
@@ -110,9 +126,9 @@ t.describe(`${FileSystemExtra.watchSource.name}`, () => {
       ))
 })
 
-t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
-  t.it("matches source file extensions", () => {
-    t
+test.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
+  test.it("matches source file extensions", () => {
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -121,7 +137,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -130,7 +146,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -139,7 +155,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -148,7 +164,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -157,7 +173,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -166,7 +182,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(true)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -177,8 +193,8 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
       .toBe(true)
   })
 
-  t.it("rejects non-source files", () => {
-    t
+  test.it("rejects non-source files", () => {
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -187,7 +203,7 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
         }),
       )
       .toBe(false)
-    t
+    test
       .expect(
         FileSystemExtra.filterSourceFiles({
           eventType: "change",
@@ -199,9 +215,9 @@ t.describe(`${FileSystemExtra.filterSourceFiles.name}`, () => {
   })
 })
 
-t.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
-  t.it("matches directories", () => {
-    t
+test.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
+  test.it("matches directories", () => {
+    test
       .expect(
         FileSystemExtra.filterDirectory({
           eventType: "change",
@@ -212,8 +228,8 @@ t.describe(`${FileSystemExtra.filterDirectory.name}`, () => {
       .toBe(true)
   })
 
-  t.it("rejects files", () => {
-    t
+  test.it("rejects files", () => {
+    test
       .expect(
         FileSystemExtra.filterDirectory({
           eventType: "change",

package/src/Http.test.ts

@@ -0,0 +1,24 @@
+import * as test from "bun:test"
+import * as Http from "./Http.ts"
+
+test.it("cloneRequest copies request and adds props", () => {
+  const request = new Request("http://localhost/test", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+  })
+
+  const cloned = Http.cloneRequest(request, { params: { id: "123" } })
+
+  test
+    .expect(cloned.url)
+    .toBe("http://localhost/test")
+  test
+    .expect(cloned.method)
+    .toBe("POST")
+  test
+    .expect(cloned.headers.get("Content-Type"))
+    .toBe("application/json")
+  test
+    .expect(cloned.params)
+    .toEqual({ id: "123" })
+})

package/src/Http.ts

@@ -0,0 +1,25 @@
+export type Method =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS"
+
+export type WebHandler = (request: Request) => Response | Promise<Response>
+
+export function cloneRequest<T extends object>(
+  request: Request,
+  props: T,
+): Request & T {
+  const cloned = new Request(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+  })
+  for (const [key, value] of Object.entries(props)) {
+    ;(cloned as any)[key] = value
+  }
+  return cloned as Request & T
+}

package/src/HttpAppExtra.test.ts

@@ -1,11 +1,12 @@
 import { HttpServerRequest } from "@effect/platform"
 import { RouteNotFound } from "@effect/platform/HttpServerError"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import {
-  Effect,
   Layer,
+  Logger,
 } from "effect"
 import * as Cause from "effect/Cause"
+import * as LogLevel from "effect/LogLevel"
 import * as HttpAppExtra from "./HttpAppExtra.ts"
 import { effectFn } from "./testing"
 
@@ -18,60 +19,76 @@ const mockRequest = HttpServerRequest.HttpServerRequest.of({
   },
 } as any)
 
-const mockRequestLayer = Layer.succeed(
-  HttpServerRequest.HttpServerRequest,
-  mockRequest,
+const mockRequestLayer = Layer.mergeAll(
+  Layer.succeed(HttpServerRequest.HttpServerRequest, mockRequest),
+  Logger.minimumLogLevel(LogLevel.None),
 )
 
 const effect = effectFn(mockRequestLayer)
 
-t.describe("renderError", () => {
+test.describe("renderError", () => {
   const routeNotFoundCause = Cause.fail(
     new RouteNotFound({ request: {} as any }),
   )
 
-  t.it("returns JSON for Accept: application/json", () =>
+  test.it("returns JSON for Accept: application/json", () =>
     effect(function*() {
       const response = yield* HttpAppExtra.renderError(
         routeNotFoundCause,
         "application/json",
       )
 
-      t.expect(response.status).toEqual(404)
-      t.expect(response.headers["content-type"]).toContain("application/json")
+      test
+        .expect(response.status)
+        .toEqual(404)
+      test
+        .expect(response.headers["content-type"])
+        .toContain("application/json")
     }))
 
-  t.it("returns HTML for Accept: text/html", () =>
+  test.it("returns HTML for Accept: text/html", () =>
     effect(function*() {
       const response = yield* HttpAppExtra.renderError(
         routeNotFoundCause,
         "text/html",
       )
 
-      t.expect(response.status).toEqual(404)
-      t.expect(response.headers["content-type"]).toContain("text/html")
+      test
+        .expect(response.status)
+        .toEqual(404)
+      test
+        .expect(response.headers["content-type"])
+        .toContain("text/html")
     }))
 
-  t.it("returns plain text for Accept: text/plain", () =>
+  test.it("returns plain text for Accept: text/plain", () =>
     effect(function*() {
       const response = yield* HttpAppExtra.renderError(
         routeNotFoundCause,
         "text/plain",
       )
 
-      t.expect(response.status).toEqual(404)
-      t.expect(response.headers["content-type"]).toContain("text/plain")
+      test
+        .expect(response.status)
+        .toEqual(404)
+      test
+        .expect(response.headers["content-type"])
+        .toContain("text/plain")
     }))
 
-  t.it("returns JSON by default (no Accept header)", () =>
+  test.it("returns JSON by default (no Accept header)", () =>
     effect(function*() {
       const response = yield* HttpAppExtra.renderError(routeNotFoundCause, "")
 
-      t.expect(response.status).toEqual(404)
-      t.expect(response.headers["content-type"]).toContain("application/json")
+      test
+        .expect(response.status)
+        .toEqual(404)
+      test
+        .expect(response.headers["content-type"])
+        .toContain("application/json")
     }))
 
-  t.it("returns 500 for unexpected errors", () =>
+  test.it("returns 500 for unexpected errors", () =>
     effect(function*() {
       const unexpectedCause = Cause.fail({ message: "Something went wrong" })
       const response = yield* HttpAppExtra.renderError(
@@ -79,6 +96,8 @@ t.describe("renderError", () => {
         "application/json",
       )
 
-      t.expect(response.status).toEqual(500)
+      test
+        .expect(response.status)
+        .toEqual(500)
     }))
 })

package/src/HttpAppExtra.ts

@@ -5,7 +5,6 @@ import {
 } from "@effect/platform"
 import * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
-
 import {
   RequestError,
   RouteNotFound,

package/src/HttpUtils.test.ts

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

package/src/HttpUtils.ts

@@ -1,5 +1,7 @@
 import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
 
+export type FetchHandler = (request: Request) => Promise<Response>
+
 export function makeUrlFromRequest(
   request: HttpServerRequest.HttpServerRequest,
 ): URL {