@effect/platform 0.48.9 → 0.48.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform",
-  "version": "0.48.9",
+  "version": "0.48.11",
   "description": "Unified interfaces for common platform-specific services",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
     "path-browserify": "^1.0.1"
   },
   "peerDependencies": {
-    "@effect/schema": "^0.64.6",
-    "effect": "^2.4.8"
+    "effect": "^2.4.9",
+    "@effect/schema": "^0.64.7"
   },
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",

package/src/Command.ts

@@ -3,6 +3,7 @@
  */
 import type { Effect } from "effect/Effect"
 import type { HashMap } from "effect/HashMap"
+import type { Inspectable } from "effect/Inspectable"
 import type { Option } from "effect/Option"
 import type { Pipeable } from "effect/Pipeable"
 import type { NonEmptyReadonlyArray } from "effect/ReadonlyArray"
@@ -37,8 +38,9 @@ export declare namespace Command {
    * @since 1.0.0
    * @category models
    */
-  export interface Proto {
+  export interface Proto extends Pipeable, Inspectable {
     readonly [CommandTypeId]: CommandTypeId
+    readonly _tag: string
   }
   /**
    * Configures the pipe that is established between the parent and child
@@ -80,7 +82,7 @@ export type CommandOutput = "inherit" | "pipe" | Sink<Uint8Array, Uint8Array>
  * @since 1.0.0
  * @category models
  */
-export interface StandardCommand extends Command.Proto, Pipeable {
+export interface StandardCommand extends Command.Proto {
   readonly _tag: "StandardCommand"
   readonly command: string
   readonly args: ReadonlyArray<string>
@@ -98,7 +100,7 @@ export interface StandardCommand extends Command.Proto, Pipeable {
  * @since 1.0.0
  * @category models
  */
-export interface PipedCommand extends Command.Proto, Pipeable {
+export interface PipedCommand extends Command.Proto {
   readonly _tag: "PipedCommand"
   readonly left: Command
   readonly right: Command

package/src/CommandExecutor.ts

@@ -4,6 +4,7 @@
 import type * as Brand from "effect/Brand"
 import type { Tag } from "effect/Context"
 import type { Effect } from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import type { Scope } from "effect/Scope"
 import type { Sink } from "effect/Sink"
 import type { Stream } from "effect/Stream"
@@ -11,11 +12,25 @@ import type { Command } from "./Command.js"
 import type { PlatformError } from "./Error.js"
 import * as internal from "./internal/commandExecutor.js"
 
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
 /**
  * @since 1.0.0
  * @category models
  */
 export interface CommandExecutor {
+  readonly [TypeId]: TypeId
+
   /**
    * Returns the exit code of the command after the process has completed
    * execution.
@@ -70,7 +85,7 @@ export type ProcessTypeId = typeof ProcessTypeId
  * @since 1.0.0
  * @category models
  */
-export interface Process {
+export interface Process extends Inspectable {
   readonly [ProcessTypeId]: ProcessTypeId
   /**
    * The process identifier.

package/src/Error.ts

@@ -74,7 +74,11 @@ export const RefailError = <const TypeId extends symbol, const Tag extends strin
       }
     }
     get message() {
-      return String(Predicate.hasProperty(this.error, "message") ? this.error.message : this.error)
+      return Predicate.hasProperty(this.error, "message")
+        ? this.error.message as string
+        : Predicate.hasProperty(this.error, "toJSON") && typeof this.error.toJSON === "function"
+        ? JSON.stringify(this.error.toJSON())
+        : String(this.error)
     }
   }
   ;(Base.prototype as any)[typeId] = typeId

package/src/FileSystem.ts

@@ -231,7 +231,7 @@ export interface FileSystem {
     mtime: Date | number
   ) => Effect.Effect<void, PlatformError>
   /**
-   * Watch a directory for changes
+   * Watch a directory or file for changes
    */
   readonly watch: (path: string) => Stream<WatchEvent, PlatformError>
   /**

package/src/Http/Body.ts

@@ -4,6 +4,7 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import * as Predicate from "effect/Predicate"
 import type * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../Error.js"
@@ -43,7 +44,7 @@ export declare namespace Body {
    * @since 1.0.0
    * @category models
    */
-  export interface Proto {
+  export interface Proto extends Inspectable {
     readonly [TypeId]: TypeId
     readonly _tag: string
     readonly contentType?: string | undefined

package/src/Http/Client.ts

@@ -5,6 +5,7 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import type * as Layer from "effect/Layer"
 import type { Pipeable } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
@@ -31,7 +32,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Client<R, E, A> extends Pipeable {
+export interface Client<R, E, A> extends Pipeable, Inspectable {
   (request: ClientRequest.ClientRequest): Effect.Effect<A, E, R>
   readonly [TypeId]: TypeId
   readonly preprocess: Client.Preprocess<R, E>

package/src/Http/ClientRequest.ts

@@ -3,6 +3,7 @@
  */
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import type { Pipeable } from "effect/Pipeable"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
@@ -29,7 +30,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface ClientRequest extends Pipeable {
+export interface ClientRequest extends Pipeable, Inspectable {
   readonly [TypeId]: TypeId
   readonly method: Method
   readonly url: string

package/src/Http/IncomingMessage.ts

@@ -7,6 +7,7 @@ import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { dual, flow } from "effect/Function"
 import * as Global from "effect/GlobalValue"
+import type { Inspectable } from "effect/Inspectable"
 import * as Option from "effect/Option"
 import type * as Stream from "effect/Stream"
 import * as Tracer from "effect/Tracer"
@@ -31,7 +32,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface IncomingMessage<E> {
+export interface IncomingMessage<E> extends Inspectable {
   readonly [TypeId]: TypeId
   readonly headers: Headers.Headers
   readonly remoteAddress: Option.Option<string>
@@ -190,3 +191,33 @@ export const withMaxBodySize = dual<
   (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxBodySize, Option.map(size, FileSystem.Size)))
+
+/**
+ * @since 1.0.0
+ */
+export const inspect = <E>(self: IncomingMessage<E>, that: object): object => {
+  const contentType = self.headers["content-type"] ?? ""
+  let body: unknown
+  if (contentType.includes("application/json")) {
+    try {
+      body = Effect.runSync(self.json)
+    } catch (_) {
+      //
+    }
+  } else if (contentType.includes("text/") || contentType.includes("urlencoded")) {
+    try {
+      body = Effect.runSync(self.text)
+    } catch (_) {
+      //
+    }
+  }
+  const obj: any = {
+    ...that,
+    headers: self.headers,
+    remoteAddress: self.remoteAddress.toJSON()
+  }
+  if (body !== undefined) {
+    obj.body = body
+  }
+  return obj
+}

package/src/Http/Multipart.ts

@@ -3,10 +3,12 @@
  */
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
+import type { YieldableError } from "effect/Cause"
 import type * as Channel from "effect/Channel"
 import type * as Chunk from "effect/Chunk"
 import type * as Effect from "effect/Effect"
 import type * as FiberRef from "effect/FiberRef"
+import type { Inspectable } from "effect/Inspectable"
 import type * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
@@ -47,7 +49,7 @@ export declare namespace Part {
    * @since 1.0.0
    * @category models
    */
-  export interface Proto {
+  export interface Proto extends Inspectable {
     readonly [TypeId]: TypeId
     readonly _tag: string
   }
@@ -130,7 +132,7 @@ export type ErrorTypeId = typeof ErrorTypeId
  * @since 1.0.0
  * @category errors
  */
-export interface MultipartError {
+export interface MultipartError extends YieldableError {
   readonly [ErrorTypeId]: ErrorTypeId
   readonly _tag: "MultipartError"
   readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
@@ -141,9 +143,11 @@ export interface MultipartError {
  * @since 1.0.0
  * @category errors
  */
-export const MultipartError: (
-  reason: MultipartError["reason"],
-  error: unknown
+export const MultipartError: new(
+  options: {
+    readonly reason: MultipartError["reason"]
+    readonly error: unknown
+  }
 ) => MultipartError = internal.MultipartError
 
 /**

package/src/Http/Multiplex.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import * as internal from "../internal/http/multiplex.js"
 import type * as App from "./App.js"
 import type * as Error from "./ServerError.js"
@@ -23,7 +24,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound> {
+export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound>, Inspectable {
   readonly [TypeId]: TypeId
   readonly apps: ReadonlyArray<
     readonly [

package/src/Http/Router.ts

@@ -7,6 +7,7 @@ import type * as Cause from "effect/Cause"
 import type * as Chunk from "effect/Chunk"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import type * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import * as internal from "../internal/http/router.js"
@@ -32,7 +33,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Router<R, E> extends App.Default<Exclude<R, RouteContext>, E | Error.RouteNotFound> {
+export interface Router<R, E> extends App.Default<Exclude<R, RouteContext>, E | Error.RouteNotFound>, Inspectable {
   readonly [TypeId]: TypeId
   readonly routes: Chunk.Chunk<Route<R, E>>
   readonly mounts: Chunk.Chunk<
@@ -76,7 +77,7 @@ export type PathInput = `/${string}` | "*"
  * @since 1.0.0
  * @category models
  */
-export interface Route<R, E> {
+export interface Route<R, E> extends Inspectable {
   readonly [RouteTypeId]: RouteTypeId
   readonly method: Method.Method | "*"
   readonly path: PathInput

package/src/Http/ServerResponse.ts

@@ -3,6 +3,7 @@
  */
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import type { Inspectable } from "effect/Inspectable"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
@@ -29,7 +30,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface ServerResponse extends Effect.Effect<ServerResponse> {
+export interface ServerResponse extends Effect.Effect<ServerResponse>, Inspectable {
   readonly [TypeId]: TypeId
   readonly status: number
   readonly statusText?: string | undefined

package/src/Path.ts

@@ -8,11 +8,24 @@ import type { Layer } from "effect/Layer"
 import type { BadArgument } from "./Error.js"
 import * as internal from "./internal/path.js"
 
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
 /**
  * @since 1.0.0
  * @category model
  */
 export interface Path {
+  readonly [TypeId]: TypeId
   readonly sep: string
   readonly basename: (path: string, suffix?: string) => string
   readonly dirname: (path: string) => string

package/src/WorkerError.ts

@@ -78,7 +78,8 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
    * @since 1.0.0
    */
   get message() {
-    return `${this.reason}: ${String(this.error)}`
+    const message = this.error instanceof Error ? this.error.message : String(this.error)
+    return `${this.reason}: ${message}`
   }
 }
 

package/src/internal/command.ts

@@ -2,6 +2,7 @@ import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as HashMap from "effect/HashMap"
+import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
 import type * as ReadonlyArray from "effect/ReadonlyArray"
@@ -28,7 +29,7 @@ export const env: {
 >(2, (self, environment) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, env: HashMap.union(self.env, HashMap.fromIterable(Object.entries(environment))) }
+      return makeStandard({ ...self, env: HashMap.union(self.env, HashMap.fromIterable(Object.entries(environment))) })
     }
     case "PipedCommand": {
       return pipeTo(env(self.left, environment), env(self.right, environment))
@@ -76,7 +77,7 @@ export const runInShell = dual<
 >(2, (self: Command.Command, shell: boolean | string): Command.Command => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, shell }
+      return makeStandard({ ...self, shell })
     }
     case "PipedCommand": {
       return pipeTo(
@@ -94,40 +95,77 @@ export const lines = (
 ): Effect.Effect<ReadonlyArray<string>, PlatformError, CommandExecutor.CommandExecutor> =>
   Effect.flatMap(commandExecutor.CommandExecutor, (executor) => executor.lines(command, encoding))
 
-/** @internal */
-export const make = (command: string, ...args: Array<string>): Command.Command => ({
+const Proto = {
   [CommandTypeId]: CommandTypeId,
-  _tag: "StandardCommand",
-  command,
-  args,
-  env: HashMap.empty(),
-  cwd: Option.none(),
-  shell: false,
-  // The initial process input here does not matter, we just want the child
-  // process to default to `"pipe"` for the stdin stream.
-  stdin: Option.some(Stream.empty),
-  stdout: "pipe",
-  stderr: "pipe",
-  gid: Option.none(),
-  uid: Option.none(),
   pipe() {
     return pipeArguments(this, arguments)
+  },
+  ...Inspectable.BaseProto
+}
+
+const StandardProto = {
+  ...Proto,
+  _tag: "StandardCommand",
+  toJSON(this: Command.StandardCommand) {
+    return {
+      _id: "@effect/platform/Command",
+      _tag: this._tag,
+      command: this.command,
+      args: this.args,
+      env: Object.fromEntries(this.env),
+      cwd: this.cwd.toJSON(),
+      shell: this.shell,
+      gid: this.gid.toJSON(),
+      uid: this.uid.toJSON()
+    }
   }
-})
+}
+
+const makeStandard = (options: Omit<Command.StandardCommand, keyof Command.Command.Proto>): Command.StandardCommand =>
+  Object.assign(Object.create(StandardProto), options)
+
+const PipedProto = {
+  ...Proto,
+  _tag: "PipedCommand",
+  toJSON(this: Command.PipedCommand) {
+    return {
+      _id: "@effect/platform/Command",
+      _tag: this._tag,
+      left: this.left.toJSON(),
+      right: this.right.toJSON()
+    }
+  }
+}
+
+const makePiped = (options: Omit<Command.PipedCommand, keyof Command.Command.Proto>): Command.PipedCommand =>
+  Object.assign(Object.create(PipedProto), options)
+
+/** @internal */
+export const make = (command: string, ...args: Array<string>): Command.Command =>
+  makeStandard({
+    command,
+    args,
+    env: HashMap.empty(),
+    cwd: Option.none(),
+    shell: false,
+    // The initial process input here does not matter, we just want the child
+    // process to default to `"pipe"` for the stdin stream.
+    stdin: Option.some(Stream.empty),
+    stdout: "pipe",
+    stderr: "pipe",
+    gid: Option.none(),
+    uid: Option.none()
+  })
 
 /** @internal */
 export const pipeTo = dual<
   (into: Command.Command) => (self: Command.Command) => Command.Command,
   (self: Command.Command, into: Command.Command) => Command.Command
->(2, (self, into) => ({
-  [CommandTypeId]: CommandTypeId,
-  _tag: "PipedCommand",
-  left: self,
-  right: into,
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}))
+>(2, (self, into) =>
+  makePiped({
+    left: self,
+    right: into
+  }))
 
 /** @internal */
 export const stderr: {
@@ -139,12 +177,12 @@ export const stderr: {
 >(2, (self, output) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, stderr: output }
+      return makeStandard({ ...self, stderr: output })
     }
     // For piped commands it only makes sense to provide `stderr` for the
     // right-most command as the rest will be piped in.
     case "PipedCommand": {
-      return { ...self, right: stderr(self.right, output) }
+      return makePiped({ ...self, right: stderr(self.right, output) })
     }
   }
 })
@@ -159,12 +197,12 @@ export const stdin: {
 >(2, (self, input) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, stdin: Option.some(input) }
+      return makeStandard({ ...self, stdin: Option.some(input) })
     }
     // For piped commands it only makes sense to provide `stdin` for the
     // left-most command as the rest will be piped in.
     case "PipedCommand": {
-      return { ...self, left: stdin(self.left, input) }
+      return makePiped({ ...self, left: stdin(self.left, input) })
     }
   }
 })
@@ -179,12 +217,12 @@ export const stdout: {
 >(2, (self, output) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, stdout: output }
+      return makeStandard({ ...self, stdout: output })
     }
     // For piped commands it only makes sense to provide `stderr` for the
     // right-most command as the rest will be piped in.
     case "PipedCommand": {
-      return { ...self, right: stdout(self.right, output) }
+      return makePiped({ ...self, right: stdout(self.right, output) })
     }
   }
 })
@@ -229,7 +267,7 @@ export const workingDirectory: {
 >(2, (self, cwd) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return { ...self, cwd: Option.some(cwd) }
+      return makeStandard({ ...self, cwd: Option.some(cwd) })
     }
     case "PipedCommand": {
       return pipeTo(workingDirectory(self.left, cwd), workingDirectory(self.right, cwd))

package/src/internal/commandExecutor.ts

@@ -7,6 +7,9 @@ import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
 import type * as _CommandExecutor from "../CommandExecutor.js"
 
+/** @internal */
+export const TypeId: _CommandExecutor.TypeId = Symbol.for("@effect/platform/CommandExecutor") as _CommandExecutor.TypeId
+
 /** @internal */
 export const ProcessTypeId: _CommandExecutor.ProcessTypeId = Symbol.for(
   "@effect/platform/Process"
@@ -32,6 +35,7 @@ export const makeExecutor = (start: _CommandExecutor.CommandExecutor["start"]):
     )
   }
   return {
+    [TypeId]: TypeId,
     start,
     exitCode: (command) => Effect.scoped(Effect.flatMap(start(command), (process) => process.exitCode)),
     stream,