effect 4.0.0-beta.37 → 4.0.0-beta.38

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
+  }
 }
 
 /**

package/src/unstable/httpapi/HttpApiSchema.ts

@@ -31,6 +31,7 @@ import { constVoid, type LazyArg } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import { hasBody, type HttpMethod } from "../http/HttpMethod.ts"
 import type * as Multipart_ from "../http/Multipart.ts"
 
 declare module "../../Schema.ts" {
@@ -332,6 +333,17 @@ export function asUint8Array(options?: {
   return <S extends Schema.Top & { readonly Encoded: Uint8Array }>(self: S) =>
     asNonMultipartEncoding(self, { _tag: "Uint8Array", ...options })
 }
+/**
+ * @since 4.0.0
+ */
+export const isNoContent = (ast: AST.AST): boolean => {
+  if (AST.isVoid(ast)) return true
+  const encoded = AST.toEncoded(ast)
+  if (AST.isVoid(encoded)) return true
+  const target = ast.encoding?.[0].to
+  if (target === undefined) return false
+  return AST.isVoid(target)
+}
 
 const resolveHttpApiEncoding = AST.resolveAt<Encoding>("~httpApiEncoding")
 
@@ -341,14 +353,20 @@ const defaultJsonEncoding: Encoding = {
   _tag: "Json",
   contentType: "application/json"
 }
+const defaultUrlEncodedEncoding: Encoding = {
+  _tag: "FormUrlEncoded",
+  contentType: "application/x-www-form-urlencoded"
+}
 
 function getEncoding(ast: AST.AST): Encoding {
   return resolveHttpApiEncoding(ast) ?? defaultJsonEncoding
 }
 
 /** @internal */
-export function getPayloadEncoding(ast: AST.AST): PayloadEncoding {
-  return getEncoding(ast)
+export function getPayloadEncoding(ast: AST.AST, method: HttpMethod): PayloadEncoding {
+  const encoding = resolveHttpApiEncoding(ast)
+  if (encoding) return encoding
+  return hasBody(method) ? defaultJsonEncoding : defaultUrlEncodedEncoding
 }
 
 /** @internal */

package/src/unstable/httpapi/OpenApi.ts

@@ -314,7 +314,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
           const c: OpenApiSpecContent = {}
           let hasContent = false
           payloadMap.forEach(({ encoding, schemas }, contentType) => {
-            const filtered = schemas.filter((s) => !isNoContent(s.ast))
+            const filtered = schemas.filter((s) => !HttpApiSchema.isNoContent(s.ast))
             if (filtered.length === 0) return
             hasContent = true
             const asts = filtered.map(AST.getAST)
@@ -529,10 +529,6 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
   return spec
 }
 
-function isNoContent(ast: AST.AST): boolean {
-  return AST.isVoid(AST.toEncoded(ast))
-}
-
 type ResponseBodies = Map<
   number, // status
   {
@@ -558,7 +554,7 @@ function extractResponseBodies(
   function process(schema: Schema.Top) {
     const ast = schema.ast
     const status = getStatus(ast)
-    if (isNoContent(ast)) {
+    if (HttpApiSchema.isNoContent(ast)) {
       addNoContent(status, getDescription(schema.ast) ?? "<No Content>")
     } else {
       addContent(schema, status, HttpApiSchema.getResponseEncoding(ast))

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -41,12 +41,12 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       Name
     >,
-    const WithResponse extends boolean = false
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
   >(
     group: GroupName,
     endpoint: Name,
     options?: {
-      readonly withResponse?: WithResponse | undefined
+      readonly responseMode?: ResponseMode | undefined
     }
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
@@ -64,11 +64,11 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.AtomResultFn<
       Simplify<
-        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, false> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, "decoded-only"> & {
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
-      WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
+      ResponseByMode<_Success["Type"], ResponseMode>,
       _Error["Type"]
     >
     : never
@@ -81,7 +81,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       Name
     >,
-    const WithResponse extends boolean = false
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
     group: GroupName,
     endpoint: Name,
@@ -100,7 +100,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
         infer _RE
       >
     ] ? Simplify<
-        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, WithResponse> & {
+        HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, ResponseMode> & {
           readonly reactivityKeys?:
             | ReadonlyArray<unknown>
             | ReadonlyRecord<string, ReadonlyArray<unknown>>
@@ -125,7 +125,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
-        WithResponse extends true ? [_Success["Type"], HttpClientResponse] : _Success["Type"],
+        ResponseByMode<_Success["Type"], ResponseMode>,
         _Error["Type"]
       >
     >
@@ -175,7 +175,7 @@ export const Service = <Self>() =>
     Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
   )
 
-  const mutationFamily = Atom.family(({ endpoint, group, withResponse }: MutationKey) => {
+  const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
     const atom = self.runtime.fn<{
       params: any
       query: any
@@ -187,14 +187,14 @@ export const Service = <Self>() =>
         const client = (yield* self) as any
         const effect = catchErrors(client[group][endpoint]({
           ...opts,
-          withResponse
+          responseMode
         }) as Effect.Effect<any>)
         return yield* opts.reactivityKeys
           ? Reactivity.mutation(effect, opts.reactivityKeys)
           : effect
       })
     )
-    if (withResponse === false) {
+    if (responseMode === "decoded-only") {
       const definition = options.api.groups[group]!.endpoints[endpoint]! as HttpApiEndpoint.AnyWithProps
       return Atom.serializable(atom, {
         key: `AtomHttpApi:mutation:${group}:${endpoint}`,
@@ -208,12 +208,12 @@ export const Service = <Self>() =>
   }) as any
 
   self.mutation = ((group: string, endpoint: string, options?: {
-    readonly withResponse?: boolean | undefined
+    readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
   }) =>
     mutationFamily({
       group,
       endpoint,
-      withResponse: options?.withResponse ?? false
+      responseMode: options?.responseMode ?? "decoded-only"
     })) as any
 
   const queryFamily = Atom.family((opts: QueryKey) => {
@@ -224,7 +224,7 @@ export const Service = <Self>() =>
         HttpClientError.HttpClientError | SchemaError
       >)
     }))
-    if (opts.withResponse === false) {
+    if (opts.responseMode === "decoded-only") {
       const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
       atom = Atom.serializable(atom, {
         key: makeSerializableKey(opts),
@@ -252,7 +252,7 @@ export const Service = <Self>() =>
       readonly query?: any
       readonly payload?: any
       readonly headers?: any
-      readonly withResponse?: boolean
+      readonly responseMode?: HttpApiEndpoint.ClientResponseMode
       readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
       readonly timeToLive?: Duration.Input | undefined
     }
@@ -264,7 +264,7 @@ export const Service = <Self>() =>
       query: request.query,
       payload: request.payload,
       headers: request.headers,
-      withResponse: request.withResponse ?? false,
+      responseMode: request.responseMode ?? "decoded-only",
       reactivityKeys: request.reactivityKeys,
       timeToLive: request.timeToLive
         ? Duration.fromInputUnsafe(request.timeToLive)
@@ -277,7 +277,7 @@ export const Service = <Self>() =>
 interface MutationKey {
   group: string
   endpoint: string
-  withResponse: boolean
+  responseMode: HttpApiEndpoint.ClientResponseMode
 }
 
 interface QueryKey {
@@ -287,11 +287,16 @@ interface QueryKey {
   query: any
   headers: any
   payload: any
-  withResponse: boolean
+  responseMode: HttpApiEndpoint.ClientResponseMode
   reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
   timeToLive?: Duration.Duration | undefined
 }
 
+type ResponseByMode<Success, ResponseMode extends HttpApiEndpoint.ClientResponseMode> = [ResponseMode] extends
+  ["decoded-and-response"] ? [Success, HttpClientResponse]
+  : [ResponseMode] extends ["response-only"] ? HttpClientResponse
+  : Success
+
 const makeSerializableKey = (
   key: QueryKey
 ): string => `AtomHttpApi:${key.group}:${key.endpoint}:${Hash.hash(key)}`

package/src/unstable/schema/VariantSchema.ts

@@ -238,7 +238,7 @@ export interface Class<
   new(
     props: S["~type.make.in"],
     options?: {
-      readonly disableValidation?: boolean
+      readonly disableChecks?: boolean
     } | undefined
   ): S["Type"]