effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -2,7 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Fiber from "../../Fiber.ts"
 import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -20,7 +20,7 @@ import * as Transformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import type { Covariant } from "../../Types.ts"
+import type { Covariant, NoInfer } from "../../Types.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import type { Cookie } from "../http/Cookies.ts"
 import type * as Etag from "../http/Etag.ts"
@@ -36,7 +36,6 @@ import * as Multipart from "../http/Multipart.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import type * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
-import { HttpApiSchemaError } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -63,7 +62,6 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
   | HttpPlatform
   | Path
   | HttpApiGroup.ToService<Id, Groups>
-  | HttpApiGroup.ErrorServicesEncode<Groups>
 > =>
   HttpRouter.use(Effect.fnUntraced(function*(router) {
     const services = yield* Effect.services<
@@ -168,7 +166,7 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
@@ -188,7 +186,7 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
@@ -284,6 +282,54 @@ export declare namespace Handlers {
     never
 }
 
+/**
+ * @since 4.0.0
+ * @category handlers
+ */
+export const endpoint = <
+  ApiId extends string,
+  Groups extends HttpApiGroup.Any,
+  const GroupName extends HttpApiGroup.Name<Groups>,
+  const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>>,
+  R,
+  Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
+  Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<Group>, EndpointName>
+>(
+  api: HttpApi.HttpApi<ApiId, Groups>,
+  groupName: GroupName,
+  endpointName: EndpointName,
+  handler: NoInfer<
+    HttpApiEndpoint.HandlerWithName<
+      HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>,
+      EndpointName,
+      never,
+      R
+    >
+  >
+): Effect.Effect<
+  Effect.Effect<
+    HttpServerResponse,
+    never,
+    | HttpServerRequest
+    | HttpRouter.RouteContext
+    | Request.ParsedSearchParams
+    | Exclude<R, HttpApiEndpoint.MiddlewareProvides<Endpoint>>
+  >,
+  never,
+  | HttpApiEndpoint.ServerServices<Endpoint>
+  | HttpApiEndpoint.Middleware<Endpoint>
+  | HttpApiEndpoint.MiddlewareServices<Endpoint>
+  | Etag.Generator
+  | FileSystem
+  | HttpPlatform
+  | Path
+> =>
+  Effect.servicesWith((services: ServiceMap.ServiceMap<any>) => {
+    const group = api.groups[groupName] as unknown as HttpApiGroup.AnyWithProps
+    const endpoint = group.endpoints[endpointName] as unknown as HttpApiEndpoint.AnyWithProps
+    return Effect.succeed(handlerToHttpEffect(group, endpoint, services, handler as any, false))
+  })
+
 /**
  * @since 4.0.0
  * @category security
@@ -328,7 +374,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
       } as any
       return HttpServerRequest.asEffect().pipe(
         Effect.flatMap((request) =>
-          Base64.decodeString((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
         ),
         Effect.match({
           onFailure: () => empty,
@@ -356,7 +402,7 @@ export const securitySetCookie = (
   self: HttpApiSecurity.ApiKey,
   value: string | Redacted.Redacted,
   options?: Cookie["options"]
-): Effect.Effect<void> =>
+): Effect.Effect<void, never, HttpServerRequest> =>
   HttpEffect.appendPreResponseHandler((_req, response) =>
     Effect.orDie(
       Response.setCookie(response, self.key, stringOrRedacted(value), {
@@ -497,22 +543,23 @@ function decodePayload(
   }
 }
 
-function handlerToRoute(
+function handlerToHttpEffect(
   group: HttpApiGroup.AnyWithProps,
-  handler: Handlers.Item<any>,
-  services: ServiceMap.ServiceMap<any>
-): HttpRouter.Route<any, any> {
-  const endpoint = handler.endpoint
+  endpoint: HttpApiEndpoint.AnyWithProps,
+  services: ServiceMap.ServiceMap<any>,
+  handler: HttpApiEndpoint.Handler<any, any, any>,
+  isRaw: boolean
+) {
   const encodeSuccess = Schema.encodeUnknownEffect(makeSuccessSchema(endpoint))
   const encodeError = Schema.encodeUnknownEffect(makeErrorSchema(endpoint))
-  const decodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.decodeUnknownEffect)
+  const decodeParams = UndefinedOr.map(endpoint.params, Schema.decodeUnknownEffect)
+  const decodeHeaders = UndefinedOr.map(endpoint.headers, Schema.decodeUnknownEffect)
+  const decodeQuery = UndefinedOr.map(endpoint.query, Schema.decodeUnknownEffect)
 
-  const shouldParsePayload = endpoint.payload.size > 0 && !handler.isRaw
+  const shouldParsePayload = endpoint.payload.size > 0 && !isRaw
   const payloadBy = shouldParsePayload ? buildPayloadDecoders(endpoint.payload) : undefined
 
-  const effect = applyMiddleware(
+  return applyMiddleware(
     group,
     endpoint,
     services,
@@ -545,23 +592,26 @@ function handlerToRoute(
           request.payload = yield* result
         }
       }
-      const response = yield* handler.handler(request)
+      const response = yield* handler(request)
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
-    Effect.catch((error) => {
-      if (Schema.isSchemaError(error)) {
-        error = HttpApiSchemaError.fromSchemaError(error)
-      }
-      return Effect.orDie(encodeError(error))
-    }),
+    Effect.withErrorReporting,
+    Effect.catch((error) => Effect.orDie(encodeError(error))),
     Effect.provideServices(services)
   )
+}
 
+function handlerToRoute(
+  group: HttpApiGroup.AnyWithProps,
+  handler: Handlers.Item<any>,
+  services: ServiceMap.ServiceMap<any>
+): HttpRouter.Route<any, any> {
+  const endpoint = handler.endpoint
   return HttpRouter.route(
     endpoint.method,
     endpoint.path as HttpRouter.PathInput,
-    effect,
+    handlerToHttpEffect(group, endpoint, services, handler.handler, handler.isRaw),
     { uninterruptible: handler.uninterruptible }
   )
 }
@@ -585,7 +635,7 @@ const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
 ) => {
   const options = { group, endpoint }
   for (const key_ of endpoint.middlewares) {
-    const key = key_ as any as HttpApiMiddleware.AnyKey
+    const key = key_ as any as HttpApiMiddleware.AnyService
     const service = services.mapUnsafe.get(key_.key) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
     const apply = HttpApiMiddleware.isSecurity(key)
       ? makeSecurityMiddleware(key, service as any)
@@ -601,7 +651,7 @@ const securityMiddlewareCache = new WeakMap<
 >()
 
 const makeSecurityMiddleware = (
-  key: HttpApiMiddleware.AnyKeySecurity,
+  key: HttpApiMiddleware.AnyServiceSecurity,
   service: HttpApiMiddleware.HttpApiMiddlewareSecurity<any, any, any, any>
 ): (effect: Effect.Effect<any, any, any>, options: any) => Effect.Effect<any, any, any> => {
   if (securityMiddlewareCache.has(key)) {
@@ -693,6 +743,9 @@ function getResponseEncode<E>(
   switch (encoding._tag) {
     case "Json": {
       return ((e) => {
+        if (e === undefined) {
+          return Effect.succeed(Response.empty({ status }))
+        }
         try {
           const s = JSON.stringify(e)
           return Effect.succeed(Response.text(s, { status, contentType: encoding.contentType }))

package/src/unstable/httpapi/HttpApiClient.ts

@@ -23,7 +23,7 @@ import * as HttpMethod from "../http/HttpMethod.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
-import type { HttpApiSchemaError } from "./HttpApiError.ts"
+import type { BadRequest } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -32,7 +32,7 @@ import * as HttpApiSchema from "./HttpApiSchema.ts"
  * @since 4.0.0
  * @category models
  */
-export type Client<Groups extends HttpApiGroup.Any, E, R> = Simplify<
+export type Client<Groups extends HttpApiGroup.Any, E = BadRequest, R = never> = Simplify<
   & {
     readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: Client.Group<
       Group,
@@ -46,6 +46,14 @@ export type Client<Groups extends HttpApiGroup.Any, E, R> = Simplify<
   }
 >
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type ForApi<Api extends HttpApi.Any, E = BadRequest, R = never> = Api extends
+  HttpApi.HttpApi<infer _Id, infer Groups> ? Client<Groups, E, R> :
+  never
+
 /**
  * @since 4.0.0
  * @category models
@@ -112,6 +120,44 @@ export declare namespace Client {
       never
 }
 
+type ApiGroups<Api extends HttpApi.Any> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? Groups : never
+
+type EndpointId<Endpoint extends HttpApiEndpoint.Any> = Endpoint extends {
+  readonly method: infer Method extends HttpMethod.HttpMethod
+  readonly path: infer Path extends string
+} ? `${Method} ${Path}`
+  : never
+
+type EndpointWithId<Endpoints extends HttpApiEndpoint.Any, Id extends string> = Id extends
+  `${infer Method extends HttpMethod.HttpMethod} ${infer Path extends string}` ?
+  Extract<Endpoints, { readonly method: Method; readonly path: Path }> :
+  never
+
+type UrlBuilderRequest<Endpoint extends HttpApiEndpoint.Any> = (
+  & ([HttpApiEndpoint.Params<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly params: HttpApiEndpoint.Params<Endpoint>["Encoded"] })
+  & ([HttpApiEndpoint.Query<Endpoint>["Encoded"]] extends [never] ? {}
+    : { readonly query: HttpApiEndpoint.Query<Endpoint>["Encoded"] })
+) extends infer Request ? keyof Request extends never ? void | undefined : Request
+  : never
+
+type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<Endpoint>] extends [void | undefined] ?
+  [request?: UrlBuilderRequest<Endpoint>]
+  : [request: UrlBuilderRequest<Endpoint>]
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type UrlBuilder<Api extends HttpApi.Any> = <
+  const GroupName extends HttpApiGroup.Name<ApiGroups<Api>>,
+  const Id extends EndpointId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>>
+>(
+  group: GroupName,
+  endpoint: Id,
+  ...args: UrlBuilderArgs<EndpointWithId<HttpApiGroup.EndpointsWithName<ApiGroups<Api>, GroupName>, Id>>
+) => string
+
 const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
@@ -128,7 +174,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
       readonly group: HttpApiGroup.AnyWithProps
       readonly endpoint: HttpApiEndpoint.AnyWithProps
       readonly mergedAnnotations: ServiceMap.ServiceMap<never>
-      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyKey>
+      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyService>
       readonly successes: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly errors: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly endpointFn: Function
@@ -217,7 +263,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
         })
 
         // encoders
-        const encodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect)
 
         const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint)
         const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ?
@@ -226,8 +272,8 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) :
           undefined
 
-        const encodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.encodeUnknownEffect)
-        const encodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeHeaders = UndefinedOr.map(endpoint.headers, Schema.encodeUnknownEffect)
+        const encodeQuery = UndefinedOr.map(endpoint.query, Schema.encodeUnknownEffect)
 
         const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`)
 
@@ -314,7 +360,7 @@ export const make = <ApiId extends string, Groups extends HttpApiGroup.Any>(
     readonly baseUrl?: URL | string | undefined
   }
 ): Effect.Effect<
-  Client<Groups, HttpApiSchemaError, never>,
+  Client<Groups>,
   never,
   HttpClient.HttpClient | HttpApiGroup.MiddlewareClient<Groups>
 > =>
@@ -337,7 +383,7 @@ export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Any,
       | undefined
     readonly baseUrl?: URL | string | undefined
   }
-): Effect.Effect<Client<Groups, HttpApiSchemaError | E, R>, never, HttpApiGroup.MiddlewareClient<Groups>> => {
+): Effect.Effect<Client<Groups, BadRequest | E, R>, never, HttpApiGroup.MiddlewareClient<Groups>> => {
   const client: Record<string, Record<string, any>> = {}
   return makeClient(api, {
     ...options,
@@ -372,7 +418,7 @@ export const group = <
     readonly baseUrl?: URL | string | undefined
   }
 ): Effect.Effect<
-  Client.Group<Groups, GroupName, HttpApiSchemaError | E, R>,
+  Client.Group<Groups, GroupName, BadRequest | E, R>,
   never,
   HttpApiGroup.MiddlewareClient<HttpApiGroup.WithName<Groups, GroupName>>
 > => {
@@ -412,7 +458,7 @@ export const endpoint = <
 ): Effect.Effect<
   Client.Method<
     HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>, EndpointName>,
-    HttpApiSchemaError | E,
+    BadRequest | E,
     R
   >,
   never,
@@ -430,6 +476,49 @@ export const endpoint = <
   }).pipe(Effect.map(() => client)) as any
 }
 
+/**
+ * Creates a type-safe URL builder keyed by `${method} ${path}`.
+ *
+ * @example
+ * ```ts
+ * import { Schema } from "effect"
+ * import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
+ *
+ * const Api = HttpApi.make("Api").add(
+ *   HttpApiGroup.make("users").add(
+ *     HttpApiEndpoint.get("getUser", "/users/:id", {
+ *       params: { id: Schema.String }
+ *     })
+ *   )
+ * )
+ *
+ * const buildUrl = HttpApiClient.urlBuilder<typeof Api>({
+ *   baseUrl: "https://api.example.com"
+ * })
+ *
+ * buildUrl("users", "GET /users/:id", {
+ *   params: { id: "123" }
+ * })
+ * //=> "https://api.example.com/users/123"
+ * ```
+ * @since 4.0.0
+ * @category constructors
+ */
+export const urlBuilder = <Api extends HttpApi.Any>(options?: {
+  readonly baseUrl?: URL | string | undefined
+}): UrlBuilder<Api> => {
+  return ((_: string, endpoint: string, request?: {
+    readonly params?: Record<string, string | undefined> | undefined
+    readonly query?: UrlParams.Input | undefined
+  }) => {
+    const path = endpoint.slice(endpoint.indexOf(" ") + 1)
+    const withParams = request?.params === undefined ? path : compilePath(path)(request.params)
+    const query = request?.query === undefined ? "" : UrlParams.toString(UrlParams.fromInput(request.query))
+    const url = query === "" ? withParams : `${withParams}?${query}`
+    return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
+  }) as UrlBuilder<Api>
+}
+
 // ----------------------------------------------------------------------------
 
 const paramsRegExp = /:(\w+)\??/g
@@ -440,7 +529,7 @@ const compilePath = (path: string) => {
   if (len === 1) {
     return (_: any) => path
   }
-  return (params: Record<string, string>) => {
+  return (params: Record<string, string | undefined>) => {
     let url = segments[0]
     for (let i = 1; i < len; i++) {
       if (i % 2 === 0) {