@effect-app/infra 2.11.0 → 2.12.0

package/src/Store/Memory.ts

@@ -5,12 +5,13 @@ import type { NonEmptyReadonlyArray } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { get } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
+import type { FieldValues } from "../Model/filter/types.js"
 import { codeFilter } from "./codeFilter.js"
 import type { FilterArgs, PersistenceModelType, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
 import { makeUpdateETag } from "./utils.js"
 
-export function memFilter<T extends { id: string }, U extends keyof T = never>(f: FilterArgs<T, U>) {
+export function memFilter<T extends FieldValues, U extends keyof T = never>(f: FilterArgs<T, U>) {
   type M = U extends undefined ? T : Pick<T, U>
   return ((c: T[]): M[] => {
     const select = (r: T[]): M[] => (f.select ? r.map(Struct.pick(...f.select)) : r) as any
@@ -76,8 +77,9 @@ function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
     }))
 }
 
-export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }, R = never, E = never>(
+export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
   modelName: string,
+  idKey: IdKey,
   namespace: string,
   seed?: Effect<Iterable<Encoded>, E, R>,
   _defaultValues?: Partial<Encoded>
@@ -88,8 +90,8 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
     const items_ = yield* seed ?? Effect.sync(() => [])
     const defaultValues = _defaultValues ?? {}
 
-    const items = new Map([...items_].map((_) => [_.id, { _etag: undefined, ...defaultValues, ..._ }] as const))
-    const store = Ref.unsafeMake<ReadonlyMap<Id, PM>>(items)
+    const items = new Map([...items_].map((_) => [_[idKey], { _etag: undefined, ...defaultValues, ..._ }] as const))
+    const store = Ref.unsafeMake<ReadonlyMap<string, PM>>(items)
     const sem = Effect.unsafeMakeSemaphore(1)
     const withPermit = sem.withPermits(1)
     const values = Effect.map(Ref.get(store), (s) => s.values())
@@ -98,7 +100,7 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
 
     const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
       Effect
-        .forEach(items, (i) => Effect.flatMap(s.find(i.id), (current) => updateETag(i, current)))
+        .forEach(items, (i) => Effect.flatMap(s.find(i[idKey]), (current) => updateETag(i, idKey, current)))
         .pipe(
           Effect
             .tap((items) =>
@@ -107,8 +109,8 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
                 .pipe(
                   Effect
                     .map((m) => {
-                      const mut = m as Map<Id, PM>
-                      items.forEach((e) => mut.set(e.id, e))
+                      const mut = m as Map<string, PM>
+                      items.forEach((e) => mut.set(e[idKey], e))
                       return mut
                     }),
                   Effect
@@ -119,7 +121,7 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
             .map((_) => _),
           withPermit
         )
-    const s: Store<Encoded, Id> = {
+    const s: Store<IdKey, Encoded> = {
       all: all.pipe(Effect.withSpan("Memory.all [effect-app/infra/Store]", {
         captureStackTrace: false,
         attributes: {
@@ -153,13 +155,13 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
           ),
       set: (e) =>
         s
-          .find(e.id)
+          .find(e[idKey])
           .pipe(
-            Effect.flatMap((current) => updateETag(e, current)),
+            Effect.flatMap((current) => updateETag(e, idKey, current)),
             Effect
               .tap((e) =>
                 Ref.get(store).pipe(
-                  Effect.map((_) => new Map([..._, [e.id, e]])),
+                  Effect.map((_) => new Map([..._, [e[idKey], e]])),
                   Effect.flatMap((_) => Ref.set(store, _))
                 )
               ),
@@ -197,7 +199,7 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
         Ref
           .get(store)
           .pipe(
-            Effect.map((_) => new Map([..._].filter(([_]) => _ !== e.id))),
+            Effect.map((_) => new Map([..._].filter(([_]) => _ !== e[idKey]))),
             Effect.flatMap((_) => Ref.set(store, _)),
             withPermit,
             Effect.withSpan("Memory.remove [effect-app/infra/Store]", {
@@ -211,14 +213,21 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
 }
 
 export const makeMemoryStore = () => ({
-  make: <Id extends string, Encoded extends { id: Id }, R = never, E = never>(
+  make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
     modelName: string,
+    idKey: IdKey,
     seed?: Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
   ) =>
     Effect.gen(function*() {
       const storesSem = Effect.unsafeMakeSemaphore(1)
-      const primary = yield* makeMemoryStoreInt<Id, Encoded, R, E>(modelName, "primary", seed, config?.defaultValues)
+      const primary = yield* makeMemoryStoreInt<IdKey, Encoded, R, E>(
+        modelName,
+        idKey,
+        "primary",
+        seed,
+        config?.defaultValues
+      )
       const ctx = yield* Effect.context<R>()
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace
@@ -234,7 +243,7 @@ export const makeMemoryStore = () => ({
           return storesSem.withPermits(1)(Effect.suspend(() => {
             const store = stores.get(namespace)
             if (store) return Effect.sync(() => store)
-            return makeMemoryStoreInt(modelName, namespace, seed, config?.defaultValues)
+            return makeMemoryStoreInt(modelName, idKey, namespace, seed, config?.defaultValues)
               .pipe(
                 Effect.orDie,
                 Effect.provide(ctx),
@@ -242,7 +251,7 @@ export const makeMemoryStore = () => ({
               )
           }))
         }))
-      const s: Store<Encoded, Id> = {
+      const s: Store<IdKey, Encoded> = {
         all: Effect.flatMap(getStore, (_) => _.all),
         find: (...args) => Effect.flatMap(getStore, (_) => _.find(...args)),
         filter: (...args) => Effect.flatMap(getStore, (_) => _.filter(...args)),

package/src/Store/codeFilter.ts

@@ -3,6 +3,7 @@
 import { Array, Option } from "effect-app"
 import { assertUnreachable, get } from "effect-app/utils"
 import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
+import type { FieldValues } from "../Model/filter/types.js"
 import type { Filter } from "./service.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
 
@@ -120,6 +121,6 @@ export const codeFilter3_ = <E>(state: readonly FilterResult[], sut: E): boolean
   return eval(s)
 }
 
-export function codeFilter<E extends { id: string }, NE extends E>(filter: Filter) {
+export function codeFilter<E extends FieldValues, NE extends E>(filter: Filter) {
   return (x: E) => codeFilter3_(filter, x) ? Option.some(x as unknown as NE) : Option.none()
 }

package/src/Store/service.ts

@@ -57,7 +57,7 @@ export interface O<TFieldValues extends FieldValues> {
   direction: "ASC" | "DESC"
 }
 
-export interface FilterArgs<Encoded extends { id: string }, U extends keyof Encoded = never> {
+export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded = never> {
   t: Encoded
   filter?: Filter | undefined
   select?: NonEmptyReadonlyArray<U> | undefined
@@ -66,18 +66,18 @@ export interface FilterArgs<Encoded extends { id: string }, U extends keyof Enco
   skip?: number | undefined
 }
 
-export type FilterFunc<Encoded extends { id: string }> = <U extends keyof Encoded = never>(
+export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
   args: FilterArgs<Encoded, U>
 ) => Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
 
 export interface Store<
-  Encoded extends { id: Id },
-  Id extends string,
+  IdKey extends keyof Encoded,
+  Encoded extends FieldValues,
   PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
 > {
   all: Effect<PM[]>
   filter: FilterFunc<Encoded>
-  find: (id: Id) => Effect<Option<PM>>
+  find: (id: Encoded[IdKey]) => Effect<Option<PM>>
   set: (e: PM) => Effect<PM, OptimisticConcurrencyException>
   batchSet: (
     items: NonEmptyReadonlyArray<PM>
@@ -96,11 +96,12 @@ export interface Store<
  * @tsplus companion StoreMaker.Ops
  */
 export class StoreMaker extends Context.TagId("effect-app/StoreMaker")<StoreMaker, {
-  make: <Encoded extends { id: Id }, Id extends string, R = never, E = never>(
+  make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
+    idKey: IdKey,
     seed?: Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
-  ) => Effect<Store<Encoded, Id>, E, R>
+  ) => Effect<Store<IdKey, Encoded>, E, R>
 }>() {
 }
 

package/src/Store/utils.ts

@@ -13,18 +13,19 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
   }) as any
 
 export const makeUpdateETag =
-  (type: string) => <E extends PersistenceModelType<{ id: string }>>(e: E, current: Option<E>) =>
+  (type: string) =>
+  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option<E>) =>
     Effect.gen(function*() {
       if (e._etag) {
         yield* Effect.mapError(
           current,
-          () => new OptimisticConcurrencyException({ type, id: e.id, current: "", found: e._etag })
+          () => new OptimisticConcurrencyException({ type, id: e[idKey] as string, current: "", found: e._etag })
         )
       }
       if (Option.isSome(current) && current.value._etag !== e._etag) {
         return yield* new OptimisticConcurrencyException({
           type,
-          id: current.value.id,
+          id: current.value[idKey] as string,
           current: current.value._etag,
           found: e._etag
         })