allow Handler to handle multiple endpoints (#641)

Author: sukovanej

.changeset/friendly-months-type.md

@@ -0,0 +1,6 @@
+---
+"effect-http-node": patch
+"effect-http": patch
+---
+
+Change internal structure of `Handler` to give it an ability to handler multiple endpoints.

packages/effect-http-node/src/internal/node-testing.ts

@@ -5,7 +5,6 @@ import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"
 import type * as HttpApp from "@effect/platform/HttpApp"
 import * as HttpClient from "@effect/platform/HttpClient"
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
-import * as HttpRouter from "@effect/platform/HttpRouter"
 import * as HttpServer from "@effect/platform/HttpServer"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
@@ -50,7 +49,7 @@ export const makeRaw = <R, E>(
 export const handler = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   handler: Handler.Handler<A, E, R>
 ) =>
-  startTestServer(HttpRouter.fromIterable([Handler.getRoute(handler)])).pipe(
+  startTestServer(Handler.getRouter(handler)).pipe(
     Effect.map((url) => makeHttpClient(HttpClient.fetch, url)),
     Effect.provide(NodeContext.layer)
   )

packages/effect-http-node/test/handler.test.ts

@@ -346,4 +346,45 @@ describe("error reporting", () => {
       expect(response.status).toEqual(302)
       expect(response.headers).toMatchObject({ "set-cookie": "session=123; Path=/; HttpOnly" })
     }))
+
+  it.scoped("concat", () =>
+    Effect.gen(function*() {
+      const getValueHandler = Handler.make(Api.getEndpoint(exampleApiGet, "getValue"), () => Effect.succeed(12))
+      const testHandler = Handler.make(Api.getEndpoint(exampleApiPostNullableField, "test"), () =>
+        Effect.succeed({ value: Option.some("test") }))
+
+      const handler = Handler.concat(getValueHandler, testHandler)
+
+      const client = yield* NodeTesting.handler(handler)
+      const [response1, response2] = yield* Effect.zip(
+        client(HttpClientRequest.get("/get-value")),
+        client(HttpClientRequest.post("/test"))
+      )
+
+      expect(yield* response1.json).toEqual(12)
+      expect(yield* response2.json).toEqual({ value: "test" })
+    }))
+
+  it.scoped("concatAll", () =>
+    Effect.gen(function*() {
+      const helloHandler = Api.getEndpoint(exampleApiParams, "hello").pipe(
+        Handler.make(({ path }) => Effect.succeed(path.value))
+      )
+      const getValueHandler = Handler.make(Api.getEndpoint(exampleApiGet, "getValue"), () => Effect.succeed(12))
+      const testHandler = Handler.make(Api.getEndpoint(exampleApiPostNullableField, "test"), () =>
+        Effect.succeed({ value: Option.some("test") }))
+
+      const handler = Handler.concatAll(getValueHandler, testHandler, helloHandler)
+
+      const client = yield* NodeTesting.handler(handler)
+      const [response1, response2, response3] = yield* Effect.all([
+        client(HttpClientRequest.get("/get-value")),
+        client(HttpClientRequest.post("/test")),
+        client(HttpClientRequest.post("/hello/a"))
+      ])
+
+      expect(yield* response1.json).toEqual(12)
+      expect(yield* response2.json).toEqual({ value: "test" })
+      expect(yield* response3.json).toEqual("a")
+    }))
 })

packages/effect-http/dtslint/Handler.ts

@@ -1,10 +1,46 @@
 import { Effect } from "effect"
 import { Api, Handler } from "effect-http"
 
-const endpoint = Api.get("getArticle", "/article")
+const endpoint1 = Api.get("endpoint1", "/endpoint1")
+const endpoint2 = Api.get("endpoint2", "/endpoint2")
+const endpoint3 = Api.get("endpoint3", "/endpoint3")
 
-// $ExpectType Handler<Default<"getArticle">, never, never>
-Handler.make(endpoint, () => Effect.void)
+declare const eff1: Effect.Effect<void, "E1", "R1">
+declare const eff2: Effect.Effect<void, "E2", "R2">
+declare const eff3: Effect.Effect<void, "E3", "R3">
 
-// $ExpectType Handler<Default<"getArticle">, never, never>
-endpoint.pipe(Handler.make(() => Effect.void))
+// $ExpectType Handler<Default<"endpoint1">, never, never>
+Handler.make(endpoint1, () => Effect.void)
+
+// $ExpectType Handler<Default<"endpoint1">, never, never>
+endpoint1.pipe(Handler.make(() => Effect.void))
+
+// $ExpectType Handler<Default<"endpoint1"> | Default<"endpoint2">, never, never>
+Handler.concat(
+  Handler.make(endpoint1, () => Effect.void),
+  Handler.make(endpoint2, () => Effect.void)
+)
+
+// $ExpectType Handler<Default<"endpoint1"> | Default<"endpoint2">, never, never>
+Handler.make(endpoint1, () => Effect.void).pipe(Handler.concat(
+  Handler.make(endpoint2, () => Effect.void)
+))
+
+// $ExpectType Handler<Default<"endpoint1"> | Default<"endpoint2">, "E1", "R1">
+Handler.concat(
+  Handler.make(endpoint1, () => eff1),
+  Handler.make(endpoint2, () => Effect.void)
+)
+
+// $ExpectType Handler<Default<"endpoint1"> | Default<"endpoint2">, "E1" | "E2", "R1" | "R2">
+Handler.concat(
+  Handler.make(endpoint1, () => eff1),
+  Handler.make(endpoint2, () => eff2)
+)
+
+// $ExpectType Handler<Default<"endpoint1"> | Default<"endpoint2"> | Default<"endpoint3">, "E1" | "E2" | "E3", "R1" | "R2" | "R3">
+Handler.concatAll(
+  Handler.make(endpoint1, () => eff1),
+  Handler.make(endpoint2, () => eff2),
+  Handler.make(endpoint3, () => eff3)
+)

packages/effect-http/src/ApiEndpoint.ts

@@ -99,7 +99,7 @@ export declare namespace ApiEndpoint {
     Id,
     ApiRequest.ApiRequest.Default,
     ApiResponse.ApiResponse.Default,
-    Security.Security<void>
+    Security.Security.Default
   >
 
   /**

packages/effect-http/src/Handler.ts

@@ -124,8 +124,32 @@ export declare namespace Handler {
    * @since 1.0.0
    */
   export type ToSecurity<Security extends Security.Security.Any> = Security.Security.Success<Security>
+
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export type Endpoint<H> = H extends Handler<infer A, any, any> ? A : never
+
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export type Error<H> = H extends Handler<any, infer E, any> ? E : never
+
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export type Context<H> = H extends Handler<any, any, infer R> ? R : never
 }
 
+/**
+ * @category constructors
+ * @since 1.0.0
+ */
+export const empty: Handler<never, never, never> = internal.empty
+
 /**
  * @category constructors
  * @since 1.0.0
@@ -157,17 +181,40 @@ export const makeRaw: {
 } = internal.makeRaw
 
 /**
- * @category getters
+ * @category combinators
+ * @since 1.0.0
+ */
+export const concat: {
+  <A extends ApiEndpoint.ApiEndpoint.Any, B extends ApiEndpoint.ApiEndpoint.Any, E1, E2, R1, R2>(
+    self: Handler<A, E1, R1>,
+    handler: Handler<B, E2, R2>
+  ): Handler<A | B, E1 | E2, R1 | R2>
+
+  <B extends ApiEndpoint.ApiEndpoint.Any, E2, R2>(
+    handler: Handler<B, E2, R2>
+  ): <A extends ApiEndpoint.ApiEndpoint.Any, E1, R1>(self: Handler<A, E1, R1>) => Handler<A | B, E1 | E2, R1 | R2>
+} = internal.concat
+
+/**
+ * @category combinators
+ * @since 1.0.0
+ */
+export const concatAll: <Handlers extends ReadonlyArray<Handler.Any>>(
+  ...handlers: Handlers
+) => Handler<Handler.Endpoint<Handlers[number]>, Handler.Error<Handlers[number]>, Handler.Context<Handlers[number]>> =
+  internal.concatAll
+/**
+ * @category destructors
  * @since 1.0.0
  */
-export const getRoute: <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
+export const getRouter: <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   handler: Handler<A, E, R>
-) => HttpRouter.Route<E, R> = internal.getRoute
+) => HttpRouter.HttpRouter<E, R> = internal.getRouter
 
 /**
- * @category getters
+ * @category destructors
  * @since 1.0.0
  */
-export const getEndpoint: <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
+export const getEndpoints: <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   handler: Handler<A, E, R>
-) => A = internal.getEndpoint
+) => ReadonlyArray<A> = internal.getEndpoints

packages/effect-http/src/Security.ts

@@ -54,6 +54,12 @@ export declare namespace Security {
    */
   export type Any = Security<any, any, any>
 
+  /**
+   * @category models
+   * @since 1.0.0
+   */
+  export type Default = Security<void, never, never>
+
   /**
    * @category models
    * @since 1.0.0

packages/effect-http/src/internal/handler.ts

@@ -1,6 +1,7 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as Array from "effect/Array"
 import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
+import { dual, pipe } from "effect/Function"
 import * as Pipeable from "effect/Pipeable"
 
 import * as ApiEndpoint from "../ApiEndpoint.js"
@@ -19,23 +20,26 @@ export const variance = {
   /* c8 ignore next */
   _A: (_: any) => _,
   /* c8 ignore next */
-  _E: (_: any) => _,
+  _E: (_: never) => _,
   /* c8 ignore next */
-  _R: (_: any) => _
+  _R: (_: never) => _
 }
 
 /** @internal */
 class HandlerImpl<A extends ApiEndpoint.ApiEndpoint.Any, E, R> implements Handler.Handler<A, E, R> {
   readonly [TypeId] = variance
 
-  constructor(readonly endpoint: A, readonly route: HttpRouter.Route<E, R>) {}
+  constructor(readonly endpoints: ReadonlyArray<A>, readonly router: HttpRouter.HttpRouter<E, R>) {}
 
   pipe() {
     // eslint-disable-next-line prefer-rest-params
     return Pipeable.pipeArguments(this, arguments)
   }
 }
 
+/** @internal */
+export const empty = new HandlerImpl([], HttpRouter.empty) as unknown as Handler.Handler<never, never, never> // TODO check variance
+
 /** @internal */
 export const make: {
   <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
@@ -77,8 +81,8 @@ const _makeRaw = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   endpoint: A,
   handler: HttpRouter.Route.Handler<E, R>
 ): Handler.Handler<A, E, R> => {
-  const router = HttpRouter.makeRoute(ApiEndpoint.getMethod(endpoint), ApiEndpoint.getPath(endpoint), handler)
-  return new HandlerImpl(endpoint, router)
+  const route = HttpRouter.makeRoute(ApiEndpoint.getMethod(endpoint), ApiEndpoint.getPath(endpoint), handler)
+  return new HandlerImpl([endpoint], HttpRouter.fromIterable([route]))
 }
 
 /** @internal */
@@ -110,11 +114,45 @@ const _make = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
 }
 
 /** @internal */
-export const getRoute = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
+export const getRouter = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   handler: Handler.Handler<A, E, R>
-): HttpRouter.Route<E, R> => (handler as HandlerImpl<A, E, R>).route
+): HttpRouter.HttpRouter<E, R> => (handler as HandlerImpl<A, E, R>).router
 
 /** @internal */
-export const getEndpoint = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
+export const getEndpoints = <A extends ApiEndpoint.ApiEndpoint.Any, E, R>(
   handler: Handler.Handler<A, E, R>
-): A => (handler as HandlerImpl<A, E, R>).endpoint
+): ReadonlyArray<A> => (handler as HandlerImpl<A, E, R>).endpoints
+
+/** @internal */
+export const concat: {
+  <A extends ApiEndpoint.ApiEndpoint.Any, B extends ApiEndpoint.ApiEndpoint.Any, E1, E2, R1, R2>(
+    self: Handler.Handler<A, E1, R1>,
+    handler: Handler.Handler<B, E2, R2>
+  ): Handler.Handler<A | B, E1 | E2, R1 | R2>
+
+  <B extends ApiEndpoint.ApiEndpoint.Any, E2, R2>(
+    handler: Handler.Handler<B, E2, R2>
+  ): <A extends ApiEndpoint.ApiEndpoint.Any, E1, R1>(
+    self: Handler.Handler<A, E1, R1>
+  ) => Handler.Handler<A | B, E1 | E2, R1 | R2>
+} = dual(2, <A extends ApiEndpoint.ApiEndpoint.Any, B extends ApiEndpoint.ApiEndpoint.Any, E1, E2, R1, R2>(
+  self: Handler.Handler<A, E1, R1>,
+  handler: Handler.Handler<B, E2, R2>
+): Handler.Handler<A | B, E1 | E2, R1 | R2> =>
+  new HandlerImpl(
+    [...getEndpoints(self), ...getEndpoints(handler)],
+    HttpRouter.concat(getRouter(self), getRouter(handler))
+  ))
+
+/** @internal */
+export const concatAll = <Handlers extends ReadonlyArray<Handler.Handler.Any>>(
+  ...handlers: Handlers
+): Handler.Handler<
+  Handler.Handler.Endpoint<Handlers[number]>,
+  Handler.Handler.Error<Handlers[number]>,
+  Handler.Handler.Context<Handlers[number]>
+> =>
+  new HandlerImpl(
+    Array.flatten(handlers.map(getEndpoints)),
+    handlers.map(getRouter).reduce(HttpRouter.concat, HttpRouter.empty)
+  )

packages/effect-http/src/internal/router-builder.ts

@@ -120,11 +120,11 @@ export const handle = (...args: Array<any>) => (builder: RouterBuilder.RouterBui
   }
 
   const handler = args[0] as Handler.Handler.Any
-  const remainingEndpoints = removeRemainingEndpoint(
-    builder,
-    ApiEndpoint.getId(Handler.getEndpoint(handler))
+  const handlerEndpointIds = Handler.getEndpoints(handler).map((e) => ApiEndpoint.getId(e))
+  const remainingEndpoints = builder.remainingEndpoints.filter((e1) =>
+    !handlerEndpointIds.includes(ApiEndpoint.getId(e1))
   )
-  const router = addRoute(builder.router, Handler.getRoute(handler))
+  const router = HttpRouter.concat(builder.router, Handler.getRouter(handler))
 
   return new RouterBuilderImpl(remainingEndpoints, builder.api, router, builder.options)
 }