@effect-app/infra 2.10.0 → 2.12.0

package/src/Store/Cosmos.ts

@@ -7,10 +7,21 @@ import { dropUndefinedT } from "effect-app/utils"
 import { CosmosClient, CosmosClientLayer } from "../adapters/cosmos-client.js"
 import { OptimisticConcurrencyException } from "../errors.js"
 import { InfraLogger } from "../logger.js"
+import type { FieldValues } from "../Model/filter/types.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
 import type { FilterArgs, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 
+const makeMapId =
+  <IdKey extends keyof Encoded, Encoded extends FieldValues>(idKey: IdKey) => ({ [idKey]: id, ...e }: Encoded) => ({
+    ...e,
+    id
+  })
+const makeReverseMapId =
+  <IdKey extends keyof Encoded, Encoded extends FieldValues>(idKey: IdKey) =>
+  ({ id, ...t }: PersistenceModelType<Omit<Encoded, IdKey> & { id: string }>) =>
+    ({ ...t, [idKey]: id }) as any as PersistenceModelType<Encoded>
+
 class CosmosDbOperationError {
   constructor(readonly message: string) {}
 } // TODO: Retry operation when running into RU limit.
@@ -19,13 +30,17 @@ function makeCosmosStore({ prefix }: StorageConfig) {
   return Effect.gen(function*() {
     const { db } = yield* CosmosClient
     return {
-      make: <Id extends string, Encoded extends Record<string, any> & { id: Id }, 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.gen(function*() {
+          const mapId = makeMapId<IdKey, Encoded>(idKey)
+          const mapReverseId = makeReverseMapId<IdKey, Encoded>(idKey)
           type PM = PersistenceModelType<Encoded>
+          type PMCosmos = PersistenceModelType<Omit<Encoded, IdKey> & { id: string }>
           const containerId = `${prefix}${name}`
           yield* Effect.promise(() =>
             db.containers.createIfNotExists(dropUndefinedT({
@@ -47,34 +62,37 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               .gen(function*() {
                 // TODO: disable batching if need atomicity
                 // we delay and batch to keep low amount of RUs
-                const b = [...items].map(
-                  (x) =>
-                    [
-                      x,
-                      Option.match(Option.fromNullable(x._etag), {
-                        onNone: () =>
-                          dropUndefinedT({
-                            operationType: "Create" as const,
-                            resourceBody: {
-                              ...Struct.omit(x, "_etag"),
-                              _partitionKey: config?.partitionValue(x)
-                            },
-                            partitionKey: config?.partitionValue(x)
-                          }),
-                        onSome: (eTag) =>
-                          dropUndefinedT({
-                            operationType: "Replace" as const,
-                            id: x.id,
-                            resourceBody: {
-                              ...Struct.omit(x, "_etag"),
-                              _partitionKey: config?.partitionValue(x)
-                            },
-                            ifMatch: eTag,
-                            partitionKey: config?.partitionValue(x)
-                          })
-                      })
-                    ] as const
-                )
+                const b = [...items]
+                  .map(
+                    (x) =>
+                      [
+                        x,
+                        Option.match(Option.fromNullable(x._etag), {
+                          onNone: () =>
+                            dropUndefinedT({
+                              operationType: "Create" as const,
+                              resourceBody: {
+                                ...Struct.omit(x, "_etag", idKey),
+                                id: x[idKey],
+                                _partitionKey: config?.partitionValue(x)
+                              },
+                              partitionKey: config?.partitionValue(x)
+                            }),
+                          onSome: (eTag) =>
+                            dropUndefinedT({
+                              operationType: "Replace" as const,
+                              id: x[idKey],
+                              resourceBody: {
+                                ...Struct.omit(x, "_etag", idKey),
+                                id: x[idKey],
+                                _partitionKey: config?.partitionValue(x)
+                              },
+                              ifMatch: eTag,
+                              partitionKey: config?.partitionValue(x)
+                            })
+                        })
+                      ] as const
+                  )
                 const batches = Chunk.toReadonlyArray(Array.chunk_(b, config?.maxBulkSize ?? 10))
 
                 const batchResult = yield* Effect.forEach(
@@ -135,15 +153,17 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         onNone: () => ({
                           operationType: "Create" as const,
                           resourceBody: {
-                            ...Struct.omit(x, "_etag"),
+                            ...Struct.omit(x, "_etag", idKey),
+                            id: x[idKey],
                             _partitionKey: config?.partitionValue(x)
                           }
                         }),
                         onSome: (eTag) => ({
                           operationType: "Replace" as const,
-                          id: x.id,
+                          id: x[idKey],
                           resourceBody: {
-                            ...Struct.omit(x, "_etag"),
+                            ...Struct.omit(x, "_etag", idKey),
+                            id: x[idKey],
                             _partitionKey: config?.partitionValue(x)
                           },
                           ifMatch: eTag
@@ -173,8 +193,9 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         )
                       }
 
-                      return batch.map(([e], i) => ({
+                      return batch.map(([{ id, ...e }], i) => ({
                         ...e,
+                        [idKey]: id,
                         _etag: result[i]?.eTag
                       })) as unknown as NonEmptyReadonlyArray<Encoded>
                     })
@@ -187,7 +208,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 }))
           }
 
-          const s: Store<Encoded, Id> = {
+          const s: Store<IdKey, Encoded> = {
             all: Effect
               .sync(() => ({
                 query: `SELECT * FROM ${name} f WHERE f.id != @id`,
@@ -199,9 +220,13 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect.promise(() =>
                     container
                       .items
-                      .query<PM>(q)
+                      .query<PMCosmos>(q)
                       .fetchAll()
-                      .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
+                      .then(({ resources }) =>
+                        resources.map(
+                          (_) => ({ ...defaultValues, ...mapReverseId(_) })
+                        )
+                      )
                   )
                 ),
                 Effect
@@ -223,6 +248,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               return Effect
                 .sync(() =>
                   buildWhereCosmosQuery3(
+                    idKey,
                     filter ?? [],
                     name,
                     importedMarkerId,
@@ -244,13 +270,20 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             .query<M>(q)
                             .fetchAll()
                             .then(({ resources }) =>
-                              resources.map((_) => ({ ...pipe(defaultValues, Struct.pick(...f.select!)), ..._ }))
+                              resources.map((_) =>
+                                ({
+                                  ...pipe(defaultValues, Struct.pick(...f.select!)),
+                                  ...mapReverseId(_ as any)
+                                }) as any
+                              )
                             )
                           : container
                             .items
                             .query<{ f: M }>(q)
                             .fetchAll()
-                            .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
+                            .then(({ resources }) =>
+                              resources.map(({ f }) => ({ ...defaultValues, ...mapReverseId(f as any) }) as any)
+                            )
                       )
                     )
                 )
@@ -263,10 +296,10 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               Effect
                 .promise(() =>
                   container
-                    .item(id, config?.partitionValue({ id } as Encoded))
+                    .item(id, config?.partitionValue({ [idKey]: id } as Encoded))
                     .read<Encoded>()
                     .then(({ resource }) =>
-                      Option.fromNullable(resource).pipe(Option.map((_) => ({ ...defaultValues, ..._ })))
+                      Option.fromNullable(resource).pipe(Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) })))
                     )
                 )
                 .pipe(Effect
@@ -275,7 +308,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     attributes: {
                       "repository.container_id": containerId,
                       "repository.model_name": name,
-                      partitionValue: config?.partitionValue({ id } as Encoded),
+                      partitionValue: config?.partitionValue({ [idKey]: id } as Encoded),
                       id
                     }
                   })),
@@ -288,14 +321,14 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     onNone: () =>
                       Effect.promise(() =>
                         container.items.create({
-                          ...e,
+                          ...mapId(e),
                           _partitionKey: config?.partitionValue(e)
                         })
                       ),
                     onSome: (eTag) =>
                       Effect.promise(() =>
-                        container.item(e.id, config?.partitionValue(e)).replace(
-                          { ...e, _partitionKey: config?.partitionValue(e) },
+                        container.item(e[idKey], config?.partitionValue(e)).replace(
+                          { ...mapId(e), _partitionKey: config?.partitionValue(e) },
                           {
                             accessCondition: {
                               type: "IfMatch",
@@ -310,7 +343,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .flatMap((x) => {
                       if (x.statusCode === 412 || x.statusCode === 404) {
-                        return new OptimisticConcurrencyException({ type: name, id: e.id })
+                        return new OptimisticConcurrencyException({ type: name, id: e[idKey] })
                       }
                       if (x.statusCode > 299 || x.statusCode < 200) {
                         return Effect.die(
@@ -327,18 +360,22 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .withSpan("Cosmos.set [effect-app/infra/Store]", {
                       captureStackTrace: false,
-                      attributes: { "repository.container_id": containerId, "repository.model_name": name, id: e.id }
+                      attributes: {
+                        "repository.container_id": containerId,
+                        "repository.model_name": name,
+                        id: e[idKey]
+                      }
                     })
                 ),
             batchSet,
             bulkSet,
             remove: (e: Encoded) =>
               Effect
-                .promise(() => container.item(e.id, config?.partitionValue(e)).delete())
+                .promise(() => container.item(e[idKey], config?.partitionValue(e)).delete())
                 .pipe(Effect
                   .withSpan("Cosmos.remove [effect-app/infra/Store]", {
                     captureStackTrace: false,
-                    attributes: { "repository.container_id": containerId, "repository.model_name": name, id: e.id }
+                    attributes: { "repository.container_id": containerId, "repository.model_name": name, id: e[idKey] }
                   }))
           }
 

package/src/Store/Disk.ts

@@ -4,12 +4,14 @@ import * as fu from "../fileUtil.js"
 import fs from "fs"
 
 import { Console, Effect, FiberRef, flow } from "effect-app"
+import type { FieldValues } from "../Model/filter/types.js"
 import { makeMemoryStoreInt, storeId } from "./Memory.js"
 import type { PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
 
-function makeDiskStoreInt<Id extends string, Encoded extends { id: Id }, R, E>(
+function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
   prefix: string,
+  idKey: IdKey,
   namespace: string,
   dir: string,
   name: string,
@@ -68,8 +70,9 @@ function makeDiskStoreInt<Id extends string, Encoded extends { id: Id }, R, E>(
           )
     }
 
-    const store = yield* makeMemoryStoreInt<Id, Encoded, R, E>(
+    const store = yield* makeMemoryStoreInt<IdKey, Encoded, R, E>(
       name,
+      idKey,
       namespace,
       !fs.existsSync(file)
         ? seed
@@ -107,7 +110,7 @@ function makeDiskStoreInt<Id extends string, Encoded extends { id: Id }, R, E>(
         store.remove,
         Effect.tap(flushToDiskInBackground)
       )
-    } satisfies Store<Encoded, Id>
+    } satisfies Store<IdKey, Encoded>
   })
 }
 
@@ -121,15 +124,16 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
       fs.mkdirSync(dir)
     }
     return {
-      make: <Id extends string, Encoded extends { id: Id }, R, E>(
+      make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
         name: string,
+        idKey: IdKey,
         seed?: Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) =>
         Effect.gen(function*() {
           const storesSem = Effect.unsafeMakeSemaphore(1)
-          const primary = yield* makeDiskStoreInt(prefix, "primary", dir, name, seed, config?.defaultValues)
-          const stores = new Map<string, Store<Encoded, Id>>([["primary", primary]])
+          const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues)
+          const stores = new Map<string, Store<IdKey, Encoded>>([["primary", primary]])
           const ctx = yield* Effect.context<R>()
           const getStore = !config?.allowNamespace
             ? Effect.succeed(primary)
@@ -145,7 +149,15 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
                 Effect.suspend(() => {
                   const existing = stores.get(namespace)
                   if (existing) return Effect.sync(() => existing)
-                  return makeDiskStoreInt<Id, Encoded, R, E>(prefix, namespace, dir, name, seed, config?.defaultValues)
+                  return makeDiskStoreInt<IdKey, Encoded, R, E>(
+                    prefix,
+                    idKey,
+                    namespace,
+                    dir,
+                    name,
+                    seed,
+                    config?.defaultValues
+                  )
                     .pipe(
                       Effect.orDie,
                       Effect.provide(ctx),
@@ -155,7 +167,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
               )
             }))
 
-          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/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
         })