@effect-app/infra 0.113.8 → 0.113.10

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @effect-app/infra
 
+## 0.113.10
+
+### Patch Changes
+
+- Updated dependencies [da80c66]
+  - @effect-app/prelude@0.89.0
+  - @effect-app/schema@0.81.0
+  - @effect-app/infra-adapters@0.70.11
+
+## 0.113.9
+
+### Patch Changes
+
+- Updated dependencies [8235a1a]
+  - @effect-app/core@0.83.3
+  - @effect-app/infra-adapters@0.70.10
+  - @effect-app/prelude@0.88.9
+  - @effect-app/schema@0.80.6
+
 ## 0.113.8
 
 ### Patch Changes

package/dist/services/RepositoryBase.d.ts

@@ -110,7 +110,7 @@ export declare function makeRepo<PM extends {
             value: A_1;
             readonly S: PM;
         };
-    }) => Where | readonly [Where, ...Where[]], mode?: "and" | "or" | undefined) => Filter<PM>;
+    }) => Where | readonly [Where, ...Where[]], mode?: "or" | "and" | undefined) => Filter<PM>;
 };
 /**
  * only use this as a shortcut if you don't have the item already

package/dist/services/simpledb/cosmosdb.d.ts

@@ -7,8 +7,8 @@ import type { DBRecord } from "./shared.js";
 import { OptimisticLockException } from "./shared.js";
 import * as simpledb from "./simpledb.js";
 export declare function createContext<TKey extends string, EA, A extends DBRecord<TKey>>(): <REncode, RDecode, EDecode>(type: string, encode: (record: A) => Effect<REncode, never, EA>, decode: (d: EA) => Effect<RDecode, EDecode, A>, indexes: IndexingPolicy) => import("effect/Effect").Effect<Cosmos.CosmosClient, import("effect/Cause").UnknownException, {
-    find: (id: string) => import("effect/Effect").Effect<simpledb.RecordCache | RDecode | Cosmos.CosmosClient, import("effect/Cause").UnknownException | simpledb.InvalidStateError, import("effect/Option").Option<A>>;
+    find: (id: string) => import("effect/Effect").Effect<RDecode | Cosmos.CosmosClient | simpledb.RecordCache, import("effect/Cause").UnknownException | simpledb.InvalidStateError, import("effect/Option").Option<A>>;
     findBy: (parameters: Record<string, string>) => import("effect/Effect").Effect<Cosmos.CosmosClient, import("effect/Cause").UnknownException, import("effect/Option").Option<any>>;
-    save: (record: A) => import("effect/Effect").Effect<simpledb.RecordCache | REncode | Cosmos.CosmosClient, OptimisticLockException, A>;
+    save: (record: A) => import("effect/Effect").Effect<REncode | Cosmos.CosmosClient | simpledb.RecordCache, OptimisticLockException, A>;
 }>;
 //# sourceMappingURL=cosmosdb.d.ts.map

package/dist/services/simpledb/diskdb.d.ts

@@ -4,9 +4,9 @@ import type { DBRecord, Index } from "./shared.js";
 import { CouldNotAquireDbLockException } from "./shared.js";
 import * as simpledb from "./simpledb.js";
 export declare function createContext<TKey extends string, EA, A extends DBRecord<TKey>>(): <REncode, RDecode, EDecode>(type: string, encode: (record: A) => Effect<REncode, never, EA>, decode: (d: EA) => Effect<RDecode, EDecode, A>, schemaVersion: string, makeIndexKey: (r: A) => Index, dir?: string) => {
-    find: (id: string) => import("effect/Effect").Effect<simpledb.RecordCache | RDecode, simpledb.InvalidStateError, import("effect/Option").Option<A>>;
-    findByIndex: (index: Index) => import("effect/Effect").Effect<never, never, import("effect/Option").Option<TKey>>;
-    save: (record: A) => import("effect/Effect").Effect<simpledb.RecordCache | REncode, import("./shared.js").OptimisticLockException | simpledb.InvalidStateError | CouldNotAquireDbLockException, A>;
+    find: (id: string) => import("effect/Effect").Effect<RDecode | simpledb.RecordCache, simpledb.InvalidStateError, import("effect/Option").Option<A>>;
+    findByIndex: (index: Index) => import("effect/Effect").Effect<never, never, import("effect/Option").Option<TKey & {}>>;
+    save: (record: A) => import("effect/Effect").Effect<REncode | simpledb.RecordCache, CouldNotAquireDbLockException | import("./shared.js").OptimisticLockException | simpledb.InvalidStateError, A>;
 };
 export declare function initialise(dir: string): void;
 //# sourceMappingURL=diskdb.d.ts.map

package/dist/services/simpledb/memdb.d.ts

@@ -5,8 +5,8 @@ import * as S from "@effect-app/schema";
 import type { DBRecord } from "./shared.js";
 import * as simpledb from "./simpledb.js";
 export declare function createContext<TKey extends string, EA, A extends DBRecord<TKey>>(): <REncode, RDecode, EDecode>(type: string, encode: (record: A) => Effect<REncode, never, EA>, decode: (d: EA) => Effect<RDecode, EDecode, A>) => {
-    find: (id: string) => import("effect/Effect").Effect<simpledb.RecordCache | RDecode, simpledb.InvalidStateError | S.CondemnException, import("effect/Option").Option<A>>;
+    find: (id: string) => import("effect/Effect").Effect<RDecode | simpledb.RecordCache, S.CondemnException | simpledb.InvalidStateError, import("effect/Option").Option<A>>;
     findBy: <V extends Partial<A>>(keys: V, eq: Equivalence<V>) => import("effect/Effect").Effect<RDecode, S.CondemnException, import("effect/Option").Option<A & {}>>;
-    save: (record: A) => import("effect/Effect").Effect<simpledb.RecordCache | REncode, import("./shared.js").OptimisticLockException | simpledb.InvalidStateError | S.CondemnException, A>;
+    save: (record: A) => import("effect/Effect").Effect<REncode | simpledb.RecordCache, S.CondemnException | import("./shared.js").OptimisticLockException | simpledb.InvalidStateError, A>;
 };
 //# sourceMappingURL=memdb.d.ts.map

package/dist/services/simpledb/redisdb.d.ts

@@ -6,9 +6,9 @@ import type { DBRecord, Index } from "./shared.js";
 import { CouldNotAquireDbLockException } from "./shared.js";
 import * as simpledb from "./simpledb.js";
 export declare function createContext<TKey extends string, EA, A extends DBRecord<TKey>>(): <REncode, RDecode, EDecode>(type: string, encode: (record: A) => Effect<REncode, never, EA>, decode: (d: EA) => Effect<RDecode, EDecode, A>, schemaVersion: string, makeIndexKey: (r: A) => Index) => {
-    find: (id: string) => import("effect/Effect").Effect<simpledb.RecordCache | RDecode | RedisClient, simpledb.InvalidStateError, import("effect/Option").Option<A>>;
+    find: (id: string) => import("effect/Effect").Effect<RDecode | RedisClient | simpledb.RecordCache, simpledb.InvalidStateError, import("effect/Option").Option<A>>;
     findByIndex: (index: Index) => import("effect/Effect").Effect<RedisClient, import("@effect-app/infra-adapters/redis-client").ConnectionException, import("effect/Option").Option<TKey>>;
-    save: (record: A) => import("effect/Effect").Effect<simpledb.RecordCache | REncode | RedisClient, import("./shared.js").OptimisticLockException | simpledb.InvalidStateError | CouldNotAquireDbLockException, A>;
+    save: (record: A) => import("effect/Effect").Effect<REncode | RedisClient | simpledb.RecordCache, CouldNotAquireDbLockException | import("./shared.js").OptimisticLockException | simpledb.InvalidStateError, A>;
 };
 declare const RedisSerializedDBRecord_base: S.Class<RedisSerializedDBRecord, S.SchemaProperties<S.ToProps<{
     version: S.SchemaDefaultSchema<unknown, string, string, string, {}>;

package/dist/services/simpledb/simpledb.d.ts

@@ -19,5 +19,5 @@ export declare const RecordCache: import("effect/Context").Tag<RecordCache, Reco
 export declare const LiveRecordCache: import("effect/Layer").Layer<never, never, RecordCache>;
 export declare function find<R, RDecode, EDecode, E, EA, A>(tryRead: (id: string) => Effect<R, E, Option<CachedRecord<EA>>>, decode: (d: EA) => Effect<RDecode, EDecode, A>, type: string): (id: string) => import("effect/Effect").Effect<R | RDecode | RecordCache, E | InvalidStateError, import("effect/Option").Option<A>>;
 export declare function storeDirectly<R, E, TKey extends string, A extends DBRecord<TKey>>(save: (r: A, version: Option<Version>) => Effect<R, E, CachedRecord<A>>, type: string): (record: A) => import("effect/Effect").Effect<R | RecordCache, E, A>;
-export declare function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<TKey>>(tryRead: (id: string) => Effect<R, E, Option<CachedRecord<EA>>>, save: (r: A, version: Option<Version>) => Effect<R, E, CachedRecord<A>>, lock: (id: string) => Effect<R2 | Scope, E2, unknown>, type: string): (record: A) => import("effect/Effect").Effect<RecordCache | R | Exclude<R2, import("effect/Scope").Scope>, OptimisticLockException | InvalidStateError | E | E2, A>;
+export declare function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<TKey>>(tryRead: (id: string) => Effect<R, E, Option<CachedRecord<EA>>>, save: (r: A, version: Option<Version>) => Effect<R, E, CachedRecord<A>>, lock: (id: string) => Effect<R2 | Scope, E2, unknown>, type: string): (record: A) => import("effect/Effect").Effect<R | RecordCache | Exclude<R2, import("effect/Scope").Scope>, E | E2 | OptimisticLockException | InvalidStateError, A>;
 //# sourceMappingURL=simpledb.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "0.113.8",
+  "version": "0.113.10",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -18,10 +18,10 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "6.0.4",
     "redlock": "^4.2.0",
-    "@effect-app/core": "0.83.2",
-    "@effect-app/prelude": "0.88.8",
-    "@effect-app/schema": "0.80.5",
-    "@effect-app/infra-adapters": "0.70.9"
+    "@effect-app/core": "0.83.3",
+    "@effect-app/infra-adapters": "0.70.11",
+    "@effect-app/prelude": "0.89.0",
+    "@effect-app/schema": "0.81.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.4",