@effect/platform 0.11.4 → 0.12.0

package/src/internal/http/client.ts

@@ -1,5 +1,6 @@
 import * as Context from "@effect/data/Context"
 import { dual } from "@effect/data/Function"
+import { pipeArguments } from "@effect/data/Pipeable"
 import type * as Predicate from "@effect/data/Predicate"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
@@ -8,6 +9,7 @@ import type * as Body from "@effect/platform/Http/Body"
 import type * as Client from "@effect/platform/Http/Client"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
+import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
 import * as Method from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
@@ -21,65 +23,84 @@ import * as Stream from "@effect/stream/Stream"
 /** @internal */
 export const tag = Context.Tag<Client.Client.Default>("@effect/platform/Http/Client")
 
+const clientProto = {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const setProto = <R, E, A>(
+  f: (request: ClientRequest.ClientRequest.NonEffectBody) => Effect.Effect<R, E, A>
+) => {
+  Object.setPrototypeOf(f, clientProto)
+  return f as Client.Client<R, E, A>
+}
+
+/** @internal */
+export const make = (
+  f: (
+    request: ClientRequest.ClientRequest.NonEffectBody
+  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+): Client.Client.Default => {
+  function client(request: ClientRequest.ClientRequest) {
+    return Effect.flatMap(
+      internalRequest.resolveBody(request),
+      (request) => f(request)
+    )
+  }
+  return setProto(client)
+}
+
 /** @internal */
 export const fetch = (
   options: RequestInit = {}
 ): Client.Client.Default =>
-(request) =>
-  Effect.flatMap(
-    UrlParams.makeUrl(request.url, request.urlParams, (_) =>
-      internalError.requestError({
-        request,
-        reason: "InvalidUrl",
-        error: _
-      })),
-    (url) =>
-      Effect.suspend(() => {
-        const headers = new Headers([...request.headers] as any)
-        const send = (body: BodyInit | undefined) =>
-          Effect.map(
-            Effect.tryPromise({
-              try: (signal) =>
-                globalThis.fetch(url, {
-                  ...options,
-                  method: request.method,
-                  headers,
-                  body,
-                  signal
-                }),
-              catch: (_) =>
-                internalError.requestError({
-                  request,
-                  reason: "Transport",
-                  error: _
-                })
-            }),
-            (_) => internalResponse.fromWeb(request, _)
-          )
-        if (Method.hasBody(request.method)) {
-          return request.body._tag === "BytesEffect" ?
-            Effect.flatMap(
-              Effect.mapError(request.body.body, (error) =>
-                internalError.requestError({
-                  reason: "Encode",
-                  request,
-                  error
-                })),
-              (body) => send(body)
-            ) :
-            send(convertBody(request.body))
-        }
-        return send(undefined)
-      })
+  make((request) =>
+    Effect.flatMap(
+      UrlParams.makeUrl(request.url, request.urlParams, (_) =>
+        internalError.requestError({
+          request,
+          reason: "InvalidUrl",
+          error: _
+        })),
+      (url) =>
+        Effect.suspend(() => {
+          const headers = new Headers([...request.headers] as any)
+          const send = (body: BodyInit | undefined) =>
+            Effect.map(
+              Effect.tryPromise({
+                try: (signal) =>
+                  globalThis.fetch(url, {
+                    ...options,
+                    method: request.method,
+                    headers,
+                    body,
+                    signal
+                  }),
+                catch: (_) =>
+                  internalError.requestError({
+                    request,
+                    reason: "Transport",
+                    error: _
+                  })
+              }),
+              (_) => internalResponse.fromWeb(request, _)
+            )
+          if (Method.hasBody(request.method)) {
+            return send(convertBody(request.body))
+          }
+          return send(undefined)
+        })
+    )
   )
 
-const convertBody = (body: Exclude<Body.Body, Body.BytesEffect>): BodyInit | undefined => {
+const convertBody = (body: Body.NonEffect): BodyInit | undefined => {
   switch (body._tag) {
     case "Empty":
       return undefined
     case "Raw":
       return body.body as any
-    case "Bytes":
+    case "Uint8Array":
       return body.body
     case "FormData":
       return body.formData
@@ -93,7 +114,7 @@ export const fetchOk = (
 ): Client.Client.Default => filterStatusOk(fetch(options))
 
 /** @internal */
-export const fetchLayer = Layer.succeed(tag, fetch())
+export const layer = Layer.succeed(tag, fetch())
 
 /** @internal */
 export const catchTag: {
@@ -115,7 +136,7 @@ export const catchTag: {
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A> =>
-  (request) => Effect.catchTag(self(request), tag, f)
+    setProto((request) => Effect.catchTag(self(request), tag, f))
 )
 
 /** @internal */
@@ -225,8 +246,7 @@ export const catchTags: {
       ) => Effect.Effect<any, any, infer A> ? A
         : never
     }[keyof Cases]
-  > =>
-  (request) => Effect.catchTags(self(request), cases)
+  > => setProto((request) => Effect.catchTags(self(request), cases))
 )
 
 /** @internal */
@@ -243,8 +263,7 @@ export const catchAll: {
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
     f: (e: E) => Effect.Effect<R2, E2, A2>
-  ): Client.Client<R | R2, E2, A2 | A> =>
-  (request) => Effect.catchAll(self(request), f)
+  ): Client.Client<R | R2, E2, A2 | A> => setProto((request) => Effect.catchAll(self(request), f))
 )
 
 /** @internal */
@@ -257,7 +276,7 @@ export const filterOrElse = dual<
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R2 | R, E2 | E, A | B>
->(3, (self, f, orElse) => (request) => Effect.filterOrElse(self(request), f, orElse))
+>(3, (self, f, orElse) => setProto((request) => Effect.filterOrElse(self(request), f, orElse)))
 
 /** @internal */
 export const filterOrFail = dual<
@@ -269,7 +288,7 @@ export const filterOrFail = dual<
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
   ) => Client.Client<R, E2 | E, A>
->(3, (self, f, orFailWith) => (request) => Effect.filterOrFail(self(request), f, orFailWith))
+>(3, (self, f, orFailWith) => setProto((request) => Effect.filterOrFail(self(request), f, orFailWith)))
 
 /** @internal */
 export const filterStatus = dual<
@@ -282,17 +301,19 @@ export const filterStatus = dual<
   ) => Client.Client.WithResponse<R, E | Error.ResponseError>
 >(
   2,
-  (self, f) => (request) =>
-    Effect.filterOrFail(
-      self(request),
-      (response) => f(response.status),
-      (response) =>
-        internalError.responseError({
-          request,
-          response,
-          reason: "StatusCode",
-          error: "non 2xx status code"
-        })
+  (self, f) =>
+    setProto((request) =>
+      Effect.filterOrFail(
+        self(request),
+        (response) => f(response.status),
+        (response) =>
+          internalError.responseError({
+            request,
+            response,
+            reason: "StatusCode",
+            error: "non 2xx status code"
+          })
+      )
     )
 )
 
@@ -310,7 +331,7 @@ export const map = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => B
   ) => Client.Client<R, E, B>
->(2, (self, f) => (request) => Effect.map(self(request), f))
+>(2, (self, f) => setProto((request) => Effect.map(self(request), f)))
 
 /** @internal */
 export const mapEffect = dual<
@@ -321,7 +342,7 @@ export const mapEffect = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R | R2, E | E2, B>
->(2, (self, f) => (request) => Effect.flatMap(self(request), f))
+>(2, (self, f) => setProto((request) => Effect.flatMap(self(request), f)))
 
 /** @internal */
 export const mapRequest = dual<
@@ -332,7 +353,7 @@ export const mapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
   ) => Client.Client<R, E, A>
->(2, (self, f) => (request) => self(f(request)))
+>(2, (self, f) => setProto((request) => self(f(request))))
 
 /** @internal */
 export const mapRequestEffect = dual<
@@ -343,7 +364,7 @@ export const mapRequestEffect = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => (request) => Effect.flatMap(f(request), self))
+>(2, (self, f) => setProto((request) => Effect.flatMap(f(request), self)))
 
 /** @internal */
 export const retry: {
@@ -359,8 +380,7 @@ export const retry: {
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
     policy: Schedule.Schedule<R1, E0, B>
-  ): Client.Client<R | R1, E, A> =>
-  (request) => Effect.retry(self(request), policy)
+  ): Client.Client<R | R1, E, A> => setProto((request) => Effect.retry(self(request), policy))
 )
 
 /** @internal */
@@ -394,7 +414,7 @@ export const schemaFunction = dual<
       (body) =>
         self(internalRequest.setBody(
           request,
-          internalBody.bytes(body, "application/json")
+          internalBody.uint8Array(body, "application/json")
         ))
     )
 })
@@ -408,7 +428,7 @@ export const tap = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => (request) => Effect.tap(self(request), f))
+>(2, (self, f) => setProto((request) => Effect.tap(self(request), f)))
 
 /** @internal */
 export const tapRequest = dual<
@@ -419,4 +439,4 @@ export const tapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => (request) => Effect.zipRight(f(request), self(request)))
+>(2, (self, f) => setProto((request) => Effect.zipRight(f(request), self(request))))

package/src/internal/http/clientRequest.ts

@@ -1,5 +1,8 @@
 import { dual } from "@effect/data/Function"
 import { pipeArguments } from "@effect/data/Pipeable"
+import * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
@@ -7,6 +10,7 @@ import * as Headers from "@effect/platform/Http/Headers"
 import type { Method } from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
+import * as internalError from "@effect/platform/internal/http/clientError"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 
@@ -14,14 +18,16 @@ import type * as Stream from "@effect/stream/Stream"
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/Http/ClientRequest") as ClientRequest.TypeId
 
 class ClientRequestImpl implements ClientRequest.ClientRequest {
-  readonly [TypeId]: ClientRequest.TypeId = TypeId
+  readonly [TypeId]: ClientRequest.TypeId
   constructor(
     readonly method: Method,
     readonly url: string,
     readonly urlParams: UrlParams.UrlParams,
     readonly headers: Headers.Headers,
     readonly body: Body.Body
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
   pipe() {
     return pipeArguments(this, arguments)
   }
@@ -293,12 +299,26 @@ export const setBody = dual<
 })
 
 /** @internal */
-export const binaryBody = dual<
+export const uint8ArrayBody = dual<
   (body: Uint8Array, contentType?: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
   (self: ClientRequest.ClientRequest, body: Uint8Array, contentType?: string) => ClientRequest.ClientRequest
 >(
   (args) => isClientRequest(args[0]),
-  (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.bytes(body, contentType))
+  (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.uint8Array(body, contentType))
+)
+
+/** @internal */
+export const effectBody = dual<
+  (
+    body: Effect.Effect<never, unknown, Body.NonEffect>
+  ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (
+    self: ClientRequest.ClientRequest,
+    body: Effect.Effect<never, unknown, Body.NonEffect>
+  ) => ClientRequest.ClientRequest
+>(
+  2,
+  (self, body) => setBody(self, internalBody.effect(body))
 )
 
 /** @internal */
@@ -316,6 +336,30 @@ export const jsonBody = dual<
   (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
 >(2, (self, body) => setBody(self, internalBody.json(body)))
 
+/** @internal */
+export const unsafeJsonBody = dual<
+  (body: unknown) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
+>(2, (self, body) => setBody(self, internalBody.unsafeJson(body)))
+
+/** @internal */
+export const fileBody = dual<
+  (
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ) => (
+    self: ClientRequest.ClientRequest
+  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>,
+  (
+    self: ClientRequest.ClientRequest,
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>
+>(
+  (args) => isClientRequest(args[0]),
+  (self, path, options) => Effect.map(internalBody.file(path, options), (body) => setBody(self, body))
+)
+
 /** @internal */
 export const schemaBody = <I, A>(schema: Schema.Schema<I, A>): {
   (body: A): (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
@@ -369,3 +413,19 @@ export const streamBody = dual<
   (self, body, { contentLength, contentType = "application/octet-stream" } = {}) =>
     setBody(self, internalBody.stream(body, contentType, contentLength))
 )
+
+/** @internal */
+export const resolveBody = (
+  self: ClientRequest.ClientRequest
+): Effect.Effect<never, Error.RequestError, ClientRequest.ClientRequest.NonEffectBody> =>
+  self.body._tag === "Effect"
+    ? Effect.map(
+      Effect.mapError(self.body.effect, (error) =>
+        internalError.requestError({
+          reason: "Encode",
+          request: self,
+          error
+        })),
+      (body) => setBody(self, body) as ClientRequest.ClientRequest.NonEffectBody
+    )
+    : Effect.succeed(self as ClientRequest.ClientRequest.NonEffectBody)

package/src/internal/http/clientResponse.ts

@@ -2,9 +2,9 @@ import * as Effect from "@effect/io/Effect"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
-import type * as FormData from "@effect/platform/Http/FormData"
 import * as Headers from "@effect/platform/Http/Headers"
 import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalError from "@effect/platform/internal/http/clientError"
 import * as Stream from "@effect/stream/Stream"
 
@@ -18,13 +18,16 @@ export const fromWeb = (
 ): ClientResponse.ClientResponse => new ClientResponseImpl(request, source)
 
 class ClientResponseImpl implements ClientResponse.ClientResponse {
-  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId = IncomingMessage.TypeId
-  readonly [TypeId]: ClientResponse.TypeId = TypeId
+  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
+  readonly [TypeId]: ClientResponse.TypeId
 
   constructor(
     private readonly request: ClientRequest.ClientRequest,
     private readonly source: globalThis.Response
-  ) {}
+  ) {
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
+    this[TypeId] = TypeId
+  }
 
   get status(): number {
     return this.source.status
@@ -77,6 +80,20 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     })
   }
 
+  get urlParams(): Effect.Effect<never, Error.ResponseError, UrlParams.UrlParams> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (_) =>
+          internalError.responseError({
+            request: this.request,
+            response: this,
+            reason: "Decode",
+            error: _
+          })
+      }))
+  }
+
   get formData(): Effect.Effect<never, Error.ResponseError, FormData> {
     return Effect.tryPromise({
       try: () => this.source.formData(),
@@ -90,15 +107,6 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     })
   }
 
-  get formDataStream(): Stream.Stream<never, Error.ResponseError, FormData.Part> {
-    return Stream.fail(internalError.responseError({
-      request: this.request,
-      response: this,
-      reason: "Decode",
-      error: "not implemented"
-    }))
-  }
-
   get arrayBuffer(): Effect.Effect<never, Error.ResponseError, ArrayBuffer> {
     return Effect.tryPromise({
       try: () => this.source.arrayBuffer(),

package/src/internal/http/formData.ts

@@ -0,0 +1,140 @@
+import * as Chunk from "@effect/data/Chunk"
+import * as Data from "@effect/data/Data"
+import { dual, pipe } from "@effect/data/Function"
+import { globalValue } from "@effect/data/Global"
+import * as Option from "@effect/data/Option"
+import * as Predicate from "@effect/data/Predicate"
+import * as ReadonlyArray from "@effect/data/ReadonlyArray"
+import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as FileSystem from "@effect/platform/FileSystem"
+import type * as FormData from "@effect/platform/Http/FormData"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
+
+/** @internal */
+export const TypeId: FormData.TypeId = Symbol.for("@effect/platform/Http/FormData") as FormData.TypeId
+
+/** @internal */
+export const ErrorTypeId: FormData.ErrorTypeId = Symbol.for(
+  "@effect/platform/Http/FormData/FormDataError"
+) as FormData.ErrorTypeId
+
+/** @internal */
+export const FormDataError = (reason: FormData.FormDataError["reason"], error: unknown): FormData.FormDataError =>
+  Data.struct({
+    [ErrorTypeId]: ErrorTypeId,
+    _tag: "FormDataError",
+    reason,
+    error
+  })
+
+/** @internal */
+export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
+  "@effect/platform/Http/FormData/maxFieldSize",
+  () => FiberRef.unsafeMake(FileSystem.Size(1024 * 1024))
+)
+
+/** @internal */
+export const withMaxFieldSize = dual<
+  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: FileSystem.SizeInput) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxFieldSize, FileSystem.Size(size)))
+
+/** @internal */
+export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = globalValue(
+  "@effect/platform/Http/FormData/maxFileSize",
+  () => FiberRef.unsafeMake(Option.none<FileSystem.Size>())
+)
+
+/** @internal */
+export const withMaxFileSize = dual<
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, FileSystem.Size)))
+
+/** @internal */
+export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValue(
+  "@effect/platform/Http/FormData/fieldMimeTypes",
+  () => FiberRef.unsafeMake(Chunk.make("application/json"))
+)
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withFieldMimeTypes = dual<
+  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<R, E, A>
+>(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
+
+/** @internal */
+export const toRecord = (formData: globalThis.FormData): Record<string, Array<globalThis.File> | string> =>
+  ReadonlyArray.reduce(
+    formData.entries(),
+    {} as Record<string, Array<globalThis.File> | string>,
+    (acc, [key, value]) => {
+      if (Predicate.isString(value)) {
+        acc[key] = value
+      } else {
+        const existing = acc[key]
+        if (Array.isArray(existing)) {
+          existing.push(value)
+        } else {
+          acc[key] = [value]
+        }
+      }
+      return acc
+    }
+  )
+/** @internal */
+export const filesSchema: Schema.Schema<ReadonlyArray<File>, ReadonlyArray<File>> = Schema.array(
+  pipe(
+    Schema.instanceOf(Blob),
+    Schema.filter(
+      (blob): blob is File => "name" in blob
+    )
+  ) as any as Schema.Schema<File, File>
+)
+
+/** @internal */
+export const schemaRecord = <I extends Readonly<Record<string, string | ReadonlyArray<globalThis.File>>>, A>(
+  schema: Schema.Schema<I, A>
+) => {
+  const parse = Schema.parse(schema)
+  return (formData: globalThis.FormData) => parse(toRecord(formData))
+}
+
+/** @internal */
+export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+  (
+    field: string
+  ): (formData: globalThis.FormData) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  (
+    formData: globalThis.FormData,
+    field: string
+  ): Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+} => {
+  const parse = Schema.parse(schema)
+  return dual<
+    (
+      field: string
+    ) => (formData: globalThis.FormData) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>,
+    (
+      formData: globalThis.FormData,
+      field: string
+    ) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  >(2, (formData, field) =>
+    pipe(
+      Effect.succeed(formData.get(field)),
+      Effect.filterOrFail(
+        (field) => Predicate.isString(field),
+        () => FormDataError("Parse", `schemaJson: field was not a string`)
+      ),
+      Effect.tryMap({
+        try: (field) => JSON.parse(field as string),
+        catch: (error) => FormDataError("Parse", `schemaJson: field was not valid json: ${error}`)
+      }),
+      Effect.flatMap(parse)
+    ))
+}