@effect/platform 0.48.8 → 0.48.10

package/src/internal/http/body.ts

@@ -2,6 +2,7 @@ import * as Schema from "@effect/schema/Schema"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import { identity } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
 import * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import * as FileSystem from "../../FileSystem.js"
@@ -24,26 +25,51 @@ const bodyError = Data.tagged<Body.BodyError>("BodyError")
 export const BodyError = (reason: Body.BodyErrorReason): Body.BodyError =>
   bodyError({ [ErrorTypeId]: ErrorTypeId, reason })
 
-class EmptyImpl implements Body.Empty {
+abstract class BodyBase implements Body.Body.Proto {
   readonly [TypeId]: Body.TypeId
-  readonly _tag = "Empty"
+  abstract readonly _tag: string
   constructor() {
     this[TypeId] = TypeId
   }
+  abstract toJSON(): unknown
+  [Inspectable.NodeInspectSymbol](): unknown {
+    return this.toJSON()
+  }
+  toString(): string {
+    return Inspectable.format(this)
+  }
+}
+
+class EmptyImpl extends BodyBase implements Body.Empty {
+  readonly _tag = "Empty"
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Body",
+      _tag: "Empty"
+    }
+  }
 }
 
 /** @internal */
 export const empty: Body.Empty = new EmptyImpl()
 
-class RawImpl implements Body.Raw {
-  readonly [TypeId]: Body.TypeId
+class RawImpl extends BodyBase implements Body.Raw {
   readonly _tag = "Raw"
   constructor(
     readonly body: unknown,
     readonly contentType?: string | undefined,
     readonly contentLength?: number | undefined
   ) {
-    this[TypeId] = TypeId
+    super()
+  }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Body",
+      _tag: "Raw",
+      body: this.body,
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    }
   }
 }
 
@@ -53,18 +79,27 @@ export const raw = (body: unknown, options?: {
   readonly contentLength?: number | undefined
 }): Body.Raw => new RawImpl(body, options?.contentType, options?.contentLength)
 
-class Uint8ArrayImpl implements Body.Uint8Array {
-  readonly [TypeId]: Body.TypeId
+class Uint8ArrayImpl extends BodyBase implements Body.Uint8Array {
   readonly _tag = "Uint8Array"
   constructor(
     readonly body: Uint8Array,
     readonly contentType: string
   ) {
-    this[TypeId] = TypeId
+    super()
   }
   get contentLength(): number {
     return this.body.length
   }
+  toJSON(): unknown {
+    const toString = this.contentType.startsWith("text/") || this.contentType.endsWith("json")
+    return {
+      _id: "@effect/platform/Http/Body",
+      _tag: "Uint8Array",
+      body: toString ? new TextDecoder().decode(this.body) : `Uint8Array(${this.body.length})`,
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    }
+  }
 }
 
 /** @internal */
@@ -137,28 +172,41 @@ export const fileInfo = (
 export const fileWeb = (file: Body.Body.FileLike): Body.Stream =>
   stream(Stream_.fromReadableStream(() => file.stream() as ReadableStream<Uint8Array>, identity), file.type, file.size)
 
-class FormDataImpl implements Body.FormData {
-  readonly [TypeId]: Body.TypeId
+class FormDataImpl extends BodyBase implements Body.FormData {
   readonly _tag = "FormData"
   constructor(
     readonly formData: FormData
   ) {
-    this[TypeId] = TypeId
+    super()
+  }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Body",
+      _tag: "FormData",
+      formData: this.formData
+    }
   }
 }
 
 /** @internal */
 export const formData = (body: FormData): Body.FormData => new FormDataImpl(body)
 
-class StreamImpl implements Body.Stream {
-  readonly [TypeId]: Body.TypeId
+class StreamImpl extends BodyBase implements Body.Stream {
   readonly _tag = "Stream"
   constructor(
     readonly stream: Stream_.Stream<Uint8Array, unknown>,
     readonly contentType: string,
     readonly contentLength?: number | undefined
   ) {
-    this[TypeId] = TypeId
+    super()
+  }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Body",
+      _tag: "Stream",
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    }
   }
 }
 

package/src/internal/http/clientRequest.ts

@@ -1,6 +1,7 @@
 import type * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
@@ -15,7 +16,7 @@ import * as internalBody from "./body.js"
 /** @internal */
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/Http/ClientRequest") as ClientRequest.TypeId
 
-class ClientRequestImpl implements ClientRequest.ClientRequest {
+class ClientRequestImpl extends Inspectable.Class implements ClientRequest.ClientRequest {
   readonly [TypeId]: ClientRequest.TypeId
   constructor(
     readonly method: Method,
@@ -24,11 +25,22 @@ class ClientRequestImpl implements ClientRequest.ClientRequest {
     readonly headers: Headers.Headers,
     readonly body: Body.Body
   ) {
+    super()
     this[TypeId] = TypeId
   }
   pipe() {
     return pipeArguments(this, arguments)
   }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/ClientRequest",
+      method: this.method,
+      url: this.url,
+      urlParams: this.urlParams,
+      headers: this.headers,
+      body: this.body.toJSON()
+    }
+  }
 }
 
 /** @internal */

package/src/internal/http/clientResponse.ts

@@ -1,6 +1,7 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
+import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
 import * as Error from "../../Http/ClientError.js"
@@ -19,7 +20,7 @@ export const fromWeb = (
   source: globalThis.Response
 ): ClientResponse.ClientResponse => new ClientResponseImpl(request, source)
 
-class ClientResponseImpl implements ClientResponse.ClientResponse {
+class ClientResponseImpl extends Inspectable.Class implements ClientResponse.ClientResponse {
   readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
   readonly [TypeId]: ClientResponse.TypeId
 
@@ -27,10 +28,19 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     private readonly request: ClientRequest.ClientRequest,
     private readonly source: globalThis.Response
   ) {
+    super()
     this[IncomingMessage.TypeId] = IncomingMessage.TypeId
     this[TypeId] = TypeId
   }
 
+  toJSON(): unknown {
+    return IncomingMessage.inspect(this, {
+      _id: "@effect/platform/Http/ClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    })
+  }
+
   get status(): number {
     return this.source.status
   }

package/src/internal/http/multipart.ts

@@ -3,11 +3,11 @@ import * as Schema from "@effect/schema/Schema"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
-import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { dual, flow, pipe } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
@@ -15,6 +15,7 @@ import type * as Scope from "effect/Scope"
 import type * as AsyncInput from "effect/SingleProducerAsyncInput"
 import * as Stream from "effect/Stream"
 import * as MP from "multipasta"
+import { RefailError } from "../../Error.js"
 import * as FileSystem from "../../FileSystem.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import type * as Multipart from "../../Http/Multipart.js"
@@ -42,13 +43,13 @@ export const ErrorTypeId: Multipart.ErrorTypeId = Symbol.for(
 ) as Multipart.ErrorTypeId
 
 /** @internal */
-export const MultipartError = (reason: Multipart.MultipartError["reason"], error: unknown): Multipart.MultipartError =>
-  Data.struct({
-    [ErrorTypeId]: ErrorTypeId,
-    _tag: "MultipartError",
-    reason,
-    error
-  })
+export class MultipartError extends RefailError(ErrorTypeId, "MultipartError")<{
+  readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
+}> {
+  get message() {
+    return `${this.reason}: ${super.message}`
+  }
+}
 
 /** @internal */
 export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
@@ -310,27 +311,34 @@ function convertError(error: MP.MultipartError): Multipart.MultipartError {
     case "ReachedLimit": {
       switch (error.limit) {
         case "MaxParts": {
-          return MultipartError("TooManyParts", error)
+          return new MultipartError({ reason: "TooManyParts", error })
         }
         case "MaxFieldSize": {
-          return MultipartError("FieldTooLarge", error)
+          return new MultipartError({ reason: "FieldTooLarge", error })
         }
         case "MaxPartSize": {
-          return MultipartError("FileTooLarge", error)
+          return new MultipartError({ reason: "FileTooLarge", error })
         }
         case "MaxTotalSize": {
-          return MultipartError("BodyTooLarge", error)
+          return new MultipartError({ reason: "BodyTooLarge", error })
         }
       }
     }
     default: {
-      return MultipartError("Parse", error)
+      return new MultipartError({ reason: "Parse", error })
     }
   }
 }
 
-class FieldImpl implements Multipart.Field {
+abstract class PartBase extends Inspectable.Class {
   readonly [TypeId]: Multipart.TypeId
+  constructor() {
+    super()
+    this[TypeId] = TypeId
+  }
+}
+
+class FieldImpl extends PartBase implements Multipart.Field {
   readonly _tag = "Field"
 
   constructor(
@@ -338,13 +346,22 @@ class FieldImpl implements Multipart.Field {
     readonly contentType: string,
     readonly value: string
   ) {
-    this[TypeId] = TypeId
+    super()
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      contentType: this.contentType,
+      value: this.value
+    }
   }
 }
 
-class FileImpl implements Multipart.File {
+class FileImpl extends PartBase implements Multipart.File {
   readonly _tag = "File"
-  readonly [TypeId]: Multipart.TypeId
   readonly key: string
   readonly name: string
   readonly contentType: string
@@ -354,12 +371,22 @@ class FileImpl implements Multipart.File {
     info: MP.PartInfo,
     channel: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, never, unknown, void, unknown>
   ) {
-    this[TypeId] = TypeId
+    super()
     this.key = info.name
     this.name = info.filename ?? info.name
     this.contentType = info.contentType
     this.content = Stream.fromChannel(channel)
   }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    }
+  }
 }
 
 const defaultWriteFile = (path: string, file: Multipart.File) =>
@@ -368,7 +395,7 @@ const defaultWriteFile = (path: string, file: Multipart.File) =>
     (fs) =>
       Effect.mapError(
         Stream.run(file.content, fs.sink(path)),
-        (error) => MultipartError("InternalError", error)
+        (error) => new MultipartError({ reason: "InternalError", error })
       )
   )
 
@@ -409,13 +436,12 @@ export const toPersisted = (
       )
     ),
     Effect.catchTags({
-      SystemError: (err) => Effect.fail(MultipartError("InternalError", err)),
-      BadArgument: (err) => Effect.fail(MultipartError("InternalError", err))
+      SystemError: (error) => Effect.fail(new MultipartError({ reason: "InternalError", error })),
+      BadArgument: (error) => Effect.fail(new MultipartError({ reason: "InternalError", error }))
     })
   )
 
-class PersistedFileImpl implements Multipart.PersistedFile {
-  readonly [TypeId]: Multipart.TypeId
+class PersistedFileImpl extends PartBase implements Multipart.PersistedFile {
   readonly _tag = "PersistedFile"
 
   constructor(
@@ -424,6 +450,17 @@ class PersistedFileImpl implements Multipart.PersistedFile {
     readonly contentType: string,
     readonly path: string
   ) {
-    this[TypeId] = TypeId
+    super()
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Multipart/Part",
+      _tag: "PersistedFile",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType,
+      path: this.path
+    }
   }
 }

package/src/internal/http/multiplex.ts

@@ -1,6 +1,7 @@
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import type * as App from "../../Http/App.js"
 import type * as Multiplex from "../../Http/Multiplex.js"
@@ -49,6 +50,18 @@ class MultiplexImpl<R, E>
   commit() {
     return this.execute
   }
+
+  [Inspectable.NodeInspectSymbol]() {
+    return Inspectable.toJSON(this)
+  }
+  toString(): string {
+    return Inspectable.format(this)
+  }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Multiplex"
+    }
+  }
 }
 
 /** @internal */

package/src/internal/http/router.ts

@@ -179,7 +179,7 @@ function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
   return request.modify({ url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen) })
 }
 
-class RouteImpl<R, E> implements Router.Route<R, E> {
+class RouteImpl<R, E> extends Inspectable.Class implements Router.Route<R, E> {
   readonly [RouteTypeId]: Router.RouteTypeId
   constructor(
     readonly method: Method.Method | "*",
@@ -187,8 +187,17 @@ class RouteImpl<R, E> implements Router.Route<R, E> {
     readonly handler: Router.Route.Handler<R, E>,
     readonly prefix = Option.none<string>()
   ) {
+    super()
     this[RouteTypeId] = RouteTypeId
   }
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Http/Router/Route",
+      method: this.method,
+      path: this.path,
+      prefix: this.prefix.toJSON()
+    }
+  }
 }
 
 class RouteContextImpl implements Router.RouteContext {

package/src/internal/http/serverRequest.ts

@@ -3,6 +3,7 @@ import type * as Schema from "@effect/schema/Schema"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -115,7 +116,7 @@ export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
 export const fromWeb = (request: globalThis.Request): ServerRequest.ServerRequest =>
   new ServerRequestImpl(request, request.url)
 
-class ServerRequestImpl implements ServerRequest.ServerRequest {
+class ServerRequestImpl extends Inspectable.Class implements ServerRequest.ServerRequest {
   readonly [TypeId]: ServerRequest.TypeId
   readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
   constructor(
@@ -124,9 +125,17 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     public headersOverride?: Headers.Headers,
     private remoteAddressOverride?: string
   ) {
+    super()
     this[TypeId] = TypeId
     this[IncomingMessage.TypeId] = IncomingMessage.TypeId
   }
+  toJSON(): unknown {
+    return IncomingMessage.inspect(this, {
+      _id: "@effect/platform/Http/ServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    })
+  }
   modify(
     options: {
       readonly url?: string | undefined
@@ -239,7 +248,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
 
   get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
     return Stream.pipeThroughChannel(
-      Stream.mapError(this.stream, (error) => Multipart.MultipartError("InternalError", error)),
+      Stream.mapError(this.stream, (error) => new Multipart.MultipartError({ reason: "InternalError", error })),
       Multipart.makeChannel(this.headers)
     )
   }

package/src/internal/http/serverResponse.ts

@@ -2,6 +2,7 @@ import type * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
 import * as Stream from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import type * as FileSystem from "../../FileSystem.js"
@@ -47,13 +48,21 @@ class ServerResponseImpl extends Effectable.StructuralClass<ServerResponse.Serve
     return Effect.succeed(this)
   }
 
+  [Inspectable.NodeInspectSymbol]() {
+    return this.toJSON()
+  }
+
+  toString(): string {
+    return Inspectable.format(this)
+  }
+
   toJSON() {
     return {
-      _id: "ServerResponse",
+      _id: "@effect/platform/Http/ServerResponse",
       status: this.status,
       statusText: this.statusText,
       headers: this.headers,
-      body: this.body
+      body: this.body.toJSON()
     }
   }
 }

package/src/internal/path.ts

@@ -4,15 +4,19 @@ import { identity } from "effect/Function"
 import * as Layer from "effect/Layer"
 import PathB from "path-browserify"
 import { BadArgument } from "../Error.js"
-import type { Path as _Path } from "../Path.js"
+import type * as Api from "../Path.js"
 
 /** @internal */
-export const Path = GenericTag<_Path>("@effect/platform/Path")
+export const TypeId: Api.TypeId = Symbol.for("@effect/platform/Path") as Api.TypeId
+
+/** @internal */
+export const Path = GenericTag<Api.Path>("@effect/platform/Path")
 
 /** @internal */
 export const layer = Layer.succeed(
   Path,
   Path.of({
+    [TypeId]: TypeId,
     ...PathB,
     fromFileUrl,
     toFileUrl,