effect 4.0.0-beta.62 → 4.0.0-beta.63

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -77,7 +77,7 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
       key.startsWith("effect/httpapi/HttpApiGroup/")
     )
     for (const group of Object.values(api.groups)) {
-      const groupRoutes = services.mapUnsafe.get(group.key) as Array<HttpRouter.Route<any, any>>
+      const groupRoutes = services.mapUnsafe.get(group.key)?.routes as Array<HttpRouter.Route<any, any>>
       if (groupRoutes === undefined) {
         const available = availableGroups.length === 0 ? "none" : availableGroups.join(", ")
         return yield* Effect.die(
@@ -130,10 +130,15 @@ export const group = <
       ? (yield* result as Effect.Effect<any, any, any>)
       : result
     const routes: Array<HttpRouter.Route<any, any>> = []
-    for (const item of handlers.handlers) {
+    for (const item of handlers.handlers.values()) {
       routes.push(handlerToRoute(group as any, item, services))
     }
-    return Context.makeUnsafe(new Map([[group.key, routes]]))
+    return Context.makeUnsafe(
+      new Map([[group.key, {
+        routes,
+        handlers: handlers.handlers
+      }]])
+    )
   })) as any
 
 /**
@@ -162,7 +167,7 @@ export interface Handlers<
     _Endpoints: Covariant<Endpoints>
   }
   readonly group: HttpApiGroup.AnyWithProps
-  readonly handlers: Set<Handlers.Item<R>>
+  readonly handlers: Map<string, Handlers.Item<R>>
 
   /**
    * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
@@ -449,7 +454,7 @@ const HandlersProto = {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ) {
     const endpoint = this.group.endpoints[name]
-    this.handlers.add({
+    this.handlers.set(name, {
       endpoint,
       handler,
       isRaw: false,
@@ -464,7 +469,7 @@ const HandlersProto = {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ) {
     const endpoint = this.group.endpoints[name]
-    this.handlers.add({
+    this.handlers.set(name, {
       endpoint,
       handler,
       isRaw: true,
@@ -479,7 +484,7 @@ const makeHandlers = <R, Endpoints extends HttpApiEndpoint.Any>(
 ): Handlers<R, Endpoints> => {
   const self = Object.create(HandlersProto)
   self.group = group
-  self.handlers = new Set<Handlers.Item<R>>()
+  self.handlers = new Map<string, Handlers.Item<R>>()
   return self
 }
 
@@ -632,7 +637,8 @@ function handlerToHttpEffect(
   )
 }
 
-function handlerToRoute(
+/** @internal */
+export function handlerToRoute(
   group: HttpApiGroup.AnyWithProps,
   handler: Handlers.Item<any>,
   context: Context.Context<any>

package/src/unstable/httpapi/HttpApiClient.ts

@@ -175,7 +175,8 @@ type UrlBuilderTopLevelMethods<Groups extends HttpApiGroup.Any> = Extract<Groups
   : never :
   never
 
-const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
+/** @internal */
+export const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
     readonly httpClient: HttpClient.HttpClient.With<E, R>
@@ -201,9 +202,9 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
       | undefined
     readonly baseUrl?: URL | string | undefined
   }
-): Effect.Effect<void, unknown, unknown> =>
+): Effect.Effect<void> =>
   Effect.gen(function*() {
-    const services = yield* Effect.context<any>()
+    const services = yield* Effect.context()
 
     const httpClient = options.httpClient.pipe(
       options?.baseUrl === undefined

package/src/unstable/httpapi/HttpApiTest.ts

@@ -0,0 +1,95 @@
+/**
+ * @since 4.0.0
+ */
+import * as Context from "../../Context.ts"
+import * as Effect from "../../Effect.ts"
+import type { FileSystem } from "../../FileSystem.ts"
+import * as Layer from "../../Layer.ts"
+import type { Path } from "../../Path.ts"
+import type { Scope } from "../../Scope.ts"
+import type { Generator } from "../http/Etag.ts"
+import * as HttpClient from "../http/HttpClient.ts"
+import type { HttpPlatform } from "../http/HttpPlatform.ts"
+import * as HttpRouter from "../http/HttpRouter.ts"
+import * as HttpServerRequest from "../http/HttpServerRequest.ts"
+import * as HttpServerResponse from "../http/HttpServerResponse.ts"
+import type * as HttpApi from "./HttpApi.ts"
+import type { Handlers } from "./HttpApiBuilder.ts"
+import * as HttpApiBuilder from "./HttpApiBuilder.ts"
+import * as HttpApiClient from "./HttpApiClient.ts"
+import type * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
+import type * as HttpApiGroup from "./HttpApiGroup.ts"
+
+/**
+ * @since 4.0.0
+ * @category Testing
+ */
+export const groups = Effect.fnUntraced(function*<
+  ApiId extends string,
+  Groups extends HttpApiGroup.Any,
+  const Names extends ReadonlyArray<HttpApiGroup.Name<Groups>>,
+  SelectedGroups = HttpApiGroup.WithName<Groups, Names[number]>
+>(
+  api: HttpApi.HttpApi<ApiId, Groups>,
+  groupNames: Names
+): Effect.fn.Return<
+  HttpApiClient.Client<Groups>,
+  never,
+  | HttpApiGroup.ToService<ApiId, SelectedGroups>
+  | HttpApiGroup.MiddlewareClient<Groups>
+  | HttpApiEndpoint.Middleware<HttpApiGroup.Endpoints<Groups>>
+  | FileSystem
+  | Generator
+  | HttpPlatform
+  | Path
+  | Scope
+> {
+  let context = yield* Effect.context<HttpApiGroup.ToService<ApiId, SelectedGroups>>()
+
+  for (const name in api.groups) {
+    const group = api.groups[name]
+    if (groupNames.includes(name as any)) {
+      continue
+    }
+    const handlers = new Map<string, Handlers.Item<never>>()
+    const routes: Array<HttpRouter.Route<any, any>> = []
+    for (const endpointName in group.endpoints) {
+      const endpoint = group.endpoints[endpointName]
+      const handler: Handlers.Item<never> = {
+        endpoint: endpoint as any,
+        handler: () => Effect.die(new Error(`Unhandled endpoint: ${endpointName}`)),
+        isRaw: false,
+        uninterruptible: false
+      }
+      handlers.set(endpointName, handler)
+      routes.push(HttpApiBuilder.handlerToRoute(group as any, handler, context))
+    }
+    context = Context.add(context, group as any, { handlers, routes })
+  }
+
+  const layer: Layer.Layer<
+    never,
+    never,
+    | FileSystem
+    | Generator
+    | HttpPlatform
+    | HttpRouter.HttpRouter
+    | Path
+  > = HttpApiBuilder.layer(api).pipe(
+    Layer.provide(Layer.succeedContext(context))
+  ) as any
+  const handler = yield* HttpRouter.toHttpEffect(layer)
+  const httpClient = HttpClient.make(Effect.fnUntraced(function*(request) {
+    const serverRequest = HttpServerRequest.fromClientRequest(request)
+    const response = yield* handler.pipe(
+      Effect.provideService(HttpServerRequest.HttpServerRequest, serverRequest),
+      Effect.orDie
+    )
+    return HttpServerResponse.toClientResponse(response)
+  }, Effect.scoped))
+
+  return yield* HttpApiClient.makeWith(api, {
+    httpClient,
+    baseUrl: "http://localhost:3000"
+  })
+})

package/src/unstable/httpapi/index.ts

@@ -85,6 +85,11 @@ export * as HttpApiSecurity from "./HttpApiSecurity.ts"
  */
 export * as HttpApiSwagger from "./HttpApiSwagger.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as HttpApiTest from "./HttpApiTest.ts"
+
 /**
  * @since 4.0.0
  */