@effect-app/infra 0.12.6 → 0.14.0

package/_src/services/Repository.ts

@@ -1,22 +1,28 @@
 // Update = Must return updated items
 // Modify = Must `set` updated items, and can return anything.
+import type { FixEnv, PureLogT } from "@effect-app/prelude/_ext/Pure"
+import { Pure } from "@effect-app/prelude/_ext/Pure"
+import type { ParserEnv } from "@effect-app/schema/custom/Parser"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
 import { NotFoundError } from "../errors.js"
 import type { RequestContext } from "../RequestContext.js"
-import { ContextMap} from "../services/Store.js";
+import { ContextMap } from "../services/Store.js"
 import type { Filter } from "../services/Store.js"
-import type { FixEnv, PureLogT} from "@effect-app/prelude/_ext/Pure";
-import { Pure } from "@effect-app/prelude/_ext/Pure"
-import type { ParserEnv } from "@effect-app/schema/custom/Parser"
 
 /**
  * @tsplus type Repository
  */
-export interface Repository<T extends { id: Id }, PM extends { id: string }, Evt, Id extends string, ItemType extends string> {
+export interface Repository<
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  Id extends string,
+  ItemType extends string
+> {
   itemType: ItemType
   find: (id: Id) => Effect<ContextMap | RequestContext, never, Opt<T>>
   all: Effect<ContextMap, never, Chunk<T>>
-  save: (
+  saveAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
   ) => Effect<ContextMap | RequestContext, InvalidStateError | OptimisticConcurrencyException, void>
@@ -24,18 +30,24 @@ export interface Repository<T extends { id: Id }, PM extends { id: string }, Evt
     mapReverse: (
       pm: PM,
       setEtag: (id: string, eTag: string | undefined) => void
-    ) => unknown, // TODO
-    parse: (a: unknown, env?: ParserEnv | undefined) => T,
-    all: Effect<never, never, Chunk<PM>>,
-    filter: (filter: Filter<PM>, cursor?: { limit?: number, skip?: number}) => Effect<never, never, Chunk<PM>>
+    ) => unknown // TODO
+    parse: (a: unknown, env?: ParserEnv | undefined) => T
+    all: Effect<never, never, Chunk<PM>>
+    filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<never, never, Chunk<PM>>
   }
 }
 
 export interface PureDSL<S, S2, W> {
-  get: ReturnType<typeof Pure.get<S>>, set: typeof Pure.set<S2>, log: (...w: W[]) => PureLogT<W>
+  get: ReturnType<typeof Pure.get<S>>
+  set: typeof Pure.set<S2>
+  log: (...w: W[]) => PureLogT<W>
 }
 
-export const AnyPureDSL: PureDSL<any, any, any> = { get: Pure.get(), set: Pure.set, log: (...evt: any[]) => Pure.logMany(evt) }
+export const AnyPureDSL: PureDSL<any, any, any> = {
+  get: Pure.get(),
+  set: Pure.set,
+  log: (...evt: any[]) => Pure.logMany(evt)
+}
 
 /**
  * @tsplus fluent Repository get
@@ -61,7 +73,7 @@ export function filter<
   T extends { id: Id },
   PM extends { id: string },
   Evt,
-  ItemType extends string,
+  ItemType extends string
 >(self: Repository<T, PM, Evt, Id, ItemType>, filter: Predicate<T>) {
   return self.all.map(_ => _.filter(filter))
 }
@@ -75,12 +87,11 @@ export function filterAll<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S extends T,
+  S extends T
 >(self: Repository<T, PM, Evt, Id, ItemType>, map: (items: Chunk<T>) => Chunk<S>) {
   return self.all.map(map)
 }
 
-
 /**
  * @tsplus fluent Repository collect
  */
@@ -90,7 +101,7 @@ export function collect<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S extends T,
+  S extends T
 >(self: Repository<T, PM, Evt, Id, ItemType>, collect: (item: T) => Opt<S>) {
   return self.all.map(_ => _.filterMap(collect))
 }
@@ -127,7 +138,7 @@ export function projectEffect<
 ) {
   // TODO: a projection that gets sent to the db instead.
   return map.flatMap(f =>
-    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip}) : self.utils.all)
+    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip }) : self.utils.all)
       .map(_ => _.filterMap(f.collect))
   )
 }
@@ -142,7 +153,7 @@ export function project<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S,
+  S
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   map: { filter?: Filter<PM>; collect: (t: PM) => Opt<S>; limit?: number; skip?: number }
@@ -150,7 +161,6 @@ export function project<
   return self.projectEffect(Effect(map))
 }
 
-
 /**
  * @tsplus fluent Repository queryEffect
  */
@@ -162,14 +172,14 @@ export function queryEffect<
   ItemType extends string,
   R,
   E,
-  S,
+  S
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: Effect<R, E, { filter?: Filter<PM>; collect: (t: T) => Opt<S>; limit?: number; skip?: number }>
 ) {
   return map.flatMap(f =>
-    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip}) : self.utils.all)
+    (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip }) : self.utils.all)
       .flatMap(items =>
         Do($ => {
           const { set } = $(Effect.service(ContextMap))
@@ -192,7 +202,7 @@ export function queryOneEffect<
   ItemType extends string,
   R,
   E,
-  S,
+  S
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
@@ -207,7 +217,11 @@ export function queryOneEffect<
         })
       )
       .map(_ => _.map(_ => self.utils.parse(_)))
-      .flatMap(_ => _.filterMap(f.collect).toNonEmptyArray.encaseInEffect(() => new NotFoundError(self.itemType, JSON.stringify(f.filter))).map(_ => _[0]))
+      .flatMap(_ =>
+        _.filterMap(f.collect).toNonEmptyArray.encaseInEffect(() =>
+          new NotFoundError(self.itemType, JSON.stringify(f.filter))
+        ).map(_ => _[0])
+      )
   )
 }
 
@@ -220,7 +234,7 @@ export function query<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S,
+  S
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
@@ -238,7 +252,7 @@ export function queryOne<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S,
+  S
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
@@ -258,7 +272,7 @@ export function queryAndSavePureEffect<
   ItemType extends string,
   R,
   E,
-  S extends T = T,
+  S extends T = T
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
@@ -278,7 +292,7 @@ export function queryAndSavePure<
   PM extends { id: string },
   Evt,
   ItemType extends string,
-  S extends T = T,
+  S extends T = T
 >(
   self: Repository<T, PM, Evt, Id, ItemType>,
   // TODO: think about collectPM, collectE, and collect(Parsed)
@@ -298,7 +312,7 @@ export function saveManyWithPure<
   ItemType extends string
 >(self: Repository<T, PM, Evt, Id, ItemType>) {
   return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>) =>
-    (items: Iterable<S1>) => saveManyWithPure_(self, items, pure)
+  (items: Iterable<S1>) => saveManyWithPure_(self, items, pure)
 }
 
 /**
@@ -311,7 +325,8 @@ export function byIdAndSaveWithPure<
   Evt,
   ItemType extends string
 >(self: Repository<T, PM, Evt, Id, ItemType>, id: Id) {
-  return <R, A, E, S2 extends T>(pure: Effect<FixEnv<R, Evt, T, S2>, E, A>) => get(self, id).flatMap(item => saveWithPure_(self, item, pure))
+  return <R, A, E, S2 extends T>(pure: Effect<FixEnv<R, Evt, T, S2>, E, A>) =>
+    get(self, id).flatMap(item => saveWithPure_(self, item, pure))
 }
 
 /**
@@ -323,9 +338,12 @@ export function handleByIdAndSaveWithPure<
   T extends { id: Id },
   PM extends { id: string },
   Evt,
-  ItemType extends string,
+  ItemType extends string
 >(self: Repository<T, PM, Evt, Id, ItemType>) {
-  return <Req extends { id: Id }, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<FixEnv<R, Evt, T, S2>, E, A>) => (req: Req, ctx: Context) => byIdAndSaveWithPure(self, req.id)(pure(req, ctx))
+  return <Req extends { id: Id }, Context, R, A, E, S2 extends T>(
+    pure: (req: Req, ctx: Context) => Effect<FixEnv<R, Evt, T, S2>, E, A>
+  ) =>
+  (req: Req, ctx: Context) => byIdAndSaveWithPure(self, req.id)(pure(req, ctx))
 }
 
 /**
@@ -375,7 +393,7 @@ export function saveWithPure_<
   return saveAllWithEffectInt(
     self,
     pure.runTerm(item)
-    .map(([item, events, a]) => [[item], events, a])
+      .map(([item, events, a]) => [[item], events, a])
   )
 }
 
@@ -396,7 +414,7 @@ function saveAllWithEffectInt<
   return gen
     .flatMap(
       ([items, events, a]) =>
-        self.save(items, events)
+        self.saveAndPublish(items, events)
           .map(() => a)
     )
 }
@@ -404,16 +422,21 @@ function saveAllWithEffectInt<
 const anyDSL = makeDSL<any, any, any>()
 
 export type AllDSL<T, Evt> =
-  (<R, A, E, S1 extends T, S2 extends T>(pure: (dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>)
-    & AllDSLExt<T, Evt>
+  & (<R, A, E, S1 extends T, S2 extends T>(
+    pure: (dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>
+  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>)
+  & AllDSLExt<T, Evt>
 
-  
 /**
  * @tsplus type DSLExt
  */
-export interface AllDSLExt<T, Evt>  {
-  modify: <R, E, A, S1 extends T, S2 extends T>(pure: (items: Chunk<S1>, dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>;
-  update: <R, E, S1 extends T, S2 extends T>(pure: (items: Chunk<S1>, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<R, E, Iterable<S2>>) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, Iterable<S2>>;
+export interface AllDSLExt<T, Evt> {
+  modify: <R, E, A, S1 extends T, S2 extends T>(
+    pure: (items: Chunk<S1>, dsl: PureDSL<Chunk<S1>, Iterable<S2>, Evt>) => Effect<R, E, A>
+  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, A>
+  update: <R, E, S1 extends T, S2 extends T>(
+    pure: (items: Chunk<S1>, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<R, E, Iterable<S2>>
+  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Iterable<S2>>, E, Iterable<S2>>
 }
 
 export function makeAllDSL<T, Evt>() {
@@ -422,16 +445,21 @@ export function makeAllDSL<T, Evt>() {
 }
 
 export type OneDSL<T, Evt> =
-(<R, A, E, S1 extends T, S2 extends T>(pure: (dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>)
-& OneDSLExt<T, Evt>
-
+  & (<R, A, E, S1 extends T, S2 extends T>(
+    pure: (dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>
+  ) => Effect<FixEnv<R, Evt, S1, S2>, E, A>)
+  & OneDSLExt<T, Evt>
 
 /**
  * @tsplus type DSLExt
  */
 export interface OneDSLExt<T, Evt> {
-  modify: <R, E, A, S1 extends T, S2 extends T>(pure: (items: S1, dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>) => Effect<FixEnv<R, Evt, S1, S2> | PureEnvEnv<Evt, S1, S1>, E, A>;
-  update: <R, E, S1 extends T, S2 extends T>(pure: (items: S1, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>;
+  modify: <R, E, A, S1 extends T, S2 extends T>(
+    pure: (items: S1, dsl: PureDSL<S1, S2, Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, A>
+  ) => Effect<FixEnv<R, Evt, S1, S2> | PureEnvEnv<Evt, S1, S1>, E, A>
+  update: <R, E, S1 extends T, S2 extends T>(
+    pure: (items: S1, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>
+  ) => Effect<FixEnv<R, Evt, S1, S2>, E, S2>
 }
 
 /**
@@ -444,11 +472,14 @@ export function updateWithOne<T, Evt, S1 extends T, S2 extends T>(self: OneDSL<T
 /**
  * @tsplus fluent DSLExt updateWith
  */
-export function updateWith<T, Evt, S1 extends T, S2 extends T>(self: AllDSL<T, Evt>, upd: (item: Chunk<S1>) => Iterable<S2>) {
+export function updateWith<T, Evt, S1 extends T, S2 extends T>(
+  self: AllDSL<T, Evt>,
+  upd: (item: Chunk<S1>) => Iterable<S2>
+) {
   return self.update((_: Chunk<S1>) => Effect(upd(_)))
 }
 
-export function makeOneDSL<T, Evt>(): OneDSL<T, Evt>  {
+export function makeOneDSL<T, Evt>(): OneDSL<T, Evt> {
   return anyDSL
 }
 
@@ -491,15 +522,15 @@ export function makeDSL<S1, S2, Evt>() {
   }
 
   return Object.assign(
-    withDSL, {
+    withDSL,
+    {
       modify,
-      update,
+      update
     }
   )
 }
 
-export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> { }
-
+export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
 
 export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
   return (items: Iterable<T>) => Effect(items.toNonEmptyArray).flatMapOpt(fn)
@@ -511,3 +542,33 @@ export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effec
 export function ifAny_<T, R, E, A>(items: Iterable<T>, fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
   return Effect(items.toNonEmptyArray).flatMapOpt(fn)
 }
+
+/**
+ * @tsplus getter Repository save
+ */
+export function save<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>
+) {
+  return (...items: NonEmptyArray<T>) => self.saveAndPublish(items)
+}
+
+/**
+ * @tsplus getter Repository saveWithEvents
+ */
+export function saveWithEvents<
+  Id extends string,
+  T extends { id: Id },
+  PM extends { id: string },
+  Evt,
+  ItemType extends string
+>(
+  self: Repository<T, PM, Evt, Id, ItemType>
+) {
+  return (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) => self.saveAndPublish(items, events)
+}

package/_src/services/Store/Cosmos.ts

@@ -237,23 +237,23 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
               const skip = cursor?.skip
               const limit = cursor?.limit
               return (filter.type === "join_find"
-                ? // This is a problem if one of the multiple joined arrays can be empty!
+                // This is a problem if one of the multiple joined arrays can be empty!
                 // https://stackoverflow.com/questions/60320780/azure-cosmosdb-sql-join-not-returning-results-when-the-child-contains-empty-arra
                 // so we use multiple queries instead.
-                  filter.keys
-                    .forEachEffect(k =>
-                      Effect(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
-                        .tap(q => logQuery(q))
-                        .flatMap(q =>
-                          Effect.promise(() =>
-                            container.items
-                              .query<PM>(q)
-                              .fetchAll()
-                              .then(({ resources }) => resources.toChunk)
-                          )
+                ? filter.keys
+                  .forEachEffect(k =>
+                    Effect(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
+                      .tap(q => logQuery(q))
+                      .flatMap(q =>
+                        Effect.promise(() =>
+                          container.items
+                            .query<PM>(q)
+                            .fetchAll()
+                            .then(({ resources }) => resources.toChunk)
                         )
-                    )
-                    .map(_ => _.flatMap(_ => _))
+                      )
+                  )
+                  .map(_ => _.flatMap(_ => _))
                 : Effect(() => buildCosmosQuery(filter, name, importedMarkerId, skip, limit))
                   .tap(q => logQuery(q))
                   .flatMap(q =>

package/_src/services/Store/codeFilter.test.ts

@@ -1,12 +1,11 @@
-import { expect, test } from "vitest"
 import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
+import { expect, test } from "vitest"
 import { makeFilters } from "../../filter.js"
 import { codeFilter } from "./utils.js"
 
-
 const somethings = [
-  {a: 1, b: "b", c: ["c"], d: [{a: "a2", b: 1}, {a: "a", b: 1}], id: "1"},
-  {a: 2, b: "b2", c: ["c2"], d: [{a: "a4", b: 2}, {a: "a5", b: 2}], id: "2"},
+  { a: 1, b: "b", c: ["c"], d: [{ a: "a2", b: 1 }, { a: "a", b: 1 }], id: "1" },
+  { a: 2, b: "b2", c: ["c2"], d: [{ a: "a4", b: 2 }, { a: "a5", b: 2 }], id: "2" }
 ] satisfies readonly Something[]
 
 const f_ = makeFilters<Something>()
@@ -31,44 +30,52 @@ export function somethingsWhere(
   })
 }
 
-
 type SomethingElse = {
-  a: string,
+  a: string
   b: number
 }
 
 type Something = {
-  a: number,
-  id: string,
-  b: string,
+  a: number
+  id: string
+  b: string
   c: readonly string[]
   d: readonly SomethingElse[]
 }
 
 test("works", () => {
-  expect(somethings.filterMap(codeFilter(
-    somethingsWhere(_ => _("b", _ => "b2"))
-  )).toArray)
-  .toEqual([somethings[1]])
-
-  expect(somethings.filterMap(codeFilter(
-    somethingsWhere(_ => _("b", _ => "b"))
-  )).toArray)
-  .toEqual([somethings[0]])
+  expect(
+    somethings.filterMap(codeFilter(
+      somethingsWhere(_ => _("b", _ => "b2"))
+    )).toArray
+  )
+    .toEqual([somethings[1]])
 
+  expect(
+    somethings.filterMap(codeFilter(
+      somethingsWhere(_ => _("b", _ => "b"))
+    )).toArray
+  )
+    .toEqual([somethings[0]])
 
-  expect(somethings.filterMap(codeFilter(
-    somethingsWhere(_ => _("d.-1.a", _ => "a5"))
-  )).toArray)
-  .toEqual([somethings[1]])
+  expect(
+    somethings.filterMap(codeFilter(
+      somethingsWhere(_ => _("d.-1.a", _ => "a5"))
+    )).toArray
+  )
+    .toEqual([somethings[1]])
 
-  expect(somethings.filterMap(codeFilter(
-    somethingsWhere(_ => _("d.-1.a", _ => "a"))
-  )).toArray)
-  .toEqual([somethings[0]])
+  expect(
+    somethings.filterMap(codeFilter(
+      somethingsWhere(_ => _("d.-1.a", _ => "a"))
+    )).toArray
+  )
+    .toEqual([somethings[0]])
 
-  expect(somethings.filterMap(codeFilter(
-    somethingsWhere(_ => _("d.-1.a", _ => _.$isnt("a")))
-  )).toArray)
-  .toEqual([somethings[1]])
+  expect(
+    somethings.filterMap(codeFilter(
+      somethingsWhere(_ => _("d.-1.a", _ => _.$isnt("a")))
+    )).toArray
+  )
+    .toEqual([somethings[1]])
 })

package/_src/services/Store/utils.ts

@@ -13,8 +13,8 @@ export const makeETag = <E extends PersistenceModelType<Id>, Id extends string>(
     ...e,
     _etag: objectHash(e)
   }) as any
-export const makeUpdateETag = (name: string) =>
-  <E extends PersistenceModelType<Id>, Id extends string>(e: E, current: Opt<E>) =>
+export const makeUpdateETag =
+  (name: string) => <E extends PersistenceModelType<Id>, Id extends string>(e: E, current: Opt<E>) =>
     Effect.gen(function*($) {
       if (current.isSome() && current.value._etag !== e._etag) {
         return yield* $(
@@ -54,40 +54,40 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
         })
         ? Opt(x as unknown as NE)
         : Opt.none
-      : // TODO: support mixed or/and
-        filter.mode === "or"
-        ? filter.where
-            .some(p =>
-              p.t === "in"
-                ? p.value.includes(get(x, p.key))
-                : p.t === "not-in"
-                ? !p.value.includes(get(x, p.key))
-                : p.t === "not-eq"
-                ? !compareCaseInsensitive(get(x, p.key), p.value)
-                : compareCaseInsensitive(get(x, p.key), p.value)
-            )
-          ? Opt(x as unknown as NE)
-          : Opt.none
-        : filter.where
-            .every(p =>
-              p.t === "in"
-                ? p.value.includes(get(x, p.key))
-                : p.t === "not-in"
-                ? !p.value.includes(get(x, p.key))
-                : p.t === "not-eq"
-                ? p.key.includes(".-1.")
-                  ? (get(x, p.key.split(".-1.")[0]) as any[])
-                    // TODO: or vs and
-                    .every(_ => !compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
-                  : !compareCaseInsensitive(get(x, p.key), p.value)
-                : p.key.includes(".-1.")
-                ? (get(x, p.key.split(".-1.")[0]) as any[])
-                  // TODO: or vs and
-                  .some(_ => compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
-                : compareCaseInsensitive(get(x, p.key), p.value)
-            )
+      // TODO: support mixed or/and
+      : filter.mode === "or"
+      ? filter.where
+          .some(p =>
+            p.t === "in"
+              ? p.value.includes(get(x, p.key))
+              : p.t === "not-in"
+              ? !p.value.includes(get(x, p.key))
+              : p.t === "not-eq"
+              ? !compareCaseInsensitive(get(x, p.key), p.value)
+              : compareCaseInsensitive(get(x, p.key), p.value)
+          )
         ? Opt(x as unknown as NE)
         : Opt.none
+      : filter.where
+          .every(p =>
+            p.t === "in"
+              ? p.value.includes(get(x, p.key))
+              : p.t === "not-in"
+              ? !p.value.includes(get(x, p.key))
+              : p.t === "not-eq"
+              ? p.key.includes(".-1.")
+                ? (get(x, p.key.split(".-1.")[0]) as any[])
+                  // TODO: or vs and
+                  .every(_ => !compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
+                : !compareCaseInsensitive(get(x, p.key), p.value)
+              : p.key.includes(".-1.")
+              ? (get(x, p.key.split(".-1.")[0]) as any[])
+                // TODO: or vs and
+                .some(_ => compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
+              : compareCaseInsensitive(get(x, p.key), p.value)
+          )
+      ? Opt(x as unknown as NE)
+      : Opt.none
 }
 
 export function codeFilterJoinSelect<E extends { id: string }, NE>(

package/_src/services/simpledb/memdb.ts

@@ -44,7 +44,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
           const cr = { data: JSON.parse(sdb.data) as EA, version: sdb.version }
           const r = yield* $(
             decode(cr.data).flatMap(d =>
-              eq(d as unknown as V)(keys)
+              eq(keys, d as unknown as V)
                 ? Effect(d)
                 : Effect.fail("not equals")
             ).exit

package/_src/services/simpledb/simpledb.ts

@@ -30,12 +30,11 @@ export const RecordCache = Tag<RecordCache>()
 
 export const LiveRecordCache = Effect(makeLiveRecordCache()).toLayer(RecordCache)
 
-const getM = <T>(type: string) =>
-  <R, E, A>(eff: (m: EffectMap<string, CachedRecord<T>>) => Effect<R, E, A>) =>
-    Effect.gen(function*($) {
-      const { get } = yield* $(RecordCache.access)
-      return yield* $(get<T>(type).flatMap(eff))
-    })
+const getM = <T>(type: string) => <R, E, A>(eff: (m: EffectMap<string, CachedRecord<T>>) => Effect<R, E, A>) =>
+  Effect.gen(function*($) {
+    const { get } = yield* $(RecordCache.access)
+    return yield* $(get<T>(type).flatMap(eff))
+  })
 
 export function find<R, RDecode, EDecode, E, EA, A>(
   tryRead: (id: string) => Effect<R, E, Opt<CachedRecord<EA>>>,