@effect-app/infra 0.48.0 → 0.49.0

package/_src/services/Store/Disk.ts

@@ -19,9 +19,9 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
     const fsStore = {
       get: fu
         .readTextFile(file)
-        .map(x => JSON.parse(x) as PM[])
+        .map((x) => JSON.parse(x) as PM[])
         .orDie,
-      setRaw: (v: Iterable<PM>) => JSON.stringify([...v], undefined, 2)["|>"](json => fu.writeTextFile(file, json))
+      setRaw: (v: Iterable<PM>) => JSON.stringify([...v], undefined, 2)["|>"]((json) => fu.writeTextFile(file, json))
     }
 
     const store = yield* $(
@@ -42,19 +42,19 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
       ...store,
       batchSet: flow(
         store.batchSet,
-        t => t.tap(() => flushToDisk.tapErrorCause(err => Effect(console.error(err))).forkDaemon)
+        (t) => t.tap(() => flushToDisk.tapErrorCause((err) => Effect(console.error(err))).forkDaemon)
       ),
       bulkSet: flow(
         store.bulkSet,
-        t => t.tap(() => flushToDisk.tapErrorCause(err => Effect(console.error(err))).forkDaemon)
+        (t) => t.tap(() => flushToDisk.tapErrorCause((err) => Effect(console.error(err))).forkDaemon)
       ),
       set: flow(
         store.set,
-        t => t.tap(() => flushToDisk.tapErrorCause(err => Effect(console.error(err))).forkDaemon)
+        (t) => t.tap(() => flushToDisk.tapErrorCause((err) => Effect(console.error(err))).forkDaemon)
       ),
       remove: flow(
         store.remove,
-        t => t.tap(() => flushToDisk.tapErrorCause(err => Effect(console.error(err))).forkDaemon)
+        (t) => t.tap(() => flushToDisk.tapErrorCause((err) => Effect(console.error(err))).forkDaemon)
       )
     } satisfies Store<PM, Id>
   })
@@ -79,7 +79,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
           const storesSem = Semaphore.unsafeMake(1)
           const primary = yield* $(makeDiskStoreInt(prefix, "primary", dir, name, seed))
           const stores = new Map<string, Store<PM, Id>>([["primary", primary]])
-          const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap(namespace => {
+          const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap((namespace) => {
             const store = stores.get(namespace)
             if (store) {
               return Effect.succeed(store)
@@ -91,7 +91,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
               Effect.suspend(() => {
                 const existing = stores.get(namespace)
                 if (existing) return Effect(existing)
-                return makeDiskStoreInt<Id, PM>(prefix, namespace, dir, name, seed).tap(store =>
+                return makeDiskStoreInt<Id, PM>(prefix, namespace, dir, name, seed).tap((store) =>
                   Effect.sync(() => stores.set(namespace, store))
                 )
               })
@@ -99,14 +99,14 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
           })
 
           const s: Store<PM, Id> = {
-            all: getStore.flatMap(_ => _.all),
-            find: (...args) => getStore.flatMap(_ => _.find(...args)),
-            filter: (...args) => getStore.flatMap(_ => _.filter(...args)),
-            filterJoinSelect: (...args) => getStore.flatMap(_ => _.filterJoinSelect(...args)),
-            set: (...args) => getStore.flatMap(_ => _.set(...args)),
-            batchSet: (...args) => getStore.flatMap(_ => _.batchSet(...args)),
-            bulkSet: (...args) => getStore.flatMap(_ => _.bulkSet(...args)),
-            remove: (...args) => getStore.flatMap(_ => _.remove(...args))
+            all: getStore.flatMap((_) => _.all),
+            find: (...args) => getStore.flatMap((_) => _.find(...args)),
+            filter: (...args) => getStore.flatMap((_) => _.filter(...args)),
+            filterJoinSelect: (...args) => getStore.flatMap((_) => _.filterJoinSelect(...args)),
+            set: (...args) => getStore.flatMap((_) => _.set(...args)),
+            batchSet: (...args) => getStore.flatMap((_) => _.batchSet(...args)),
+            bulkSet: (...args) => getStore.flatMap((_) => _.bulkSet(...args)),
+            remove: (...args) => getStore.flatMap((_) => _.remove(...args))
           }
           return s
         })
@@ -115,7 +115,8 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
 }
 
 export function DiskStoreLive(config: Config<StorageConfig>, dir: string) {
-  return config.config
-    .flatMap(_ => makeDiskStore(_, dir))
+  return config
+    .config
+    .flatMap((_) => makeDiskStore(_, dir))
     .toLayer(StoreMaker)
 }

package/_src/services/Store/Memory.ts

@@ -6,11 +6,11 @@ import { StoreMaker } from "./service.js"
 import { codeFilter, codeFilterJoinSelect, makeETag, makeUpdateETag } from "./utils.js"
 
 export function memFilter<T extends { id: string }>(filter: Filter<T>, cursor?: { skip?: number; limit?: number }) {
-  return ((c: Chunk<T>): Chunk<T> => {
+  return ((c: T[]): T[] => {
     const skip = cursor?.skip
     const limit = cursor?.limit
     if (!skip && limit === 1) {
-      return c.findFirstMap(codeFilter(filter)).map(Chunk.make).getOrElse(() => Chunk.empty())
+      return c.findFirstMap(codeFilter(filter)).map(ReadonlyArray.make).getOrElse(() => [])
     }
     let r = c.filterMap(codeFilter(filter))
     if (skip) {
@@ -19,17 +19,18 @@ export function memFilter<T extends { id: string }>(filter: Filter<T>, cursor?:
     if (limit !== undefined) {
       r = r.take(limit)
     }
-    return r.toChunk
+    return r
   })
 }
 
 export const storeId = FiberRef.unsafeMake("primary")
-export const restoreFromRequestContext = RequestContextContainer.get.flatMap(ctx =>
+export const restoreFromRequestContext = RequestContextContainer.get.flatMap((ctx) =>
   storeId.set(ctx.namespace ?? "primary")
 )
 
 function logQuery(filter: any, cursor: any) {
-  return Effect.logDebug("mem query")
+  return Effect
+    .logDebug("mem query")
     .apply(Effect.logAnnotates({
       query: JSON.stringify(filter, undefined, 2),
       cursor: JSON.stringify(
@@ -47,47 +48,51 @@ export function makeMemoryStoreInt<Id extends string, PM extends PersistenceMode
   return Effect.gen(function*($) {
     const updateETag = makeUpdateETag(name)
     const items_ = yield* $(seed ?? Effect([]))
-    const items = new Map(items_.toChunk.map(_ => [_.id, _] as const))
+    const items = new Map(items_.toChunk.map((_) => [_.id, _] as const))
     const makeStore = (): ReadonlyMap<Id, PM> => new Map([...items.entries()].map(([id, e]) => [id, makeETag(e)]))
     const store = Ref.unsafeMake(makeStore())
     const sem = Semaphore.unsafeMake(1)
     const withPermit = sem.withPermits(1)
-    const values = store.get.map(s => s.values())
-    const all = values.map(Chunk.fromIterable)
+    const values = store.get.map((s) => s.values())
+    const all = values.map(ReadonlyArray.fromIterable)
     const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
       items
-        .forEachEffect(i => s.find(i.id).flatMap(current => updateETag(i, current)))
-        .tap(items =>
-          store.get
-            .map(m => {
+        .forEachEffect((i) => s.find(i.id).flatMap((current) => updateETag(i, current)))
+        .tap((items) =>
+          store
+            .get
+            .map((m) => {
               const mut = m as Map<Id, PM>
-              items.forEach(e => mut.set(e.id, e))
+              items.forEach((e) => mut.set(e.id, e))
               return mut
             })
-            .flatMap(_ => store.set(_))
+            .flatMap((_) => store.set(_))
         )
-        .map(_ => _.toReadonlyArray as NonEmptyReadonlyArray<PM>)
+        .map((_) => _ as NonEmptyArray<PM>)
         .apply(withPermit)
     const s: Store<PM, Id> = {
       all,
-      find: id => store.get.map(_ => Option.fromNullable(_.get(id))),
+      find: (id) => store.get.map((_) => Option.fromNullable(_.get(id))),
       filter: (filter: Filter<PM>, cursor?: { skip?: number; limit?: number }) =>
         all
           .tap(() => logQuery(filter, cursor))
           .map(memFilter(filter, cursor)),
       filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
-        all.map(c => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
-      set: e =>
+        all.map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
+      set: (e) =>
         s
           .find(e.id)
-          .flatMap(current => updateETag(e, current))
-          .tap(e => store.get.map(_ => new Map([..._, [e.id, e]])).flatMap(_ => store.set(_)))
+          .flatMap((current) => updateETag(e, current))
+          .tap((e) => store.get.map((_) => new Map([..._, [e.id, e]])).flatMap((_) => store.set(_)))
           .apply(withPermit),
       batchSet,
       bulkSet: batchSet,
       remove: (e: PM) =>
-        store.get.map(_ => new Map([..._].filter(([_]) => _ !== e.id)))
-          .flatMap(_ => store.set(_)).apply(withPermit)
+        store
+          .get
+          .map((_) => new Map([..._].filter(([_]) => _ !== e.id)))
+          .flatMap((_) => store.set(_))
+          .apply(withPermit)
     }
     return s
   })
@@ -103,7 +108,7 @@ export const makeMemoryStore = () => ({
       const storesSem = Semaphore.unsafeMake(1)
       const primary = yield* $(makeMemoryStoreInt<Id, PM>(name, seed))
       const stores = new Map([["primary", primary]])
-      const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap(namespace => {
+      const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap((namespace) => {
         const store = stores.get(namespace)
         if (store) {
           return Effect.succeed(store)
@@ -114,18 +119,18 @@ export const makeMemoryStore = () => ({
         return storesSem.withPermits(1)(Effect.suspend(() => {
           const store = stores.get(namespace)
           if (store) return Effect(store)
-          return makeMemoryStoreInt(name, seed).tap(store => Effect.sync(() => stores.set(namespace, store)))
+          return makeMemoryStoreInt(name, seed).tap((store) => Effect.sync(() => stores.set(namespace, store)))
         }))
       })
       const s: Store<PM, Id> = {
-        all: getStore.flatMap(_ => _.all),
-        find: (...args) => getStore.flatMap(_ => _.find(...args)),
-        filter: (...args) => getStore.flatMap(_ => _.filter(...args)),
-        filterJoinSelect: (...args) => getStore.flatMap(_ => _.filterJoinSelect(...args)),
-        set: (...args) => getStore.flatMap(_ => _.set(...args)),
-        batchSet: (...args) => getStore.flatMap(_ => _.batchSet(...args)),
-        bulkSet: (...args) => getStore.flatMap(_ => _.bulkSet(...args)),
-        remove: (...args) => getStore.flatMap(_ => _.remove(...args))
+        all: getStore.flatMap((_) => _.all),
+        find: (...args) => getStore.flatMap((_) => _.find(...args)),
+        filter: (...args) => getStore.flatMap((_) => _.filter(...args)),
+        filterJoinSelect: (...args) => getStore.flatMap((_) => _.filterJoinSelect(...args)),
+        set: (...args) => getStore.flatMap((_) => _.set(...args)),
+        batchSet: (...args) => getStore.flatMap((_) => _.batchSet(...args)),
+        bulkSet: (...args) => getStore.flatMap((_) => _.bulkSet(...args)),
+        remove: (...args) => getStore.flatMap((_) => _.remove(...args))
       }
       return s
     })

package/_src/services/Store/Redis.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as RedisClient from "@effect-app/infra-adapters/redis-client"
+import { RedisClient } from "@effect-app/infra-adapters/redis-client"
 import { NotFoundError } from "../../errors.js"
 import { memFilter } from "./Memory.js"
 
@@ -9,7 +9,7 @@ import { codeFilterJoinSelect, makeETag, makeUpdateETag } from "./utils.js"
 
 export function makeRedisStore({ prefix }: StorageConfig) {
   return Effect.gen(function*($) {
-    const redis = yield* $(RedisClient.RedisClient)
+    const redis = yield* $(RedisClient)
     return {
       make: <Id extends string, PM extends PersistenceModelType<Id>>(
         name: string,
@@ -20,65 +20,69 @@ export function makeRedisStore({ prefix }: StorageConfig) {
           const updateETag = makeUpdateETag(name)
           // Very naive implementation of course.
           const key = `${prefix}${name}`
-          const current = yield* $(RedisClient.get(key).orDie.provideService(RedisClient.RedisClient, redis))
+          const current = yield* $(redis.get(key).orDie.provideService(RedisClient, redis))
           if (!current.isSome()) {
             const m = yield* $(seed ?? Effect([]))
             yield* $(
-              RedisClient.set(key, JSON.stringify({ data: [...m].map(e => makeETag(e)) }))
+              redis
+                .set(key, JSON.stringify({ data: [...m].map((e) => makeETag(e)) }))
                 .orDie
-                .provideService(RedisClient.RedisClient, redis)
+                .provideService(RedisClient, redis)
             )
           }
-          const get = RedisClient.get(key)
-            .flatMap(x => x.encaseInEffect(() => new NotFoundError("data", "")))
+          const get = redis
+            .get(key)
+            .flatMap((x) => x.encaseInEffect(() => new NotFoundError("data", "")))
             .orDie
-            .map(x => JSON.parse(x) as { data: readonly PM[] })
-            .map(_ => _.data)
-            .provideService(RedisClient.RedisClient, redis)
+            .map((x) => JSON.parse(x) as { data: readonly PM[] })
+            .map((_) => _.data)
+            .provideService(RedisClient, redis)
 
-          const set = (i: ReadonlyMap<Id, PM>) => RedisClient.set(key, JSON.stringify({ data: [...i.values()] })).orDie
+          const set = (i: ReadonlyMap<Id, PM>) => redis.set(key, JSON.stringify({ data: [...i.values()] })).orDie
 
           const sem = Semaphore.unsafeMake(1)
           const withPermit = sem.withPermits(1)
 
-          const asMap = get.map(x => new Map(x.map(x => [x.id, x] as const)))
-          const all = get.map(Chunk.fromIterable)
+          const asMap = get.map((x) => new Map(x.map((x) => [x.id, x] as const)))
+          const all = get.map(ReadonlyArray.fromIterable)
           const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
             items
-              .forEachEffect(e => s.find(e.id).flatMap(current => updateETag(e, current)))
-              .tap(items =>
+              .forEachEffect((e) => s.find(e.id).flatMap((current) => updateETag(e, current)))
+              .tap((items) =>
                 asMap
-                  .map(m => {
+                  .map((m) => {
                     const mut = m
-                    items.forEach(e => mut.set(e.id, e))
+                    items.forEach((e) => mut.set(e.id, e))
                     return mut
                   })
                   .flatMap(set)
               )
-              .map(_ => _.toReadonlyArray as NonEmptyReadonlyArray<PM>)
+              .map((_) => _ as NonEmptyArray<PM>)
               .apply(withPermit)
-              .provideService(RedisClient.RedisClient, redis)
+              .provideService(RedisClient, redis)
           const s: Store<PM, Id> = {
             all,
             filter: (filter: Filter<PM>, cursor?: { skip?: number; limit?: number }) =>
               all.map(memFilter(filter, cursor)),
             filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
-              all.map(c => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
-            find: id => asMap.map(_ => Option.fromNullable(_.get(id))),
-            set: e =>
+              all.map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
+            find: (id) => asMap.map((_) => Option.fromNullable(_.get(id))),
+            set: (e) =>
               s
                 .find(e.id)
-                .flatMap(current => updateETag(e, current))
-                .tap(e => asMap.map(_ => new Map([..._, [e.id, e]])).flatMap(set))
+                .flatMap((current) => updateETag(e, current))
+                .tap((e) => asMap.map((_) => new Map([..._, [e.id, e]])).flatMap(set))
                 .apply(withPermit)
-                .provideService(RedisClient.RedisClient, redis),
+                .provideService(RedisClient, redis),
             batchSet,
             bulkSet: batchSet,
             remove: (e: PM) =>
-              asMap.map(_ => new Map([..._].filter(([_]) => _ !== e.id))).flatMap(set)
+              asMap
+                .map((_) => new Map([..._].filter(([_]) => _ !== e.id)))
+                .flatMap(set)
                 .apply(withPermit)
                 .provideService(
-                  RedisClient.RedisClient,
+                  RedisClient,
                   redis
                 )
           }

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

@@ -20,7 +20,7 @@ export function somethingsWhere(
   ) => Where | [Where, ...Where[]],
   mode?: "or" | "and"
 ) {
-  return makeSomethingFilter_(f => {
+  return makeSomethingFilter_((f) => {
     const m = makeWhere ? makeWhere(f) : []
     return ({
       mode,
@@ -44,37 +44,47 @@ type Something = {
 
 test("works", () => {
   expect(
-    somethings.filterMap(codeFilter(
-      somethingsWhere(_ => _("b", _ => "b2"))
-    )).toArray
+    somethings
+      .filterMap(codeFilter(
+        somethingsWhere((_) => _("b", (_) => "b2"))
+      ))
+      .toArray
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings.filterMap(codeFilter(
-      somethingsWhere(_ => _("b", _ => "b"))
-    )).toArray
+    somethings
+      .filterMap(codeFilter(
+        somethingsWhere((_) => _("b", (_) => "b"))
+      ))
+      .toArray
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings.filterMap(codeFilter(
-      somethingsWhere(_ => _("d.-1.a", _ => "a5"))
-    )).toArray
+    somethings
+      .filterMap(codeFilter(
+        somethingsWhere((_) => _("d.-1.a", (_) => "a5"))
+      ))
+      .toArray
   )
     .toEqual([somethings[1]])
 
   expect(
-    somethings.filterMap(codeFilter(
-      somethingsWhere(_ => _("d.-1.a", _ => "a"))
-    )).toArray
+    somethings
+      .filterMap(codeFilter(
+        somethingsWhere((_) => _("d.-1.a", (_) => "a"))
+      ))
+      .toArray
   )
     .toEqual([somethings[0]])
 
   expect(
-    somethings.filterMap(codeFilter(
-      somethingsWhere(_ => _("d.-1.a", _ => _.$isnt("a")))
-    )).toArray
+    somethings
+      .filterMap(codeFilter(
+        somethingsWhere((_) => _("d.-1.a", (_) => _.$isnt("a")))
+      ))
+      .toArray
   )
     .toEqual([somethings[1]])
 })

package/_src/services/Store/index.ts

@@ -14,32 +14,34 @@ import { StoreMaker } from "./service.js"
  * @tsplus static StoreMaker.Ops Live
  */
 export function StoreMakerLive(config: Config<StorageConfig>) {
-  return config.config.flatMap(cfg => {
-    const storageUrl = cfg.url.value
-    if (storageUrl.startsWith("mem://")) {
-      console.log("Using in memory store")
-      return Effect(makeMemoryStore())
-    }
-    if (storageUrl.startsWith("disk://")) {
-      const dir = storageUrl.replace("disk://", "")
-      console.log("Using disk store at " + dir)
-      return makeDiskStore(cfg, dir)
-    }
-    if (storageUrl.startsWith("redis://")) {
-      console.log("Using Redis store")
-      return RedisClient.makeRedisClient(makeRedis(storageUrl)).flatMap(client =>
-        makeRedisStore(cfg).provideService(
-          RedisClient.RedisClient,
-          client
+  return config
+    .config
+    .flatMap((cfg) => {
+      const storageUrl = cfg.url.value
+      if (storageUrl.startsWith("mem://")) {
+        console.log("Using in memory store")
+        return Effect(makeMemoryStore())
+      }
+      if (storageUrl.startsWith("disk://")) {
+        const dir = storageUrl.replace("disk://", "")
+        console.log("Using disk store at " + dir)
+        return makeDiskStore(cfg, dir)
+      }
+      if (storageUrl.startsWith("redis://")) {
+        console.log("Using Redis store")
+        return RedisClient.makeRedisClient(makeRedis(storageUrl)).flatMap((client) =>
+          makeRedisStore(cfg).provideService(
+            RedisClient.RedisClient,
+            client
+          )
         )
-      )
-    }
+      }
 
-    console.log("Using Cosmos DB store")
-    return CosmosClient.makeCosmosClient(storageUrl, cfg.dbName).flatMap(client =>
-      makeCosmosStore(cfg).provideService(CosmosClient.CosmosClient, client)
-    )
-  })
+      console.log("Using Cosmos DB store")
+      return CosmosClient.makeCosmosClient(storageUrl, cfg.dbName).flatMap((client) =>
+        makeCosmosStore(cfg).provideService(CosmosClient.CosmosClient, client)
+      )
+    })
     .toLayerScoped(StoreMaker)
 }
 

package/_src/services/Store/service.ts

@@ -57,14 +57,14 @@ export type FilterJoinSelect = {
 }
 
 export interface Store<PM extends PersistenceModelType<Id>, Id extends string> {
-  all: Effect<never, never, Chunk<PM>>
+  all: Effect<never, never, PM[]>
   filter: (
     filter: Filter<PM>,
     cursor?: { limit?: number; skip?: number }
-  ) => Effect<never, never, Chunk<PM>>
+  ) => Effect<never, never, PM[]>
   filterJoinSelect: <T extends object>(
     filter: FilterJoinSelect
-  ) => Effect<never, never, Chunk<T & { _rootId: string }>>
+  ) => Effect<never, never, (T & { _rootId: string })[]>
   find: (id: Id) => Effect<never, never, Option<PM>>
   set: (e: PM) => Effect<never, OptimisticConcurrencyException, PM>
   batchSet: (
@@ -124,8 +124,8 @@ export const makeMap = Effect.sync((): ContextMap => {
     // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
     lax: false,
     cache: {
-      getOrSetParser: p => parserCache.get(p) ?? setAndReturn(p, i => parserEnv.cache!.getOrSet(i, p)),
-      getOrSetParsers: parsers => {
+      getOrSetParser: (p) => parserCache.get(p) ?? setAndReturn(p, (i) => parserEnv.cache!.getOrSet(i, p)),
+      getOrSetParsers: (parsers) => {
         return Object.entries(parsers).reduce((prev, [k, v]) => {
           prev[k] = parserEnv.cache!.getOrSetParser(v)
           return prev

package/_src/services/Store/utils.ts

@@ -50,20 +50,21 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
         ? Option(x as unknown as NE)
         : Option.none
       : filter.type === "join_find"
-      ? filter.keys.some(k => {
+      ? filter.keys.some((k) => {
           const value = get(x, k) as Record<string, unknown>[]
           // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
           return (
-            value &&
-            value.some(v => compareCaseInsensitive(v[filter.valueKey], filter.value))
+            value
+            && value.some((v) => compareCaseInsensitive(v[filter.valueKey], filter.value))
           )
         })
         ? Option(x as unknown as NE)
         : Option.none
       // TODO: support mixed or/and
       : filter.mode === "or"
-      ? filter.where
-          .some(p =>
+      ? filter
+          .where
+          .some((p) =>
             p.t === "in"
               ? p.value.includes(get(x, p.key))
               : p.t === "not-in"
@@ -82,8 +83,9 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
           )
         ? Option(x as unknown as NE)
         : Option.none
-      : filter.where
-          .every(p =>
+      : filter
+          .where
+          .every((p) =>
             p.t === "in"
               ? p.value.includes(get(x, p.key))
               : p.t === "not-in"
@@ -100,12 +102,12 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
               ? 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))
+                  .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))
+                .some((_) => compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
               : compareCaseInsensitive(get(x, p.key), p.value)
           )
       ? Option(x as unknown as NE)
@@ -116,22 +118,23 @@ export function codeFilterJoinSelect<E extends { id: string }, NE>(
   filter: FilterJoinSelect
 ) {
   return (x: E) =>
-    filter.keys.filterMap(k => {
-      const value = get(x, k)
-      // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
-      return value
-        ? Option(
-          (value as readonly NE[]).filterMap(v =>
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            compareCaseInsensitive((v as any)[filter.valueKey], filter.value)
-              ? Option({ ...v, _rootId: x.id })
-              : Option.none
+    filter
+      .keys
+      .filterMap((k) => {
+        const value = get(x, k)
+        // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
+        return value
+          ? Option(
+            (value as readonly NE[]).filterMap((v) =>
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              compareCaseInsensitive((v as any)[filter.valueKey], filter.value)
+                ? Option({ ...v, _rootId: x.id })
+                : Option.none
+            )
           )
-        )
-        : Option.none
-    })
-      .flatMap(_ => _)
-      .toChunk
+          : Option.none
+      })
+      .flatMap((_) => _)
 }
 
 function lowercaseIfString<T>(val: T) {