effect 4.0.0-beta.37 → 4.0.0-beta.39

package/src/unstable/eventlog/SqlEventLogJournal.ts

@@ -199,7 +199,7 @@ export const make = (options?: {
             event,
             primaryKey,
             payload
-          }, { disableValidation: true })
+          }, { disableChecks: true })
           yield* insertEntry(toEntryRow(entry))
           const value = yield* effect(entry)
           yield* PubSub.publish(pubsub, entry)
@@ -280,7 +280,7 @@ const toEntry = (row: EntryRow): EventJournal.Entry =>
     event: row.event,
     primaryKey: row.primary_key,
     payload: row.payload
-  }, { disableValidation: true })
+  }, { disableChecks: true })
 
 const toEntryRow = (entry: EventJournal.Entry): EntryRow => ({
   id: entry.id,

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -652,7 +652,7 @@ const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
 }
 
 const securityMiddlewareCache = new WeakMap<
-  any,
+  object,
   (effect: Effect.Effect<any, any, any>, options: any) => Effect.Effect<any, any, any>
 >()
 
@@ -660,13 +660,14 @@ const makeSecurityMiddleware = (
   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)) {
-    return securityMiddlewareCache.get(key)!
+  const cached = securityMiddlewareCache.get(service)
+  if (cached !== undefined) {
+    return cached
   }
 
-  const entries = Object.entries(key.security).map(([key, security]) => ({
+  const entries = Object.entries(key.security).map(([securityKey, security]) => ({
     decode: securityDecode(security),
-    middleware: service[key]
+    middleware: service[securityKey]
   }))
   if (entries.length === 0) {
     return identity
@@ -694,7 +695,7 @@ const makeSecurityMiddleware = (
     return yield* lastResult!.asEffect()
   })
 
-  securityMiddlewareCache.set(key, middleware)
+  securityMiddlewareCache.set(service, middleware)
   return middleware
 }
 
@@ -734,7 +735,11 @@ function getResponseTransformation(
   schema: Schema.Top
 ): Transformation.Transformation<unknown, Response.HttpServerResponse> {
   const ast = schema.ast
-  const encode = getResponseEncode(getStatus(ast), HttpApiSchema.getResponseEncoding(ast))
+  const encode = getResponseEncode(
+    getStatus(ast),
+    HttpApiSchema.getResponseEncoding(ast),
+    HttpApiSchema.isNoContent(ast)
+  )
 
   return Transformation.transformOrFail({
     decode: (res) => Effect.fail(new Issue.Forbidden(Option.some(res), { message: "Encode only schema" })),
@@ -744,12 +749,13 @@ function getResponseTransformation(
 
 function getResponseEncode<E>(
   status: number,
-  encoding: HttpApiSchema.ResponseEncoding
+  encoding: HttpApiSchema.ResponseEncoding,
+  isNoContent: boolean
 ): (e: E) => Effect.Effect<Response.HttpServerResponse, Issue.InvalidValue, never> {
   switch (encoding._tag) {
     case "Json": {
       return ((e) => {
-        if (e === undefined) {
+        if (e === undefined || isNoContent) {
           return Effect.succeed(Response.empty({ status }))
         }
         try {

package/src/unstable/httpapi/HttpApiClient.ts

@@ -8,7 +8,7 @@ import { identity } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import type * as AST from "../../SchemaAST.ts"
+import * as AST from "../../SchemaAST.ts"
 import * as Issue from "../../SchemaIssue.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
 import type * as ServiceMap from "../../ServiceMap.ts"
@@ -59,6 +59,21 @@ export type ForApi<Api extends HttpApi.Any, E = BadRequest, R = never> = Api ext
  * @category models
  */
 export declare namespace Client {
+  /**
+   * @since 4.0.0
+   * @category models
+   */
+  export type ResponseMode = HttpApiEndpoint.ClientResponseMode
+
+  /**
+   * @since 4.0.0
+   * @category models
+   */
+  export type Response<Success, Mode extends ResponseMode> = [Mode] extends ["decoded-and-response"]
+    ? [Success, HttpClientResponse.HttpClientResponse]
+    : [Mode] extends ["response-only"] ? HttpClientResponse.HttpClientResponse
+    : Success
+
   /**
    * @since 4.0.0
    * @category models
@@ -88,23 +103,21 @@ export declare namespace Client {
       infer _Middleware,
       infer _MR
     >
-  ] ? <WithResponse extends boolean = false>(
-      request: Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, WithResponse>>
+  ] ? <Mode extends ResponseMode = ResponseMode>(
+      request: Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, Mode>>
     ) => Effect.Effect<
-      WithResponse extends true ? [_Success["Type"], HttpClientResponse.HttpClientResponse] : _Success["Type"],
-      | _Error["Type"]
+      Response<_Success["Type"], Mode>,
       | HttpApiMiddleware.Error<_Middleware>
       | HttpApiMiddleware.ClientError<_Middleware>
       | E
       | HttpClientError.HttpClientError
-      | Schema.SchemaError,
+      | ([Mode] extends ["response-only"] ? never : _Error["Type"] | Schema.SchemaError),
       | R
       | _Params["EncodingServices"]
       | _Query["EncodingServices"]
       | _Payload["EncodingServices"]
       | _Headers["EncodingServices"]
-      | _Success["DecodingServices"]
-      | _Error["DecodingServices"]
+      | ([Mode] extends ["response-only"] ? never : _Success["DecodingServices"] | _Error["DecodingServices"])
     > :
     never
 
@@ -120,24 +133,11 @@ 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"] })
+  & ([HttpApiEndpoint.Params<Endpoint>["Type"]] extends [never] ? {}
+    : { readonly params: HttpApiEndpoint.Params<Endpoint>["Type"] })
+  & ([HttpApiEndpoint.Query<Endpoint>["Type"]] extends [never] ? {}
+    : { readonly query: HttpApiEndpoint.Query<Endpoint>["Type"] })
 ) extends infer Request ? keyof Request extends never ? void | undefined : Request
   : never
 
@@ -149,15 +149,33 @@ type UrlBuilderArgs<Endpoint extends HttpApiEndpoint.Any> = [UrlBuilderRequest<E
  * @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>>
+export type UrlBuilder<Api extends HttpApi.Any> = Api extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? Simplify<
+    & {
+      readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: UrlBuilderGroup<
+        HttpApiGroup.Endpoints<Group>
+      >
+    }
+    & {
+      readonly [Method in UrlBuilderTopLevelMethods<Groups> as Method[0]]: Method[1]
+    }
+  >
+  : never
+
+type UrlBuilderGroup<Endpoints extends HttpApiEndpoint.Any> = {
+  readonly [Endpoint in Endpoints as HttpApiEndpoint.Name<Endpoint>]: UrlBuilderMethod<Endpoint>
+}
+
+type UrlBuilderMethod<Endpoint extends HttpApiEndpoint.Any> = (
+  ...args: UrlBuilderArgs<Endpoint>
 ) => string
 
+type UrlBuilderTopLevelMethods<Groups extends HttpApiGroup.Any> = Extract<Groups, { readonly topLevel: true }> extends
+  HttpApiGroup.HttpApiGroup<infer _Id, infer _Endpoints, infer _TopLevel> ?
+  _Endpoints extends infer Endpoint extends HttpApiEndpoint.Any ?
+    [HttpApiEndpoint.Name<Endpoint>, UrlBuilderMethod<Endpoint>]
+  : never :
+  never
+
 const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>(
   api: HttpApi.HttpApi<ApiId, Groups>,
   options: {
@@ -268,7 +286,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
         const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint)
         const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ?
           HttpMethod.hasBody(endpoint.method)
-            ? Schema.encodeUnknownEffect(getEncodePayloadSchema(payloadSchemas))
+            ? Schema.encodeUnknownEffect(getEncodePayloadSchema(payloadSchemas, endpoint.method))
             : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) :
           undefined
 
@@ -283,7 +301,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             readonly query: unknown
             readonly payload: unknown
             readonly headers: Record<string, string> | undefined
-            readonly withResponse?: boolean
+            readonly responseMode?: HttpApiEndpoint.ClientResponseMode
           } | undefined
         ) {
           let httpRequest = HttpClientRequest.make(endpoint.method)(endpoint.path)
@@ -331,11 +349,15 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             middlewareKeys.length - 1
           )
 
+          if (request?.responseMode === "response-only") {
+            return response
+          }
+
           const value = yield* (options.transformResponse === undefined
             ? decodeResponse(response)
             : options.transformResponse(decodeResponse(response)))
 
-          return request?.withResponse === true ? [value, response] : value
+          return request?.responseMode === "decoded-and-response" ? [value, response] : value
         })
 
         options.onEndpoint({
@@ -477,7 +499,7 @@ export const endpoint = <
 }
 
 /**
- * Creates a type-safe URL builder keyed by `${method} ${path}`.
+ * Creates a type-safe URL builder that mirrors `HttpApiClient.make`.
  *
  * @example
  * ```ts
@@ -492,11 +514,11 @@ export const endpoint = <
  *   )
  * )
  *
- * const buildUrl = HttpApiClient.urlBuilder<typeof Api>({
+ * const buildUrl = HttpApiClient.urlBuilder(Api, {
  *   baseUrl: "https://api.example.com"
  * })
  *
- * buildUrl("users", "GET /users/:id", {
+ * buildUrl.users.getUser({
  *   params: { id: "123" }
  * })
  * //=> "https://api.example.com/users/123"
@@ -504,19 +526,45 @@ export const endpoint = <
  * @since 4.0.0
  * @category constructors
  */
-export const urlBuilder = <Api extends HttpApi.Any>(options?: {
+export const urlBuilder = <Api extends HttpApi.Any>(api: Api, 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 builder: Record<string, any> = {}
+
+  HttpApi.reflect(api as unknown as HttpApi.AnyWithProps, {
+    onGroup({ group }) {
+      if (group.topLevel) return
+      builder[group.identifier] = {}
+    },
+    onEndpoint({ group, endpoint }) {
+      const makeUrl = compilePath(endpoint.path)
+      const encodeParams = endpoint.params === undefined
+        ? undefined
+        : Schema.encodeSync(endpoint.params as Schema.Encoder<unknown>)
+      const encodeQuery = endpoint.query === undefined
+        ? undefined
+        : Schema.encodeSync(endpoint.query as Schema.Encoder<unknown>)
+
+      const endpointBuilder = (request?: {
+        readonly params?: unknown
+        readonly query?: unknown
+      }) => {
+        const params = request?.params
+        const path = params === undefined
+          ? endpoint.path
+          : makeUrl((encodeParams === undefined ? params : encodeParams(params)) as Record<string, string | undefined>)
+        const queryInput = request?.query === undefined
+          ? undefined
+          : (encodeQuery === undefined ? request.query : encodeQuery(request.query)) as UrlParams.Input
+        const query = queryInput === undefined ? "" : UrlParams.toString(UrlParams.fromInput(queryInput))
+        const url = query === "" ? path : `${path}?${query}`
+        return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
+      }
+      ;(group.topLevel ? builder : builder[group.identifier])[endpoint.name] = endpointBuilder
+    }
+  })
+
+  return builder as UrlBuilder<Api>
 }
 
 // ----------------------------------------------------------------------------
@@ -608,8 +656,19 @@ function toCodecArrayBuffer(schemas: readonly [Schema.Top, ...Array<Schema.Top>]
   function onSchema(schema: Schema.Top) {
     const encoding = HttpApiSchema.getResponseEncoding(schema.ast)
     switch (encoding._tag) {
-      case "Json":
-        return UnknownFromArrayBuffer.pipe(Schema.decodeTo(schema))
+      case "Json": {
+        // handle json codecs that transform void schemas to null
+        const encodedIsNull = AST.isNull(AST.toEncoded(schema.ast))
+        return UnknownFromArrayBuffer.pipe(Schema.decodeTo(
+          schema,
+          encodedIsNull ?
+            Transformation.transform({
+              decode: (a) => a === undefined ? null : a,
+              encode: (a) => a === null ? undefined : a
+            }) as any :
+            undefined
+        ))
+      }
       case "FormUrlEncoded":
         return StringFromArrayBuffer.pipe(
           Schema.decodeTo(UrlParams.schemaRecord),
@@ -635,21 +694,25 @@ const statusOrElse = (response: HttpClientResponse.HttpClientResponse) =>
 
 const $HttpBody = Schema.declare(HttpBody.isHttpBody)
 
-function getEncodePayloadSchema(schemas: readonly [Schema.Top, ...Array<Schema.Top>]): Schema.Top {
-  return Schema.Union(schemas.map(getEncodePayloadSchemaFromBody))
+function getEncodePayloadSchema(
+  schemas: readonly [Schema.Top, ...Array<Schema.Top>],
+  method: HttpMethod.HttpMethod
+): Schema.Top {
+  return Schema.Union(schemas.map((s) => getEncodePayloadSchemaFromBody(s, method)))
 }
 
 const bodyFromPayloadCache = new WeakMap<AST.AST, Schema.Top>()
 
 function getEncodePayloadSchemaFromBody(
-  schema: Schema.Top
+  schema: Schema.Top,
+  method: HttpMethod.HttpMethod
 ): Schema.Top {
   const ast = schema.ast
   const cached = bodyFromPayloadCache.get(ast)
   if (cached !== undefined) {
     return cached
   }
-  const encoding = HttpApiSchema.getPayloadEncoding(ast)
+  const encoding = HttpApiSchema.getPayloadEncoding(ast, method)
   const out = $HttpBody.pipe(Schema.decodeTo(
     schema,
     Transformation.transformOrFail({

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -4,6 +4,7 @@
 import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import type { Effect } from "../../Effect.ts"
+import { identity } from "../../Function.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -476,7 +477,7 @@ export type ClientRequest<
   Query extends Schema.Top,
   Payload extends Schema.Top,
   Headers extends Schema.Top,
-  WithResponse extends boolean
+  ResponseMode extends ClientResponseMode
 > = (
   & ([Params["Type"]] extends [never] ? {} : { readonly params: Params["Type"] })
   & ([Query["Type"]] extends [never] ? {} : { readonly query: Query["Type"] })
@@ -487,10 +488,16 @@ export type ClientRequest<
         ? { readonly payload: FormData }
       : { readonly payload: Payload["Type"] }
     : { readonly payload: Payload["Type"] })
-) extends infer Req ? keyof Req extends never ? (void | { readonly withResponse?: WithResponse }) :
-  Req & { readonly withResponse?: WithResponse } :
+) extends infer Req ? keyof Req extends never ? (void | { readonly responseMode?: ResponseMode }) :
+  Req & { readonly responseMode?: ResponseMode } :
   void
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type ClientResponseMode = "decoded-only" | "decoded-and-response" | "response-only"
+
 /**
  * @since 4.0.0
  * @category models
@@ -888,6 +895,14 @@ export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMe
   > :
   SuccessConstraint
 
+/**
+ * @since 4.0.0
+ * @category constraints
+ */
+export type PayloadConstraintCodecs<Method extends HttpMethod> = Method extends HttpMethod.NoBody ?
+  Record<string, Schema.Top> :
+  Schema.Top | ReadonlyArray<Schema.Top>
+
 /**
  * @since 4.0.0
  * @category constraints
@@ -904,7 +919,73 @@ export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
  * @since 4.0.0
  * @category constructors
  */
-export const make = <Method extends HttpMethod>(method: Method) =>
+export const make = <Method extends HttpMethod>(method: Method): {
+  <
+    const Name extends string,
+    const Path extends HttpRouter.PathInput,
+    Params extends Schema.Top | Schema.Struct.Fields = never,
+    Query extends Schema.Top | Schema.Struct.Fields = never,
+    Payload extends PayloadConstraintCodecs<Method> = never,
+    Headers extends Schema.Top | Schema.Struct.Fields = never,
+    const Success extends Schema.Top | ReadonlyArray<Schema.Top> = HttpApiSchema.NoContent,
+    const Error extends Schema.Top | ReadonlyArray<Schema.Top> = never
+  >(
+    name: Name,
+    path: Path,
+    options?: {
+      readonly disableCodecs?: false | undefined
+      readonly params?: Params | undefined
+      readonly query?: Query | undefined
+      readonly headers?: Headers | undefined
+      readonly payload?: Payload | undefined
+      readonly success?: Success | undefined
+      readonly error?: Error | undefined
+    }
+  ): HttpApiEndpoint<
+    Name,
+    Method,
+    Path,
+    StringTree<Params extends Schema.Struct.Fields ? Schema.Struct<Params> : Params>,
+    StringTree<Query extends Schema.Struct.Fields ? Schema.Struct<Query> : Query>,
+    Method extends HttpMethod.WithBody ? Json<ExtractSchemaOrArray<Payload>>
+      : StringTree<ExtractSchemaOrArray<Payload>>,
+    StringTree<Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers>,
+    Json<Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success>,
+    Json<(Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent>
+  >
+  <
+    const Name extends string,
+    const Path extends HttpRouter.PathInput,
+    Params extends ParamsConstraint = never,
+    Query extends QueryConstraint = never,
+    Payload extends PayloadConstraint<Method> = never,
+    Headers extends HeadersConstraint = never,
+    const Success extends SuccessConstraint = HttpApiSchema.NoContent,
+    const Error extends ErrorConstraint = never
+  >(
+    name: Name,
+    path: Path,
+    options?: {
+      readonly disableCodecs: true
+      readonly params?: Params | undefined
+      readonly query?: Query | undefined
+      readonly headers?: Headers | undefined
+      readonly payload?: Payload | undefined
+      readonly success?: Success | undefined
+      readonly error?: Error | undefined
+    }
+  ): HttpApiEndpoint<
+    Name,
+    Method,
+    Path,
+    Params extends Schema.Struct.Fields ? Schema.Struct<Params> : Params,
+    Query extends Schema.Struct.Fields ? Schema.Struct<Query> : Query,
+    ExtractSchemaOrArray<Payload>,
+    ExtractSchemaOrArray<Headers>,
+    Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
+    (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent
+  >
+} =>
 <
   const Name extends string,
   const Path extends HttpRouter.PathInput,
@@ -918,6 +999,7 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   name: Name,
   path: Path,
   options?: {
+    readonly disableCodecs?: boolean | undefined
     readonly params?: Params | undefined
     readonly query?: Query | undefined
     readonly headers?: Headers | undefined
@@ -938,42 +1020,62 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
   (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent
 > => {
+  const disableCodecs = options?.disableCodecs ?? false
+  const transformStringTree = disableCodecs ? identity : Schema.toCodecStringTree
   return makeProto({
     name,
     path,
     method,
-    params: getParams(options?.params),
-    query: getQuery(options?.query),
-    headers: getHeaders(options?.headers),
-    payload: getPayload(options?.payload),
-    success: getSuccess(options?.success),
-    error: getError(options?.error),
+    params: ensureStruct(options?.params, transformStringTree),
+    query: ensureStruct(options?.query, transformStringTree),
+    headers: ensureStruct(options?.headers, transformStringTree),
+    payload: getPayload(options?.payload, method, disableCodecs),
+    success: getResponse(options?.success, disableCodecs),
+    error: getResponse(options?.error, disableCodecs),
     annotations: ServiceMap.empty(),
     middlewares: new Set()
   })
 }
 
-function getParams(params: ParamsConstraint | undefined): Schema.Top | undefined {
-  if (params === undefined) return undefined
-  if (Schema.isSchema(params)) return params
-  return Schema.Struct(params)
-}
+type ExtractSchemaOrArray<S extends Schema.Struct.Fields | Schema.Top | ReadonlyArray<Schema.Top>> = S extends
+  Schema.Struct.Fields ? Schema.Struct<S>
+  : S extends ReadonlyArray<Schema.Top> ? S[number]
+  : S
 
-function getQuery(query: QueryConstraint | undefined): Schema.Top | undefined {
-  if (query === undefined) return undefined
-  if (Schema.isSchema(query)) return query
-  return Schema.Struct(query)
-}
+/**
+ * @since 4.0.0
+ * @category Codecs
+ */
+export interface Json<S extends Schema.Top>
+  extends Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+{}
+
+/**
+ * @since 4.0.0
+ * @category Codecs
+ */
+export interface StringTree<S extends Schema.Top> extends
+  Schema.Codec<
+    S["Type"],
+    Schema.StringTree,
+    S["DecodingServices"],
+    S["EncodingServices"]
+  >
+{}
 
-// all keys should be lowercase
-function getHeaders(headers: HeadersConstraint | undefined): Schema.Top | undefined {
-  if (headers === undefined) return undefined
-  if (Schema.isSchema(headers)) return headers
-  return Schema.Struct(headers)
+function ensureStruct(
+  params: Schema.Struct.Fields | Schema.Top | undefined,
+  transform: typeof Schema.toCodecJson | typeof Schema.toCodecStringTree
+): Schema.Top | undefined {
+  if (params === undefined) return undefined
+  if (Schema.isSchema(params)) return transform(params)
+  return transform(Schema.Struct(params))
 }
 
 function getPayload(
-  payload: Schema.Top | ReadonlyArray<Schema.Top> | Schema.Struct.Fields | undefined
+  payload: Schema.Top | ReadonlyArray<Schema.Top> | Schema.Struct.Fields | undefined,
+  method: HttpMethod,
+  disableCodecs: boolean
 ): PayloadMap {
   const result: Map<string, { encoding: HttpApiSchema.PayloadEncoding; schemas: [Schema.Top, ...Array<Schema.Top>] }> =
     new Map()
@@ -982,9 +1084,11 @@ function getPayload(
     ? payload
     : Schema.isSchema(payload)
     ? [payload]
-    : [Schema.Struct(payload as any).pipe(HttpApiSchema.asFormUrlEncoded())]
+    : [(Schema.Struct(payload as any)).pipe(HttpApiSchema.asFormUrlEncoded())]
+  const transform = disableCodecs ? identity : transformPayload
+
   for (const schema of schemas) {
-    const encoding = HttpApiSchema.getPayloadEncoding(schema.ast)
+    const encoding = HttpApiSchema.getPayloadEncoding(schema.ast, method)
     const existing = result.get(encoding.contentType)
     if (existing) {
       if (existing.encoding._tag !== encoding._tag) {
@@ -993,24 +1097,48 @@ function getPayload(
       if (existing.encoding._tag === "Multipart") {
         throw new Error(`Multiple multipart payloads for content-type: ${encoding.contentType}`)
       }
-      existing.schemas.push(schema)
+      existing.schemas.push(transform(schema, method))
     } else {
-      result.set(encoding.contentType, { encoding, schemas: [schema] })
+      result.set(encoding.contentType, { encoding, schemas: [transform(schema, method)] })
     }
   }
   return result
 }
 
-function getSuccess(
-  success: Schema.Top | ReadonlyArray<Schema.Top> | undefined
+function getResponse(
+  success: Schema.Top | ReadonlyArray<Schema.Top> | undefined,
+  disableCodecs: boolean
 ): Set<Schema.Top> {
   if (success === undefined) return new Set()
-  return new Set(Array.isArray(success) ? success : [success])
+  const arr = Arr.ensure(success)
+  return new Set(disableCodecs ? arr : arr.map(transformResponse))
 }
 
-function getError(error: Schema.Top | ReadonlyArray<Schema.Top> | undefined): Set<Schema.Top> {
-  if (error === undefined) return new Set()
-  return new Set(Array.isArray(error) ? error : [error])
+function transformResponse(schema: Schema.Top): Schema.Top {
+  const encoding = HttpApiSchema.getResponseEncoding(schema.ast)
+  switch (encoding._tag) {
+    case "Json":
+      return Schema.toCodecJson(schema)
+    case "FormUrlEncoded":
+      return Schema.toCodecStringTree(schema)
+    case "Text":
+    case "Uint8Array":
+      return schema
+  }
+}
+
+function transformPayload(schema: Schema.Top, method: HttpMethod): Schema.Top {
+  const encoding = HttpApiSchema.getPayloadEncoding(schema.ast, method)
+  switch (encoding._tag) {
+    case "Json":
+      return Schema.toCodecJson(schema)
+    case "FormUrlEncoded":
+      return Schema.toCodecStringTree(schema)
+    case "Text":
+    case "Uint8Array":
+    case "Multipart":
+      return schema
+  }
 }
 
 /**