effect-start 0.14.0 → 0.16.0

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 {