replace /platform RefailError with use of the "cause" property (#3260)

.changeset/dry-trains-tease.md

@@ -0,0 +1,20 @@
+---
+"@effect/sql-sqlite-react-native": minor
+"@effect/platform-node-shared": minor
+"@effect/platform-browser": minor
+"@effect/sql-sqlite-node": minor
+"@effect/sql-sqlite-wasm": minor
+"@effect/sql-sqlite-bun": minor
+"@effect/platform-node": minor
+"@effect/experimental": minor
+"@effect/platform-bun": minor
+"@effect/sql-drizzle": minor
+"@effect/sql-mysql2": minor
+"@effect/sql-mssql": minor
+"@effect/platform": minor
+"@effect/sql-d1": minor
+"@effect/sql-pg": minor
+"@effect/sql": minor
+---
+
+replace /platform RefailError with use of the "cause" property

packages/experimental/src/Machine.ts

@@ -137,24 +137,17 @@ export type ActorTypeId = typeof ActorTypeId
  * @category errors
  */
 export class MachineDefect extends Schema.TaggedError<MachineDefect>()("MachineDefect", {
-  cause: Schema.Cause({ error: Schema.Never })
+  cause: Schema.CauseDefectUnknown
 }) {
   /**
    * @since 1.0.0
    */
   static wrap<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, MachineDefect, R> {
     return Effect.catchAllCause(
       Effect.orDie(effect),
-      (cause) => Effect.fail(new MachineDefect({ cause }))
+      (cause) => Effect.fail(new MachineDefect({ cause: Cause.squash(cause) }))
     )
   }
-
-  /**
-   * @since 1.0.0
-   */
-  get message() {
-    return Cause.pretty(this.cause)
-  }
 }
 
 /**
@@ -803,7 +796,7 @@ export const boot = <
             })
           )
         ),
-        Effect.catchAllDefect((defect) => Effect.fail(new MachineDefect({ cause: Cause.die(defect) })))
+        Effect.catchAllDefect((cause) => Effect.fail(new MachineDefect({ cause })))
       )
     }).pipe(Effect.scoped) as Effect.Effect<
       never,

packages/experimental/src/MsgPack.ts

@@ -17,8 +17,12 @@ import { Packr, Unpackr } from "msgpackr"
  */
 export class MsgPackError extends Data.TaggedError("MsgPackError")<{
   readonly reason: "Pack" | "Unpack"
-  readonly error: unknown
-}> {}
+  readonly cause: unknown
+}> {
+  get message() {
+    return this.reason
+  }
+}
 
 /**
  * @since 1.0.0
@@ -42,7 +46,7 @@ export const pack = <IE = never, Done = unknown>(): Channel.Channel<
               Channel.flatMap(
                 Effect.try({
                   try: () => Chunk.of(packr.pack(Chunk.toReadonlyArray(input))),
-                  catch: (error) => new MsgPackError({ reason: "Pack", error })
+                  catch: (cause) => new MsgPackError({ reason: "Pack", cause })
                 }),
                 Channel.write
               ),
@@ -122,7 +126,7 @@ export const unpack = <IE = never, Done = unknown>(): Channel.Channel<
                 throw error
               }
             }),
-          catch: (error) => new MsgPackError({ reason: "Unpack", error })
+          catch: (cause) => new MsgPackError({ reason: "Unpack", cause })
         })
 
       const loop: Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<Uint8Array>, IE | MsgPackError, IE, Done, Done> =

packages/experimental/src/Ndjson.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import { RefailError } from "@effect/platform/Error"
+import { TypeIdError } from "@effect/platform/Error"
 import type { ParseError } from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
@@ -28,9 +28,14 @@ const encoder = new TextEncoder()
  * @since 1.0.0
  * @category errors
  */
-export class NdjsonError extends RefailError(NdjsonErrorTypeId, "NdjsonError")<{
+export class NdjsonError extends TypeIdError(NdjsonErrorTypeId, "NdjsonError")<{
   readonly reason: "Pack" | "Unpack"
-}> {}
+  readonly cause: unknown
+}> {
+  get message() {
+    return this.reason
+  }
+}
 
 /**
  * @since 1.0.0
@@ -62,7 +67,7 @@ export const pack = <IE = never, Done = unknown>(): Channel.Channel<
                   Chunk.toReadonlyArray(input).map((_) => JSON.stringify(_)).join("\n") + "\n"
                 )
               ),
-            catch: (error) => new NdjsonError({ reason: "Pack", error })
+            catch: (cause) => new NdjsonError({ reason: "Pack", cause })
           }),
           Channel.write
         ),
@@ -131,7 +136,7 @@ export const unpack = <IE = never, Done = unknown>(): Channel.Channel<
     return Channel.mapOutEffect(Channel.pipeTo(loop, Channel.splitLines()), (chunk) =>
       Effect.try({
         try: () => Chunk.map(chunk, (_) => JSON.parse(_)),
-        catch: (error) => new NdjsonError({ reason: "Unpack", error })
+        catch: (cause) => new NdjsonError({ reason: "Unpack", cause })
       }))
   })
 

packages/experimental/src/Persistence.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import { RefailError, TypeIdError } from "@effect/platform/Error"
+import { TypeIdError } from "@effect/platform/Error"
 import * as KeyValueStore from "@effect/platform/KeyValueStore"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Serializable from "@effect/schema/Serializable"
@@ -60,19 +60,20 @@ export class PersistenceParseError extends TypeIdError(ErrorTypeId, "Persistence
  * @since 1.0.0
  * @category errors
  */
-export class PersistenceBackingError extends RefailError(ErrorTypeId, "PersistenceError")<{
+export class PersistenceBackingError extends TypeIdError(ErrorTypeId, "PersistenceError")<{
   readonly reason: "BackingError"
   readonly method: string
+  readonly cause: unknown
 }> {
   /**
    * @since 1.0.0
    */
-  static make(method: string, error: unknown) {
-    return new PersistenceBackingError({ reason: "BackingError", method, error })
+  static make(method: string, cause: unknown) {
+    return new PersistenceBackingError({ reason: "BackingError", method, cause })
   }
 
   get message() {
-    return `${this.method}: ${super.message}`
+    return this.reason
   }
 }
 

packages/experimental/test/Machine.test.ts

@@ -165,7 +165,7 @@ describe("Machine", () => {
       assert.strictEqual(yield* _(booted.send(new FailBackground())), undefined)
       const cause = yield* _(booted.join, Effect.sandbox, Effect.flip)
       const failure = Cause.failures(cause).pipe(Chunk.unsafeHead)
-      assert.deepStrictEqual(failure.cause, Cause.die("error"))
+      assert.deepStrictEqual(failure.cause, "error")
     }).pipe(Effect.scoped, Machine.withTracingEnabled(true), Effect.provide(DevTools.layer()), Effect.runPromise))
 
   test("init context", () =>

packages/platform-browser/src/Geolocation.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import { RefailError } from "@effect/platform/Error"
+import { TypeIdError } from "@effect/platform/Error"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
@@ -64,9 +64,14 @@ export type ErrorTypeId = typeof ErrorTypeId
  * @since 1.0.0
  * @category errors
  */
-export class GeolocationError extends RefailError(ErrorTypeId, "GeolocationError")<{
+export class GeolocationError extends TypeIdError(ErrorTypeId, "GeolocationError")<{
   readonly reason: "PositionUnavailable" | "PermissionDenied" | "Timeout"
-}> {}
+  readonly cause: unknown
+}> {
+  get message() {
+    return this.reason
+  }
+}
 
 const makeQueue = (
   options:
@@ -81,11 +86,11 @@ const makeQueue = (
         Effect.sync(() =>
           navigator.geolocation.watchPosition(
             (position) => queue.unsafeOffer(Either.right(position)),
-            (error) => {
-              if (error.code === error.PERMISSION_DENIED) {
-                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "PermissionDenied", error })))
-              } else if (error.code === error.TIMEOUT) {
-                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "Timeout", error })))
+            (cause) => {
+              if (cause.code === cause.PERMISSION_DENIED) {
+                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "PermissionDenied", cause })))
+              } else if (cause.code === cause.TIMEOUT) {
+                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "Timeout", cause })))
               }
             },
             options

packages/platform-browser/src/internal/httpClient.ts

@@ -65,7 +65,7 @@ export const makeXMLHttpRequest = Client.makeDefault((request, url, signal, fibe
             new Error.RequestError({
               request,
               reason: "Transport",
-              error: xhr.statusText
+              cause: xhr.statusText
             })
           ))
         }
@@ -98,12 +98,12 @@ const sendBody = (
           return next
         }),
         {
-          onFailure: (error) =>
+          onFailure: (cause) =>
             Effect.fail(
               new Error.RequestError({
                 request,
                 reason: "Encode",
-                error
+                cause
               })
             ),
           onSuccess: (body) => Effect.sync(() => xhr.send(body))
@@ -286,12 +286,12 @@ class ClientResponseImpl extends IncomingMessageImpl<Error.ResponseError> implem
     readonly request: ClientRequest.HttpClientRequest,
     source: XMLHttpRequest
   ) {
-    super(source, (_) =>
+    super(source, (cause) =>
       new Error.ResponseError({
         request,
         response: this,
         reason: "Decode",
-        error: _
+        cause
       }))
     this[ClientResponse.TypeId] = ClientResponse.TypeId
   }

packages/platform-browser/src/internal/worker.ts

@@ -25,7 +25,7 @@ const platformWorkerImpl = Worker.makePlatform<globalThis.SharedWorker | globalT
     function onError(event: ErrorEvent) {
       Deferred.unsafeDone(
         deferred,
-        new WorkerError({ reason: "unknown", error: event.error ?? event.message })
+        new WorkerError({ reason: "unknown", cause: event.error ?? event.message })
       )
     }
     port.addEventListener("message", onMessage as any)

packages/platform-browser/src/internal/workerRunner.ts

@@ -59,13 +59,13 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
               function onMessageError(error: MessageEvent) {
                 Deferred.unsafeDone(
                   fiberSet.deferred,
-                  new WorkerError({ reason: "decode", error: error.data })
+                  new WorkerError({ reason: "decode", cause: error.data })
                 )
               }
               function onError(error: any) {
                 Deferred.unsafeDone(
                   fiberSet.deferred,
-                  new WorkerError({ reason: "unknown", error: error.data })
+                  new WorkerError({ reason: "unknown", cause: error.data })
                 )
               }
               function handlePort(port: MessagePort) {

packages/platform-bun/src/internal/httpServer.ts

@@ -261,17 +261,17 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
 
   get stream(): Stream.Stream<Uint8Array, Error.RequestError> {
     return this.source.body
-      ? Stream.fromReadableStream(() => this.source.body as any, (_) =>
+      ? Stream.fromReadableStream(() => this.source.body as any, (cause) =>
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error: _
+          cause
         }))
       : Stream.fail(
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error: "can not create stream from empty body"
+          description: "can not create stream from empty body"
         })
       )
   }
@@ -284,11 +284,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     this.textEffect = Effect.runSync(Effect.cached(
       Effect.tryPromise({
         try: () => this.source.text(),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       })
     ))
@@ -298,11 +298,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
   get json(): Effect.Effect<unknown, Error.RequestError> {
     return Effect.tryMap(this.text, {
       try: (_) => JSON.parse(_) as unknown,
-      catch: (error) =>
+      catch: (cause) =>
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error
+          cause
         })
     })
   }
@@ -311,11 +311,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       }))
   }
@@ -353,11 +353,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     this.arrayBufferEffect = Effect.runSync(Effect.cached(
       Effect.tryPromise({
         try: () => this.source.arrayBuffer(),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       })
     ))
@@ -386,7 +386,7 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
               new Error.RequestError({
                 request: this,
                 reason: "Decode",
-                error: "Not an upgradeable ServerRequest"
+                description: "Not an upgradeable ServerRequest"
               })
             ))
             return

packages/platform-bun/src/internal/worker.ts

@@ -35,7 +35,7 @@ const platformWorkerImpl = Worker.makePlatform<globalThis.Worker>()({
     function onError(event: ErrorEvent) {
       Deferred.unsafeDone(
         deferred,
-        new WorkerError({ reason: "unknown", error: event.error ?? event.message })
+        new WorkerError({ reason: "unknown", cause: event.error ?? event.message })
       )
     }
     port.addEventListener("message", onMessage)