effect-app 4.0.0-beta.20 → 4.0.0-beta.201

package/src/client/errors.ts

@@ -1,19 +1,20 @@
 /** @effect-diagnostics overriddenSchemaConstructor:skip-file */
-import { TaggedError } from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
 import * as Cause from "effect/Cause"
 import * as S from "../Schema.js"
 
-export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
+export const tryToJson = (error: unknown) => {
   try {
-    return error.toJSON()
+    const errorJson = (error as any).toJSON()
+    return errorJson && typeof errorJson === "object" ? errorJson as Record<string, unknown> : { error }
   } catch {
     try {
-      return error.toString()
+      return { error: (error as any).toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }
@@ -21,7 +22,7 @@ export const tryToJson = (error: { toJSON(): unknown; toString(): string }) => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 // @ts-expect-error type not used
-export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<ItemType>>()("NotFoundError", {
+export class NotFoundError<ItemType = string> extends TaggedErrorClass<NotFoundError<ItemType>>()("NotFoundError", {
   type: S.String,
   id: S.Unknown
 }) {
@@ -29,76 +30,97 @@ export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<
     props: { type: string; id: unknown; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Didn't find ${(this as any).type}#${JSON.stringify((this as any).id)}`
   }
+  override toString() {
+    return `NotFoundError: ${this.message}`
+  }
 }
 
 const messageFallback = (messageOrObject?: string | { message: string }) =>
   typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject ?? "" }
 
-export class InvalidStateError extends TaggedError<InvalidStateError>()("InvalidStateError", {
+export class InvalidStateError extends TaggedErrorClass<InvalidStateError>()("InvalidStateError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(
-      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
       disableValidation as any
     )
   }
+  override toString() {
+    return `InvalidStateError: ${this.message}`
+  }
 }
 
-export class ServiceUnavailableError extends TaggedError<ServiceUnavailableError>()("ServiceUnavailableError", {
+export class ServiceUnavailableError extends TaggedErrorClass<ServiceUnavailableError>()("ServiceUnavailableError", {
   message: S.String
 }) {
   constructor(messageOrObject: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
     super(
-      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject } as any,
+      typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject },
       disableValidation as any
     )
   }
+  override toString() {
+    return `ServiceUnavailableError: ${this.message}`
+  }
 }
 
-export class ValidationError extends TaggedError<ValidationError>()("ValidationError", {
+export class ValidationError extends TaggedErrorClass<ValidationError>()("ValidationError", {
   errors: S.Array(S.Unknown)
 }) {
   constructor(
     props: { errors: ReadonlyArray<unknown>; cause?: unknown },
     disableValidation?: boolean
   ) {
-    super(props as any, disableValidation as any)
+    super(props, disableValidation as any)
   }
   override get message() {
     return `Validation failed: ${(this as any).errors.map((e: any) => JSON.stringify(e, undefined, 2)).join(",\n")}`
   }
+  override toString() {
+    return `ValidationError: ${this.message}`
+  }
 }
 
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
+export class NotLoggedInError extends TaggedErrorClass<NotLoggedInError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `NotLoggedInError: ${this.message}`
   }
 }
 
 /**
  * The user carries a valid Userprofile, but there is a problem with the login none the less.
  */
-export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
+export class LoginError extends TaggedErrorClass<LoginError>()("NotLoggedInError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `LoginError: ${this.message}`
   }
 }
 
-export class UnauthorizedError extends TaggedError<UnauthorizedError>()("UnauthorizedError", {
+export class UnauthorizedError extends TaggedErrorClass<UnauthorizedError>()("UnauthorizedError", {
   message: S.String
 }) {
   constructor(messageOrObject?: string | { message: string; cause?: unknown }, disableValidation?: boolean) {
-    super(messageFallback(messageOrObject) as any, disableValidation as any)
+    super(messageFallback(messageOrObject), disableValidation as any)
+  }
+  override toString() {
+    return `UnauthorizedError: ${this.message}`
   }
 }
 
@@ -110,7 +132,7 @@ type OptimisticConcurrencyDetails = {
   readonly found?: string | undefined
 }
 
-export class OptimisticConcurrencyException extends TaggedError<OptimisticConcurrencyException>()(
+export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticConcurrencyException>()(
   "OptimisticConcurrencyException",
   { message: S.String }
 ) {
@@ -123,13 +145,16 @@ export class OptimisticConcurrencyException extends TaggedError<OptimisticConcur
     disableValidation?: boolean
   ) {
     super(
-      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` } as any,
+      "message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` },
       disableValidation as any
     )
     if (!("message" in args)) {
       this.details = args
     }
   }
+  override toString() {
+    return `OptimisticConcurrencyException: ${this.message}`
+  }
 }
 
 const MutationOnlyErrors = [
@@ -183,6 +208,7 @@ export class CauseException<E> extends Error {
     Error.stackTraceLimit = 0
     super()
     Error.stackTraceLimit = limit
+    this.cause = Cause.squash(originalCause)
     // v4: makeFiberFailure removed — use Cause.prettyErrors instead
     const errors = Cause.prettyErrors(originalCause)
     const first = errors[0]
@@ -222,17 +248,17 @@ export class CauseException<E> extends Error {
   }
 }
 
-export const tryToReport = (error: { toReport(): unknown; toString(): string }) => {
+export const tryToReport = (error: { toReport(): Record<string, unknown>; toString(): string }) => {
   try {
     return error.toReport()
   } catch {
     try {
-      return error.toString()
+      return { error: error.toString() }
     } catch (err) {
       try {
-        return `Failed to convert error: ${err}`
+        return { error: `Failed to convert error: ${err}` }
       } catch {
-        return `Failed to convert error: unknown failure`
+        return { error: `Failed to convert error: unknown failure` }
       }
     }
   }