effect-app 4.0.0-beta.265 → 4.0.0-beta.267

package/src/Model/Repository/service.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type * as Scope from "effect/Scope"
-import type { InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "../../client/errors.js"
+import type { DatabaseError, InvalidStateError, NotFoundError, OptimisticConcurrencyException } from "../../client/errors.js"
 import type * as Effect from "../../Effect.js"
 import type * as Option from "../../Option.js"
 import type * as S from "../../Schema.js"
@@ -49,32 +49,32 @@ export interface Repository<
 > {
   readonly itemType: ItemType
   readonly idKey: IdKey
-  readonly find: (id: T[IdKey]) => Effect.Effect<Option.Option<T>, never, RSchema>
-  readonly all: Effect.Effect<T[], never, RSchema>
+  readonly find: (id: T[IdKey]) => Effect.Effect<Option.Option<T>, DatabaseError, RSchema>
+  readonly all: Effect.Effect<T[], DatabaseError, RSchema>
   readonly saveAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect.Effect<void, InvalidStateError | OptimisticConcurrencyException, RSchema | RPublish>
+  ) => Effect.Effect<void, InvalidStateError | OptimisticConcurrencyException | DatabaseError, RSchema | RPublish>
   readonly changeFeed: ChangeFeed<T>
   readonly removeAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect.Effect<void, never, RSchema | RPublish>
+  ) => Effect.Effect<void, DatabaseError, RSchema | RPublish>
 
   readonly removeById: (
     idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>
-  ) => Effect.Effect<void, never, RSchema>
+  ) => Effect.Effect<void, DatabaseError, RSchema>
 
   readonly queryRaw: <T, Out, R>(
     schema: S.Codec<T, Out, R>,
     raw: RawQuery<Encoded, Out>
-  ) => Effect.Effect<readonly T[], S.SchemaError, R>
+  ) => Effect.Effect<readonly T[], S.SchemaError | DatabaseError, R>
 
   /**
    * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
    * Non-primary namespaces must be seeded explicitly before use.
    */
-  readonly seedNamespace: (namespace: string) => Effect.Effect<void>
+  readonly seedNamespace: (namespace: string) => Effect.Effect<void, DatabaseError>
 
   readonly query: {
     // ending with projection
@@ -91,7 +91,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -111,7 +112,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -133,7 +135,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -157,7 +160,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -183,7 +187,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -209,7 +214,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -237,7 +243,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -267,7 +274,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -299,7 +307,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -333,7 +342,8 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? readonly A[] : TType extends "count" ? NonNegativeInt : A,
       | (TType extends "many" ? never : NotFoundError<ItemType>)
-      | (TType extends "count" ? never : S.SchemaError),
+      | (TType extends "count" ? never : S.SchemaError)
+      | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
 
@@ -347,7 +357,7 @@ export interface Repository<
       q: (initial: Query<Encoded>) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -363,7 +373,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -383,7 +393,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -403,7 +413,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -425,7 +435,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -449,7 +459,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -475,7 +485,7 @@ export interface Repository<
       ) => QAll<Encoded, EncodedRefined, RefineTHelper<T, EncodedRefined>, R, TType, E>
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined> : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -504,7 +514,7 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined>
         : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -535,7 +545,7 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined>
         : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
     <
@@ -568,7 +578,7 @@ export interface Repository<
     ): Effect.Effect<
       TType extends "many" ? DistributeQueryIfExclusiveOnArray<E, T, EncodedRefined>
         : RefineTHelper<T, EncodedRefined>,
-      TType extends "many" ? never : NotFoundError<ItemType>,
+      (TType extends "many" ? never : NotFoundError<ItemType>) | DatabaseError,
       Exclude<R, RProvided> | RSchema
     >
   }
@@ -585,7 +595,7 @@ export interface Repository<
     percentage?: number
     /** optional maximum number of items to sample */
     maxItems?: number
-  }) => Effect.Effect<ValidationResult, never, RSchema>
+  }) => Effect.Effect<ValidationResult, DatabaseError, RSchema>
 }
 
 type DistributeQueryIfExclusiveOnArray<Exclusive extends boolean, T, EncodedRefined> = [Exclusive] extends [true]

package/src/Model/filter/types/path/eager.ts

@@ -7,27 +7,36 @@ import type { ArrayKey, IsTuple, TupleKeys } from "./common.js"
 
 /**
  * Helper type for recursively constructing paths through a type.
- * See {@link Path}
+ * `Seen` carries the set of object types already entered on this branch so
+ * recursion terminates on self-referential types (see {@link Path}).
  */
-type PathImpl<K extends string | number, V> = V extends
+type PathImpl<K extends string | number, V, Seen> = V extends
   | Primitive
   | BrowserNativeObject ? `${K}`
-  : `${K}` | `${K}.${Path<V>}`
+  // Stop before re-entering a type already on this branch. Recursive types
+  // (notably `Json`, the encoded form of `Schema.Defect()`:
+  // `JsonObject = { [x: string]: Json }`) would otherwise descend forever and
+  // blow past TS's instantiation limit => TS2589. The key itself stays a valid
+  // leaf path; only the unbounded descent is cut.
+  : [V] extends [Seen] ? `${K}`
+  : `${K}` | `${K}.${Path<V, Seen | V>}`
 
 /**
  * Type which eagerly collects all paths through a type
- * @typeParam T - type which should be introspected
+ * @typeParam T    - type which should be introspected
+ * @typeParam Seen - object types already entered on this recursion branch;
+ *                   used to terminate on self-referential types
  * @example
  * ```
  * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
  * ```
  */
-export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-      [K in TupleKeys<T>]-?: PathImpl<K & string, T[K]> | "length"
+export type Path<T, Seen = never> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+      [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], Seen> | "length"
     }[TupleKeys<T>]
-  : PathImpl<ArrayKey, V> | "length"
+  : PathImpl<ArrayKey, V, Seen | T> | "length"
   : {
-    [K in keyof T]-?: PathImpl<K & string, T[K]>
+    [K in keyof T]-?: PathImpl<K & string, T[K], Seen | T>
   }[keyof T]
 
 /**
@@ -35,6 +44,27 @@ export type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true
  */
 export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>
 
+export namespace PathRecursionTests {
+  // Regression: self-referential types must terminate instead of blowing past
+  // TS's instantiation limit (TS2589). `JsonLike` mirrors effect's `Json` — the
+  // encoded form of `Schema.Defect()` — whose `{ [x: string]: Json }` index
+  // signature previously made `Path` recurse forever. These aliases failing to
+  // compile (rather than resolving to a string union) signals the regression.
+  type JsonLike =
+    | string
+    | number
+    | boolean
+    | null
+    | ReadonlyArray<JsonLike>
+    | { readonly [x: string]: JsonLike }
+  export type _RawDefect = Path<{ id: string; raw: JsonLike }>
+  export type _NestedDefect = Path<{ a: { b: { error: { raw: JsonLike } } } }>
+  export type _ArrayOfDefect = Path<{ items: ReadonlyArray<{ raw: JsonLike }> }>
+  // finite paths are still produced
+  expectTypeOf<"id">().toExtend<_RawDefect>()
+  expectTypeOf<"raw">().toExtend<_RawDefect>()
+}
+
 /**
  * Type to evaluate the type which the given path points to.
  * @typeParam T - deeply nested type which is indexed by the path

package/src/Store.ts

@@ -3,7 +3,7 @@ import * as Data from "effect/Data"
 import type * as Redacted from "effect/Redacted"
 import * as Semaphore from "effect/Semaphore"
 import type { NonEmptyReadonlyArray } from "./Array.js"
-import type { OptimisticConcurrencyException } from "./client/errors.js"
+import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.js"
 import * as Context from "./Context.js"
 import * as Effect from "./Effect.js"
 import * as Layer from "./Layer.js"
@@ -99,30 +99,30 @@ export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded
 
 export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
   args: FilterArgs<Encoded, U>
-) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
+) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[], DatabaseError>
 
 export interface Store<
   IdKey extends keyof Encoded,
   Encoded extends FieldValues,
   PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
 > {
-  all: Effect.Effect<PM[]>
+  all: Effect.Effect<PM[], DatabaseError>
   filter: FilterFunc<Encoded>
-  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>>
-  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException>
+  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>, DatabaseError>
+  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException | DatabaseError>
   batchSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
   bulkSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
-  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
-  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException | DatabaseError>
+  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void, DatabaseError>
+  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[], DatabaseError>
   /**
    * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
    * Non-primary namespaces must be seeded explicitly before use.
    */
-  seedNamespace: (namespace: string) => Effect.Effect<void>
+  seedNamespace: (namespace: string) => Effect.Effect<void, DatabaseError>
 }
 
 export class StoreMaker extends Context.Opaque<StoreMaker, {

package/src/client/errors.ts

@@ -157,6 +157,45 @@ export class OptimisticConcurrencyException extends TaggedErrorClass<OptimisticC
   }
 }
 
+/**
+ * Raised by a store adapter when a database operation fails for an
+ * infrastructure reason (request timeout, throttle, 5xx, dropped socket, or any
+ * non-conflict error). Distinct from `OptimisticConcurrencyException`, which is
+ * an expected etag conflict.
+ *
+ * `transient` is set by the adapter for failures worth retrying (timeout /
+ * throttle / 5xx / network). `cause` is the underlying adapter error, carried
+ * through a `Defect` schema so it serializes (an `Error` encodes to
+ * `{ name, message, cause }`) instead of breaking JSON encoding of the channel.
+ *
+ * Treated by the api/client/FE machinery like an unexpected (500-class) error.
+ */
+export class DatabaseError extends TaggedErrorClass<DatabaseError>()(
+  "DatabaseError",
+  {
+    message: S.String,
+    transient: S.Boolean,
+    cause: S.optional(S.Defect())
+  }
+) {
+  constructor(
+    args: { message?: string; transient?: boolean; cause?: unknown },
+    disableValidation?: boolean
+  ) {
+    super(
+      {
+        message: args.message ?? "Database operation failed",
+        transient: args.transient ?? false,
+        cause: args.cause
+      },
+      disableValidation as any
+    )
+  }
+  override toString() {
+    return `DatabaseError: ${this.message}`
+  }
+}
+
 const MutationOnlyErrors = [
   InvalidStateError,
   OptimisticConcurrencyException
@@ -168,7 +207,8 @@ const GeneralErrors = [
   LoginError,
   UnauthorizedError,
   ValidationError,
-  ServiceUnavailableError
+  ServiceUnavailableError,
+  DatabaseError
 ] as const
 
 export const SupportedErrors = S.Union([