effect-start 0.15.0 → 0.16.0

package/src/RouteMount.ts

@@ -179,8 +179,8 @@ export namespace RouteMount {
   export type Items<S> = S extends Builder<any, infer I> ? I : []
 
   export type BuilderBindings<S> = S extends Builder<any, infer I>
-    ? Types.Simplify<WildcardBindings<I>>
-    : {}
+    ? Types.Simplify<WildcardBindings<I>> & { request: Request }
+    : { request: Request }
 
   type WildcardBindingsItem<T> = T extends Route.Route.Route<
     { method: "*" },
@@ -251,6 +251,7 @@ export namespace RouteMount {
   }
 
   // Flatten items: merge method into descriptor and accumulate bindings through the chain
+  // `request` is omitted from bindings since it's implicit (always available)
   export type FlattenItems<
     M extends Method,
     B,
@@ -259,8 +260,14 @@ export namespace RouteMount {
     Route.Route.Route<infer D, infer RB, infer A, infer E, infer R>,
     ...infer Tail extends Route.Route.Tuple,
   ] ? [
-      Route.Route.Route<{ method: M } & D, B & RB, A, E, R>,
-      ...FlattenItems<M, B & RB, Tail>,
+      Route.Route.Route<
+        Types.Simplify<{ method: M } & D> & {},
+        Types.Simplify<Omit<B & RB, "request">>,
+        A,
+        E,
+        R
+      >,
+      ...FlattenItems<M, Types.Simplify<B & RB>, Tail>,
     ]
     : []
 
@@ -309,5 +316,155 @@ export namespace RouteMount {
         ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>,
       ]
     >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>,
+      ]
+    >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+      E extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+      ef: (e: D) => E,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>,
+      ]
+    >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+      E extends Route.RouteSet.Any,
+      F extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+      ef: (e: D) => E,
+      fg: (f: E) => F,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>,
+      ]
+    >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+      E extends Route.RouteSet.Any,
+      F extends Route.RouteSet.Any,
+      G extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+      ef: (e: D) => E,
+      fg: (f: E) => F,
+      gh: (g: F) => G,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>,
+      ]
+    >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+      E extends Route.RouteSet.Any,
+      F extends Route.RouteSet.Any,
+      G extends Route.RouteSet.Any,
+      H extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+      ef: (e: D) => E,
+      fg: (f: E) => F,
+      gh: (g: F) => G,
+      hi: (h: G) => H,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>,
+      ]
+    >
+
+    <
+      S extends Self,
+      A extends Route.RouteSet.Any,
+      B extends Route.RouteSet.Any,
+      C extends Route.RouteSet.Any,
+      D extends Route.RouteSet.Any,
+      E extends Route.RouteSet.Any,
+      F extends Route.RouteSet.Any,
+      G extends Route.RouteSet.Any,
+      H extends Route.RouteSet.Any,
+      I extends Route.RouteSet.Any,
+    >(
+      this: S,
+      ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
+      bc: (b: A) => B,
+      cd: (c: B) => C,
+      de: (d: C) => D,
+      ef: (e: D) => E,
+      fg: (f: E) => F,
+      gh: (g: F) => G,
+      hi: (h: G) => H,
+      ij: (i: H) => I,
+    ): Builder<
+      {},
+      [
+        ...Items<S>,
+        ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>,
+      ]
+    >
   }
 }

package/src/RouteSchema.test.ts

@@ -3,9 +3,12 @@ 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`, () => {
@@ -79,3 +82,346 @@ test.describe(`${RouteSchema.schemaHeaders.name}()`, () => {
       .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 }
+      }>()
+  })
+})