@effect/platform 0.37.8 → 0.39.0

package/src/Http/ServerRequest.ts

@@ -10,10 +10,10 @@ import type * as Stream from "effect/Stream"
 import type * as FileSystem from "../FileSystem.js"
 import * as internal from "../internal/http/serverRequest.js"
 import type * as Path from "../Path.js"
-import type * as FormData from "./FormData.js"
 import type * as Headers from "./Headers.js"
 import type * as IncomingMessage from "./IncomingMessage.js"
 import type { Method } from "./Method.js"
+import type * as Multipart from "./Multipart.js"
 import type * as Error from "./ServerError.js"
 
 export {
@@ -47,12 +47,12 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   readonly originalUrl: string
   readonly method: Method
 
-  readonly formData: Effect.Effect<
+  readonly multipart: Effect.Effect<
     Scope.Scope | FileSystem.FileSystem | Path.Path,
-    FormData.FormDataError,
-    FormData.PersistedFormData
+    Multipart.MultipartError,
+    Multipart.Persisted
   >
-  readonly formDataStream: Stream.Stream<never, FormData.FormDataError, FormData.Part>
+  readonly multipartStream: Stream.Stream<never, Multipart.MultipartError, Multipart.Part>
 
   readonly modify: (
     options: {
@@ -73,11 +73,11 @@ export const ServerRequest: Context.Tag<ServerRequest, ServerRequest> = internal
  * @since 1.0.0
  * @category accessors
  */
-export const persistedFormData: Effect.Effect<
+export const persistedMultipart: Effect.Effect<
   Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest,
-  FormData.FormDataError,
+  Multipart.MultipartError,
   unknown
-> = internal.persistedFormData
+> = internal.multipartPersisted
 
 /**
  * @since 1.0.0
@@ -95,6 +95,18 @@ export const schemaBodyJson: <I, A>(
   schema: Schema.Schema<I, A>
 ) => Effect.Effect<ServerRequest, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyJson
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyForm: <I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<
+  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+  Multipart.MultipartError | Error.RequestError | ParseResult.ParseError,
+  A
+> = internal.schemaBodyForm
+
 /**
  * @since 1.0.0
  * @category schema
@@ -107,27 +119,27 @@ export const schemaBodyUrlParams: <I extends Readonly<Record<string, string>>, A
  * @since 1.0.0
  * @category schema
  */
-export const schemaFormData: <I extends FormData.PersistedFormData, A>(
+export const schemaBodyMultipart: <I extends Multipart.Persisted, A>(
   schema: Schema.Schema<I, A>
 ) => Effect.Effect<
   ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
-  FormData.FormDataError | ParseResult.ParseError,
+  Multipart.MultipartError | ParseResult.ParseError,
   A
-> = internal.schemaFormData
+> = internal.schemaBodyMultipart
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaFormDataJson: <I, A>(
+export const schemaBodyFormJson: <I, A>(
   schema: Schema.Schema<I, A>
 ) => (
   field: string
 ) => Effect.Effect<
   ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
-  Error.RequestError | FormData.FormDataError | ParseResult.ParseError,
+  Error.RequestError | ParseResult.ParseError,
   A
-> = internal.schemaFormDataJson
+> = internal.schemaBodyFormJson
 
 /**
  * @since 1.0.0

package/src/Http/UrlParams.ts

@@ -1,8 +1,11 @@
 /**
  * @since 1.0.0
  */
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 
 /**
@@ -34,6 +37,62 @@ export const fromInput = (input: Input): UrlParams => {
  */
 export const empty: UrlParams = []
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getAll: {
+  (key: string): (self: UrlParams) => ReadonlyArray<string>
+  (self: UrlParams, key: string): ReadonlyArray<string>
+} = dual<
+  (key: string) => (self: UrlParams) => ReadonlyArray<string>,
+  (self: UrlParams, key: string) => ReadonlyArray<string>
+>(2, (self, key) =>
+  ReadonlyArray.reduce(self, [] as Array<string>, (acc, [k, value]) => {
+    if (k === key) {
+      acc.push(value)
+    }
+    return acc
+  }))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getFirst: {
+  (key: string): (self: UrlParams) => Option.Option<string>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: UrlParams) => Option.Option<string>,
+  (self: UrlParams, key: string) => Option.Option<string>
+>(2, (self, key) =>
+  Option.map(
+    ReadonlyArray.findFirst(
+      self,
+      ([k]) => k === key
+    ),
+    ([, value]) => value
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getLast: {
+  (key: string): (self: UrlParams) => Option.Option<string>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual<
+  (key: string) => (self: UrlParams) => Option.Option<string>,
+  (self: UrlParams, key: string) => Option.Option<string>
+>(2, (self, key) =>
+  Option.map(
+    ReadonlyArray.findLast(
+      self,
+      ([k]) => k === key
+    ),
+    ([, value]) => value
+  ))
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -143,3 +202,23 @@ const baseUrl = (): string | undefined => {
   }
   return undefined
 }
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+  (
+    field: string
+  ): (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>
+  (
+    self: UrlParams,
+    field: string
+  ): Effect.Effect<never, ParseResult.ParseError, A>
+} => {
+  const parse = Schema.parse(Schema.parseJson(schema))
+  return dual<
+    (field: string) => (self: UrlParams) => Effect.Effect<never, ParseResult.ParseError, A>,
+    (self: UrlParams, field: string) => Effect.Effect<never, ParseResult.ParseError, A>
+  >(2, (self, field) => parse(Option.getOrElse(getLast(self, field), () => "")))
+}

package/src/HttpServer.ts

@@ -3,9 +3,9 @@
  */
 import * as app from "./Http/App.js"
 import * as body from "./Http/Body.js"
-import * as formData from "./Http/FormData.js"
 import * as headers from "./Http/Headers.js"
 import * as middleware from "./Http/Middleware.js"
+import * as multipart from "./Http/Multipart.js"
 import * as router from "./Http/Router.js"
 import * as error from "./Http/ServerError.js"
 import * as request from "./Http/ServerRequest.js"
@@ -34,13 +34,6 @@ export {
    * - Module: `@effect/platform/Http/ServerError`
    */
   error,
-  /**
-   * @since 1.0.0
-   *
-   * - Docs: [Http/FormData](https://effect-ts.github.io/platform/platform/Http/FormData.html)
-   * - Module: `@effect/platform/Http/FormData`
-   */
-  formData,
   /**
    * @since 1.0.0
    *
@@ -55,6 +48,13 @@ export {
    * - Module: `@effect/platform/Http/Middleware`
    */
   middleware,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Multipart](https://effect-ts.github.io/platform/platform/Http/Multipart.html)
+   * - Module: `@effect/platform/Http/Multipart`
+   */
+  multipart,
   /**
    * @since 1.0.0
    *

package/src/internal/http/body.ts

@@ -6,6 +6,7 @@ import * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import * as FileSystem from "../../FileSystem.js"
 import type * as Body from "../../Http/Body.js"
+import * as UrlParams from "../../Http/UrlParams.js"
 
 /** @internal */
 export const TypeId: Body.TypeId = Symbol.for(
@@ -68,13 +69,14 @@ class Uint8ArrayImpl implements Body.Uint8Array {
 export const uint8Array = (body: Uint8Array, contentType?: string): Body.Uint8Array =>
   new Uint8ArrayImpl(body, contentType ?? "application/octet-stream")
 
+const encoder = new TextEncoder()
+
 /** @internal */
 export const text = (body: string, contentType?: string): Body.Uint8Array =>
-  uint8Array(new TextEncoder().encode(body), contentType ?? "text/plain")
+  uint8Array(encoder.encode(body), contentType ?? "text/plain")
 
 /** @internal */
-export const unsafeJson = (body: unknown): Body.Uint8Array =>
-  uint8Array(new TextEncoder().encode(JSON.stringify(body)), "application/json")
+export const unsafeJson = (body: unknown): Body.Uint8Array => text(JSON.stringify(body), "application/json")
 
 /** @internal */
 export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.Uint8Array> =>
@@ -83,6 +85,10 @@ export const json = (body: unknown): Effect.Effect<never, Body.BodyError, Body.U
     catch: (error) => BodyError({ _tag: "JsonError", error })
   })
 
+/** @internal */
+export const urlParams = (urlParams: UrlParams.UrlParams): Body.Uint8Array =>
+  text(UrlParams.toString(urlParams), "application/x-www-form-urlencoded")
+
 /** @internal */
 export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
   const encode = Schema.encode(schema)

package/src/internal/http/client.ts

@@ -4,7 +4,6 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
@@ -53,20 +52,17 @@ export const make = <R, E, A, R2, E2>(
 }
 
 const addB3Headers = (req: ClientRequest.ClientRequest) =>
-  Effect.map(
-    Effect.currentSpan,
-    Option.match({
-      onNone: () => req,
-      onSome: (span) =>
-        internalRequest.setHeader(
-          req,
-          "b3",
-          `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
-            span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
-          }`
-        )
-    })
-  )
+  Effect.match(Effect.currentSpan, {
+    onFailure: () => req,
+    onSuccess: (span) =>
+      internalRequest.setHeader(
+        req,
+        "b3",
+        `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
+          span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
+        }`
+      )
+  })
 
 /** @internal */
 export const makeDefault = (

package/src/internal/http/{formData.ts → multipart.ts}

@@ -16,34 +16,34 @@ import type * as AsyncInput from "effect/SingleProducerAsyncInput"
 import * as Stream from "effect/Stream"
 import * as MP from "multipasta"
 import * as FileSystem from "../../FileSystem.js"
-import type * as FormData from "../../Http/FormData.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
+import type * as Multipart from "../../Http/Multipart.js"
 import * as Path from "../../Path.js"
 
 /** @internal */
-export const TypeId: FormData.TypeId = Symbol.for("@effect/platform/Http/FormData") as FormData.TypeId
+export const TypeId: Multipart.TypeId = Symbol.for("@effect/platform/Http/Multipart") as Multipart.TypeId
 
 /** @internal */
-export const ErrorTypeId: FormData.ErrorTypeId = Symbol.for(
-  "@effect/platform/Http/FormData/FormDataError"
-) as FormData.ErrorTypeId
+export const ErrorTypeId: Multipart.ErrorTypeId = Symbol.for(
+  "@effect/platform/Http/Multipart/MultipartError"
+) as Multipart.ErrorTypeId
 
 /** @internal */
-export const FormDataError = (reason: FormData.FormDataError["reason"], error: unknown): FormData.FormDataError =>
+export const MultipartError = (reason: Multipart.MultipartError["reason"], error: unknown): Multipart.MultipartError =>
   Data.struct({
     [ErrorTypeId]: ErrorTypeId,
-    _tag: "FormDataError",
+    _tag: "MultipartError",
     reason,
     error
   })
 
 /** @internal */
-export const isField = (u: unknown): u is FormData.Field =>
+export const isField = (u: unknown): u is Multipart.Field =>
   Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "Field")
 
 /** @internal */
 export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
-  "@effect/platform/Http/FormData/maxParts",
+  "@effect/platform/Http/Multipart/maxParts",
   () => FiberRef.unsafeMake(Option.none<number>())
 )
 
@@ -55,7 +55,7 @@ export const withMaxParts = dual<
 
 /** @internal */
 export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
-  "@effect/platform/Http/FormData/maxFieldSize",
+  "@effect/platform/Http/Multipart/maxFieldSize",
   () => FiberRef.unsafeMake(FileSystem.Size(10 * 1024 * 1024))
 )
 
@@ -67,7 +67,7 @@ export const withMaxFieldSize = dual<
 
 /** @internal */
 export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = globalValue(
-  "@effect/platform/Http/FormData/maxFileSize",
+  "@effect/platform/Http/Multipart/maxFileSize",
   () => FiberRef.unsafeMake(Option.none<FileSystem.Size>())
 )
 
@@ -79,7 +79,7 @@ export const withMaxFileSize = dual<
 
 /** @internal */
 export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValue(
-  "@effect/platform/Http/FormData/fieldMimeTypes",
+  "@effect/platform/Http/Multipart/fieldMimeTypes",
   () => FiberRef.unsafeMake<Chunk.Chunk<string>>(Chunk.make("application/json"))
 )
 
@@ -89,59 +89,58 @@ export const withFieldMimeTypes = dual<
   <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)))
 
+const fileSchema: Schema.Schema<Multipart.PersistedFile, Multipart.PersistedFile> = Schema.struct({
+  [TypeId]: Schema.uniqueSymbol(TypeId),
+  _tag: Schema.literal("PersistedFile"),
+  key: Schema.string,
+  name: Schema.string,
+  contentType: Schema.string,
+  path: Schema.string
+})
+
 /** @internal */
-export const filesSchema: Schema.Schema<ReadonlyArray<FormData.PersistedFile>, ReadonlyArray<FormData.PersistedFile>> =
-  Schema
-    .array(
-      pipe(
-        Schema.object,
-        Schema.filter(
-          (file): file is FormData.PersistedFile => TypeId in file && "_tag" in file && file._tag === "PersistedFile"
-        )
-      ) as any as Schema.Schema<FormData.PersistedFile, FormData.PersistedFile>
-    )
+export const filesSchema: Schema.Schema<
+  ReadonlyArray<Multipart.PersistedFile>,
+  ReadonlyArray<Multipart.PersistedFile>
+> = Schema.array(fileSchema)
 
 /** @internal */
-export const schemaPersisted = <I extends FormData.PersistedFormData, A>(
+export const schemaPersisted = <I extends Multipart.Persisted, A>(
   schema: Schema.Schema<I, A>
 ) => {
   const parse = Schema.parse(schema)
-  return (formData: FormData.PersistedFormData) => parse(formData)
+  return (persisted: Multipart.Persisted) => parse(persisted)
 }
 
 /** @internal */
 export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
   (
     field: string
-  ): (formData: FormData.PersistedFormData) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  ): (persisted: Multipart.Persisted) => Effect.Effect<never, ParseResult.ParseError, A>
   (
-    formData: FormData.PersistedFormData,
+    persisted: Multipart.Persisted,
     field: string
-  ): Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  ): Effect.Effect<never, ParseResult.ParseError, A>
 } => {
-  const parse = Schema.parse(schema)
+  const fromJson = Schema.parseJson(schema)
   return dual<
     (
       field: string
     ) => (
-      formData: FormData.PersistedFormData
-    ) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>,
+      persisted: Multipart.Persisted
+    ) => Effect.Effect<never, ParseResult.ParseError, A>,
     (
-      formData: FormData.PersistedFormData,
+      persisted: Multipart.Persisted,
       field: string
-    ) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
-  >(2, (formData, field) =>
-    pipe(
-      Effect.succeed(formData[field]),
-      Effect.filterOrFail(
-        isField,
-        () => FormDataError("Parse", `schemaJson: was not a field`)
-      ),
-      Effect.tryMap({
-        try: (field) => JSON.parse(field.value),
-        catch: (error) => FormDataError("Parse", `schemaJson: field was not valid json: ${error}`)
-      }),
-      Effect.flatMap(parse)
+    ) => Effect.Effect<never, ParseResult.ParseError, A>
+  >(2, (persisted, field) =>
+    Effect.map(
+      Schema.parse(
+        Schema.struct({
+          [field]: fromJson
+        })
+      )(persisted),
+      (_) => _[field]
     ))
 }
 
@@ -181,8 +180,8 @@ export const makeChannel = <IE>(
   IE,
   Chunk.Chunk<Uint8Array>,
   unknown,
-  FormData.FormDataError | IE,
-  Chunk.Chunk<FormData.Part>,
+  Multipart.MultipartError | IE,
+  Chunk.Chunk<Multipart.Part>,
   unknown
 > =>
   Channel.acquireUseRelease(
@@ -202,13 +201,13 @@ const makeFromQueue = <IE>(
   IE,
   Chunk.Chunk<Uint8Array>,
   unknown,
-  IE | FormData.FormDataError,
-  Chunk.Chunk<FormData.Part>,
+  IE | Multipart.MultipartError,
+  Chunk.Chunk<Multipart.Part>,
   unknown
 > =>
   Channel.suspend(() => {
-    let error = Option.none<Cause.Cause<IE | FormData.FormDataError>>()
-    let partsBuffer: Array<FormData.Part> = []
+    let error = Option.none<Cause.Cause<IE | Multipart.MultipartError>>()
+    let partsBuffer: Array<Multipart.Part> = []
     let partsFinished = false
 
     const input: AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array>, unknown> = {
@@ -293,8 +292,8 @@ const makeFromQueue = <IE>(
       unknown,
       unknown,
       unknown,
-      IE | FormData.FormDataError,
-      Chunk.Chunk<FormData.Part>,
+      IE | Multipart.MultipartError,
+      Chunk.Chunk<Multipart.Part>,
       void
     > = Channel.suspend(() => {
       if (error._tag === "Some") {
@@ -308,32 +307,32 @@ const makeFromQueue = <IE>(
     return Channel.embedInput(partsChannel, input)
   })
 
-function convertError(error: MP.MultipartError): FormData.FormDataError {
+function convertError(error: MP.MultipartError): Multipart.MultipartError {
   switch (error._tag) {
     case "ReachedLimit": {
       switch (error.limit) {
         case "MaxParts": {
-          return FormDataError("TooManyParts", error)
+          return MultipartError("TooManyParts", error)
         }
         case "MaxFieldSize": {
-          return FormDataError("FieldTooLarge", error)
+          return MultipartError("FieldTooLarge", error)
         }
         case "MaxPartSize": {
-          return FormDataError("FileTooLarge", error)
+          return MultipartError("FileTooLarge", error)
         }
         case "MaxTotalSize": {
-          return FormDataError("BodyTooLarge", error)
+          return MultipartError("BodyTooLarge", error)
         }
       }
     }
     default: {
-      return FormDataError("Parse", error)
+      return MultipartError("Parse", error)
     }
   }
 }
 
-class FieldImpl implements FormData.Field {
-  readonly [TypeId]: FormData.TypeId
+class FieldImpl implements Multipart.Field {
+  readonly [TypeId]: Multipart.TypeId
   readonly _tag = "Field"
 
   constructor(
@@ -345,13 +344,13 @@ class FieldImpl implements FormData.Field {
   }
 }
 
-class FileImpl implements FormData.File {
+class FileImpl implements Multipart.File {
   readonly _tag = "File"
-  readonly [TypeId]: FormData.TypeId
+  readonly [TypeId]: Multipart.TypeId
   readonly key: string
   readonly name: string
   readonly contentType: string
-  readonly content: Stream.Stream<never, FormData.FormDataError, Uint8Array>
+  readonly content: Stream.Stream<never, Multipart.MultipartError, Uint8Array>
 
   constructor(
     info: MP.PartInfo,
@@ -365,21 +364,21 @@ class FileImpl implements FormData.File {
   }
 }
 
-const defaultWriteFile = (path: string, file: FormData.File) =>
+const defaultWriteFile = (path: string, file: Multipart.File) =>
   Effect.flatMap(
     FileSystem.FileSystem,
     (fs) =>
       Effect.mapError(
         Stream.run(file.content, fs.sink(path)),
-        (error) => FormDataError("InternalError", error)
+        (error) => MultipartError("InternalError", error)
       )
   )
 
 /** @internal */
-export const formData = (
-  stream: Stream.Stream<never, FormData.FormDataError, FormData.Part>,
+export const toPersisted = (
+  stream: Stream.Stream<never, Multipart.MultipartError, Multipart.Part>,
   writeFile = defaultWriteFile
-): Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, FormData.FormDataError, FormData.PersistedFormData> =>
+): Effect.Effect<FileSystem.FileSystem | Path.Path | Scope.Scope, Multipart.MultipartError, Multipart.Persisted> =>
   pipe(
     Effect.Do,
     Effect.bind("fs", () => FileSystem.FileSystem),
@@ -388,18 +387,18 @@ export const formData = (
     Effect.flatMap(({ dir, path: path_ }) =>
       Stream.runFoldEffect(
         stream,
-        Object.create(null) as Record<string, Array<FormData.PersistedFile> | string>,
-        (formData, part) => {
+        Object.create(null) as Record<string, Array<Multipart.PersistedFile> | string>,
+        (persisted, part) => {
           if (part._tag === "Field") {
-            formData[part.key] = part.value
-            return Effect.succeed(formData)
+            persisted[part.key] = part.value
+            return Effect.succeed(persisted)
           }
           const file = part
           const path = path_.join(dir, path_.basename(file.name).slice(-128))
-          if (!Array.isArray(formData[part.key])) {
-            formData[part.key] = []
+          if (!Array.isArray(persisted[part.key])) {
+            persisted[part.key] = []
           }
-          ;(formData[part.key] as Array<FormData.PersistedFile>).push(
+          ;(persisted[part.key] as Array<Multipart.PersistedFile>).push(
             new PersistedFileImpl(
               file.key,
               file.name,
@@ -407,18 +406,18 @@ export const formData = (
               path
             )
           )
-          return Effect.as(writeFile(path, file), formData)
+          return Effect.as(writeFile(path, file), persisted)
         }
       )
     ),
     Effect.catchTags({
-      SystemError: (err) => Effect.fail(FormDataError("InternalError", err)),
-      BadArgument: (err) => Effect.fail(FormDataError("InternalError", err))
+      SystemError: (err) => Effect.fail(MultipartError("InternalError", err)),
+      BadArgument: (err) => Effect.fail(MultipartError("InternalError", err))
     })
   )
 
-class PersistedFileImpl implements FormData.PersistedFile {
-  readonly [TypeId]: FormData.TypeId
+class PersistedFileImpl implements Multipart.PersistedFile {
+  readonly [TypeId]: Multipart.TypeId
   readonly _tag = "PersistedFile"
 
   constructor(