effect-start 0.18.0 → 0.20.0

package/src/RouteSchema.test.ts

@@ -1,427 +0,0 @@
-import * as test from "bun:test"
-import {
-  Effect,
-  Schema,
-} from "effect"
-import * as Http from "./Http.ts"
-import * as Route from "./Route.ts"
-import * as RouteHttp from "./RouteHttp.ts"
-import * as RouteMount from "./RouteMount.ts"
-import * as RouteSchema from "./RouteSchema.ts"
-import * as TestLogger from "./testing/TestLogger.ts"
-
-test.describe(`${RouteSchema.schemaHeaders.name}()`, () => {
-  test.it(`${RouteSchema.schemaHeaders.name} merges`, () => {
-    type ExpectedBindings = {
-      hello: string
-      "x-custom-header": string
-    }
-    const route = Route
-      .use(
-        RouteSchema.schemaHeaders(
-          Schema.Struct({
-            "hello": Schema.String,
-          }),
-        ),
-      )
-      .get(
-        RouteSchema.schemaHeaders(
-          Schema.Struct({
-            "x-custom-header": Schema.String,
-          }),
-        ),
-        Route.html(function*(ctx) {
-          test
-            .expectTypeOf(ctx.headers)
-            .toExtend<ExpectedBindings>()
-
-          return `<h1>Hello, world!</h1>`
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        headers: ExpectedBindings
-      }>()
-  })
-
-  test.it("passes bindings and parses value", async () => {
-    const headers = {
-      "x-hello": "test-value",
-    }
-    type ExpectedBindings = {
-      headers: typeof headers
-    }
-
-    const route = RouteMount.get(
-      RouteSchema.schemaHeaders(
-        Schema.Struct({
-          "x-hello": Schema.String,
-        }),
-      ),
-      Route.text((context) =>
-        Effect.gen(function*() {
-          test
-            .expectTypeOf(context)
-            .toExtend<ExpectedBindings>()
-
-          test
-            .expect(context)
-            .toMatchObject({
-              headers,
-            })
-
-          return "Hello, World!"
-        })
-      ),
-    )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<ExpectedBindings>()
-  })
-})
-
-test.describe(`${RouteSchema.schemaCookies.name}()`, () => {
-  test.it("merges cookies from schema", () => {
-    type ExpectedBindings = {
-      session: string
-      token: string
-    }
-    const route = Route
-      .use(
-        RouteSchema.schemaCookies(
-          Schema.Struct({
-            "session": Schema.String,
-          }),
-        ),
-      )
-      .get(
-        RouteSchema.schemaCookies(
-          Schema.Struct({
-            "token": Schema.String,
-          }),
-        ),
-        Route.html(function*(ctx) {
-          test
-            .expectTypeOf(ctx.cookies)
-            .toExtend<ExpectedBindings>()
-
-          return `<h1>Hello, world!</h1>`
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        cookies: ExpectedBindings
-      }>()
-  })
-
-  test.it("parses cookies from request", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        RouteSchema.schemaCookies(
-          Schema.Struct({
-            "session": Schema.String,
-          }),
-        ),
-        Route.text(function*(ctx) {
-          return `session=${ctx.cookies.session}`
-        }),
-      ),
-    )
-    const response = await Http.fetch(handler, {
-      path: "/test",
-      headers: {
-        "Cookie": "session=abc123",
-      },
-    })
-
-    test
-      .expect(response.status)
-      .toBe(200)
-    test
-      .expect(await response.text())
-      .toBe("session=abc123")
-  })
-})
-
-test.describe(`${RouteSchema.schemaSearchParams.name}()`, () => {
-  test.it("merges search params from schema", () => {
-    type ExpectedBindings = {
-      page: string
-      limit: string
-    }
-    const route = Route
-      .use(
-        RouteSchema.schemaSearchParams(
-          Schema.Struct({
-            "page": Schema.String,
-          }),
-        ),
-      )
-      .get(
-        RouteSchema.schemaSearchParams(
-          Schema.Struct({
-            "limit": Schema.String,
-          }),
-        ),
-        Route.html(function*(ctx) {
-          test
-            .expectTypeOf(ctx.searchParams)
-            .toExtend<ExpectedBindings>()
-
-          return `<h1>Hello, world!</h1>`
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        searchParams: ExpectedBindings
-      }>()
-  })
-
-  test.it("parses search params from request", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        RouteSchema.schemaSearchParams(
-          Schema.Struct({
-            "page": Schema.NumberFromString,
-            "limit": Schema.NumberFromString,
-          }),
-        ),
-        Route.text(function*(ctx) {
-          return `page=${ctx.searchParams.page},limit=${ctx.searchParams.limit}`
-        }),
-      ),
-    )
-    const response = await Http.fetch(handler, {
-      path: "/test?page=2&limit=10",
-    })
-
-    test
-      .expect(response.status)
-      .toBe(200)
-    test
-      .expect(await response.text())
-      .toBe("page=2,limit=10")
-  })
-})
-
-test.describe(`${RouteSchema.schemaBodyJson.name}()`, () => {
-  test.it("parses JSON body from schema", () => {
-    type ExpectedBindings = {
-      name: string
-      age: number
-    }
-    const route = Route
-      .post(
-        RouteSchema.schemaBodyJson(
-          Schema.Struct({
-            name: Schema.String,
-            age: Schema.Number,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          test
-            .expectTypeOf(ctx.body)
-            .toExtend<ExpectedBindings>()
-
-          return { received: ctx.body }
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        body: ExpectedBindings
-      }>()
-  })
-
-  test.it("parses JSON body from request", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.post(
-        RouteSchema.schemaBodyJson(
-          Schema.Struct({
-            name: Schema.String,
-            age: Schema.Number,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          return { name: ctx.body.name, age: ctx.body.age }
-        }),
-      ),
-    )
-    const response = await Http.fetch(handler, {
-      path: "/test",
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ name: "Alice", age: 30 }),
-    })
-
-    test
-      .expect(response.status)
-      .toBe(200)
-    test
-      .expect(await response.json())
-      .toEqual({ name: "Alice", age: 30 })
-  })
-
-  test.it("returns error for invalid JSON body", () =>
-    Effect
-      .gen(function*() {
-        const runtime = yield* Effect.runtime<TestLogger.TestLogger>()
-        const handler = RouteHttp.toWebHandlerRuntime(runtime)(
-          Route.post(
-            RouteSchema.schemaBodyJson(
-              Schema.Struct({
-                name: Schema.String,
-                age: Schema.Number,
-              }),
-            ),
-            Route.json(function*(ctx) {
-              return ctx.body
-            }),
-          ),
-        )
-        const response = yield* Effect.promise(() =>
-          Http.fetch(handler, {
-            path: "/test",
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ name: "Alice", age: "not a number" }),
-          })
-        )
-
-        test
-          .expect(response.status)
-          .toBe(400)
-
-        const messages = yield* TestLogger.messages
-        test
-          .expect(messages.some((m) => m.includes("ParseError")))
-          .toBe(true)
-      })
-      .pipe(Effect.provide(TestLogger.layer()), Effect.runPromise))
-})
-
-test.describe(`${RouteSchema.schemaBodyUrlParams.name}()`, () => {
-  test.it("parses URL params body from schema", () => {
-    type ExpectedBindings = {
-      username: string
-      password: string
-    }
-    const route = Route
-      .post(
-        RouteSchema.schemaBodyUrlParams(
-          Schema.Struct({
-            username: Schema.String,
-            password: Schema.String,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          test
-            .expectTypeOf(ctx.body)
-            .toExtend<ExpectedBindings>()
-
-          return { received: ctx.body }
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        body: ExpectedBindings
-      }>()
-  })
-
-  test.it("parses URL-encoded body from request", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.post(
-        RouteSchema.schemaBodyUrlParams(
-          Schema.Struct({
-            username: Schema.String,
-            password: Schema.String,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          return { username: ctx.body.username, password: ctx.body.password }
-        }),
-      ),
-    )
-    const response = await Http.fetch(handler, {
-      path: "/test",
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body: "username=alice&password=secret123",
-    })
-
-    test
-      .expect(response.status)
-      .toBe(200)
-    test
-      .expect(await response.json())
-      .toEqual({ username: "alice", password: "secret123" })
-  })
-})
-
-test.describe(`${RouteSchema.schemaBodyMultipart.name}()`, () => {
-  test.it("has correct type signature for multipart body", () => {
-    const route = Route
-      .post(
-        RouteSchema.schemaBodyMultipart(
-          Schema.Struct({
-            name: Schema.String,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          test
-            .expectTypeOf(ctx.body)
-            .toExtend<{ name: string }>()
-
-          return { name: ctx.body.name }
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        body: { name: string }
-      }>()
-  })
-})
-
-test.describe(`${RouteSchema.schemaBodyForm.name}()`, () => {
-  test.it("has correct type signature for form body", () => {
-    const route = Route
-      .post(
-        RouteSchema.schemaBodyForm(
-          Schema.Struct({
-            email: Schema.String,
-          }),
-        ),
-        Route.json(function*(ctx) {
-          test
-            .expectTypeOf(ctx.body)
-            .toExtend<{ email: string }>()
-
-          return { email: ctx.body.email }
-        }),
-      )
-
-    test
-      .expectTypeOf<Route.Route.Context<typeof route>>()
-      .toExtend<{
-        body: { email: string }
-      }>()
-  })
-})

package/src/RouteSse.test.ts

@@ -1,249 +0,0 @@
-import * as test from "bun:test"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Runtime from "effect/Runtime"
-import * as Stream from "effect/Stream"
-import * as Http from "./Http.ts"
-import * as Route from "./Route.ts"
-import * as RouteHttp from "./RouteHttp.ts"
-import * as RouteMount from "./RouteMount.ts"
-
-test.describe("Route.sse()", () => {
-  test.it("infers format as text", () => {
-    RouteMount.get(
-      Route.sse(function*(ctx) {
-        test
-          .expectTypeOf(ctx)
-          .toExtend<{
-            method: "GET"
-            format: "text"
-          }>()
-
-        return Stream.make({ data: "hello" })
-      }),
-    )
-  })
-
-  test.it("accepts object events with data only", () => {
-    RouteMount.get(
-      Route.sse(() =>
-        Stream.make(
-          { data: "hello" },
-          { data: "world" },
-        )
-      ),
-    )
-  })
-
-  test.it("accepts object events with data and event", () => {
-    RouteMount.get(
-      Route.sse(() =>
-        Stream.make(
-          { data: "hello", event: "message" },
-          { data: "world", event: "update" },
-        )
-      ),
-    )
-  })
-
-  test.it("accepts events with retry", () => {
-    RouteMount.get(
-      Route.sse(() =>
-        Stream.make(
-          { data: "hello", retry: 3000 },
-        )
-      ),
-    )
-  })
-
-  test.it("accepts Effect returning Stream", () => {
-    RouteMount.get(
-      Route.sse(
-        Effect.succeed(Stream.make({ data: "hello" })),
-      ),
-    )
-  })
-
-  test.it("accepts generator returning Stream", () => {
-    RouteMount.get(
-      Route.sse(function*() {
-        const prefix = yield* Effect.succeed("msg: ")
-        return Stream.make({ data: `${prefix}hello` })
-      }),
-    )
-  })
-
-  test.it("formats data events correctly", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() => Stream.make({ data: "hello" }, { data: "world" })),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    test.expect(response.headers.get("content-type")).toBe("text/event-stream")
-    test.expect(response.headers.get("cache-control")).toBe("no-cache")
-    test.expect(response.headers.get("connection")).toBe("keep-alive")
-
-    const text = await response.text()
-    test.expect(text).toBe("data: hello\n\ndata: world\n\n")
-  })
-
-  test.it("formats events with event field", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() => Stream.make({ data: "payload", event: "custom" })),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe("event: custom\ndata: payload\n\n")
-  })
-
-  test.it("formats events with retry", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() => Stream.make({ data: "hello", retry: 5000 })),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe("data: hello\nretry: 5000\n\n")
-  })
-
-  test.it("formats multi-line data with multiple data fields", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() =>
-          Stream.make({
-            event: "patch",
-            data: "line1\nline2\nline3",
-          })
-        ),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe(
-      "event: patch\ndata: line1\ndata: line2\ndata: line3\n\n",
-    )
-  })
-
-  test.it("accepts Stream directly", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(
-          Stream.make({ data: "direct" }),
-        ),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe("data: direct\n\n")
-  })
-
-  test.it("infers error type from Stream", () => {
-    class MyError {
-      readonly _tag = "MyError"
-    }
-
-    const stream: Stream.Stream<{ data: string }, MyError> = Stream.fail(
-      new MyError(),
-    )
-
-    const route = Route.get(
-      Route.sse(stream),
-    )
-
-    const routes = [...route]
-    type RouteError = (typeof routes)[0] extends
-      Route.Route.Route<any, any, any, infer E, any> ? E
-      : never
-
-    test.expectTypeOf<RouteError>().toEqualTypeOf<MyError>()
-  })
-
-  test.it("infers context type from Stream", () => {
-    class Config extends Context.Tag("Config")<Config, { url: string }>() {}
-
-    const stream = Stream.fromEffect(
-      Effect.map(Config, (cfg) => ({ data: cfg.url })),
-    )
-
-    const route = Route.get(
-      Route.sse(stream),
-    )
-
-    const routes = [...route]
-    type RouteContext = (typeof routes)[0] extends
-      Route.Route.Route<any, any, any, any, infer R> ? R
-      : never
-
-    test.expectTypeOf<RouteContext>().toEqualTypeOf<Config>()
-  })
-
-  test.it("works with context at runtime", async () => {
-    class Config extends Context.Tag("Config")<Config, { message: string }>() {}
-
-    const stream = Stream.fromEffect(
-      Effect.map(Config, (cfg) => ({ data: cfg.message })),
-    )
-
-    const route = Route.get(Route.sse(stream))
-    const layer = Layer.succeed(Config, { message: "from context" })
-    const runtime = Effect.runSync(Layer.toRuntime(layer).pipe(Effect.scoped))
-    const handler = RouteHttp.toWebHandlerRuntime(runtime)(route)
-
-    const response = await Http.fetch(handler, { path: "/events" })
-    const text = await response.text()
-
-    test.expect(text).toBe("data: from context\n\n")
-  })
-
-  test.it("formats tagged struct as event with JSON data", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() =>
-          Stream.make(
-            { _tag: "UserCreated", id: 123, name: "Alice" },
-            { _tag: "UserUpdated", id: 123, active: true },
-          )
-        ),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe(
-      `event: UserCreated\ndata: {"_tag":"UserCreated","id":123,"name":"Alice"}\n\n`
-        + `event: UserUpdated\ndata: {"_tag":"UserUpdated","id":123,"active":true}\n\n`,
-    )
-  })
-
-  test.it("handles mixed tagged and regular events", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        Route.sse(() =>
-          Stream.make(
-            { data: "plain message" },
-            { _tag: "Notification", text: "hello" },
-            { data: "another", event: "custom" },
-          )
-        ),
-      ),
-    )
-    const response = await Http.fetch(handler, { path: "/events" })
-
-    const text = await response.text()
-    test.expect(text).toBe(
-      `data: plain message\n\n`
-        + `event: Notification\ndata: {"_tag":"Notification","text":"hello"}\n\n`
-        + `event: custom\ndata: another\n\n`,
-    )
-  })
-})