Function makeMemoryStoreInt

packages/infra/src/Store/Memory.ts:330–512

(
  modelName: string,
  idKey: IdKey,
  namespace: string,
  seed?: Effect.Effect<Iterable<Encoded>, E, R>,
  _defaultValues?: Partial<Encoded>
)

}

export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
  modelName: string,
  idKey: IdKey,
  namespace: string,
  seed?: Effect.Effect<Iterable<Encoded>, E, R>,
  _defaultValues?: Partial<Encoded>
) {
  type PM = PersistenceModelType<Encoded>
  return Effect.gen(function*() {
    const updateETag = makeUpdateETag(modelName)
    const items_ = yield* seed ?? Effect.sync(() => [])
    const defaultValues = _defaultValues ?? {}

    const items = new Map([...items_].map((_) => [_[idKey], { _etag: undefined, ...defaultValues, ..._ }] as const))
    const store = Ref.makeUnsafe<ReadonlyMap<Encoded[IdKey], PM>>(items)
    const sem = Semaphore.makeUnsafe(1)
    const withPermit = sem.withPermits(1)
    const values = Effect.map(Ref.get(store), (s) => s.values())

    const all = Effect.map(values, Array.fromIterable)

    const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
      Effect
        .forEach(items, (i) => Effect.flatMap(s.find(i[idKey]), (current) => updateETag(i, idKey, current)))
        .pipe(
          Effect
            .tap((items) =>
              Ref
                .get(store)
                .pipe(
                  Effect
                    .map((m) => {
                      const mut = m as Map<Encoded[IdKey], PM>
                      items.forEach((e) => mut.set(e[idKey], e))
                      return mut
                    }),
                  Effect
                    .flatMap((_) => Ref.set(store, _))
                )
            ),
          Effect
            .map((_) => _),
          withPermit
        )

    const batchRemove = (items: NonEmptyReadonlyArray<Encoded[IdKey]>) =>
      Ref
        .get(store)
        .pipe(
          Effect
            .map((m) => {
              return new Map([...m].filter(([_k]) => !items.includes(_k)))
            }),
          Effect
            .flatMap((_) => Ref.set(store, _))
        )
        .pipe(
          withPermit