@effect-app/infra 0.198.2 → 0.199.0

package/src/services/RepositoryBase.ts

@@ -17,11 +17,16 @@ import { StoreMaker } from "./Store.js"
 import type { Filter, FilterArgs, FilterFunc, PersistenceModelType, StoreConfig, Where } from "./Store.js"
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
+import { toNonEmptyArray } from "@effect-app/core/Array"
 import { flatMapOption } from "@effect-app/core/Effect"
-import type { Opt } from "@effect-app/core/Option"
 import { makeFilters } from "@effect-app/infra/filter"
-import { Effect, S } from "effect-app"
-import { type FixEnv, runTerm } from "effect-app/Pure"
+import type { ParseResult, Schema } from "@effect-app/schema"
+import { NonNegativeInt } from "@effect-app/schema"
+import type { Context, NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
+import { Chunk, Effect, flow, Option, pipe, PubSub, ReadonlyArray, S } from "effect-app"
+import { runTerm } from "effect-app/Pure"
+import type { FixEnv, PureEnv } from "effect-app/Pure"
+import { assignTag } from "effect-app/service"
 import { type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../errors.js"
 import type { FieldValues } from "../filter/types.js"
 import { make as makeQuery, type QAll, type Query, query, type QueryProjection } from "./query.js"
@@ -67,7 +72,7 @@ export abstract class RepositoryBaseC<
   ItemType extends string
 > {
   abstract readonly itemType: ItemType
-  abstract readonly find: (id: T["id"]) => Effect<Opt<T>>
+  abstract readonly find: (id: T["id"]) => Effect<Option<T>>
   abstract readonly all: Effect<T[]>
   abstract readonly saveAndPublish: (
     items: Iterable<T>,
@@ -83,7 +88,7 @@ export abstract class RepositoryBaseC<
     filter: FilterFunc<PM>
     // count: (filter?: Filter<PM>) => Effect<never, never, NonNegativeInt>
   }
-  abstract readonly changeFeed: PubSub<[T[], "save" | "remove"]>
+  abstract readonly changeFeed: PubSub.PubSub<[T[], "save" | "remove"]>
   abstract readonly removeAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
@@ -158,15 +163,17 @@ export class RepositoryBaseC3<
   ItemType extends string
 > extends RepositoryBaseC2<T, PM, Evt, ItemType> {
   get(id: T["id"]) {
-    return this
-      .find(id)
-      .flatMap((_) => _.encaseInEffect(() => new NotFoundError<ItemType>({ type: this.itemType, id })))
+    return Effect.andThen(
+      this
+        .find(id),
+      (_) => Effect.mapError(_, () => new NotFoundError<ItemType>({ type: this.itemType, id }))
+    )
   }
 
   readonly log = (evt: Evt) => AnyPureDSL.log(evt)
 
   removeById(id: T["id"]) {
-    return this.get(id).andThen((_) => this.removeAndPublish([_]))
+    return Effect.andThen(this.get(id), (_) => this.removeAndPublish([_]))
   }
 
   // TODO: project inside the db.
@@ -222,12 +229,13 @@ export class RepositoryBaseC3<
     >
   ): Effect<S[], E, R> {
     // TODO: a projection that gets sent to the db instead.
-    return map.flatMap((f) =>
-      this
-        .utils
-        .filter(f)
-        .map((_) => f.collect ? _.filterMap(f.collect) : _ as unknown as S[])
-    )
+    return Effect.flatMap(map, (f) =>
+      Effect.map(
+        this
+          .utils
+          .filter(f),
+        (_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown as S[]
+      ))
   }
 
   project<S = PM>(
@@ -262,9 +270,10 @@ export class RepositoryBaseC3<
   }
 
   count(filter?: Filter<PM>) {
-    return this
-      .projectEffect(Effect.sync(() => ({ filter })))
-      .map((_) => NonNegativeInt(_.length))
+    return Effect.map(
+      this.projectEffect(Effect.sync(() => ({ filter }))),
+      (_) => NonNegativeInt(_.length)
+    )
   }
 
   queryEffect<
@@ -275,11 +284,12 @@ export class RepositoryBaseC3<
     // TODO: think about collectPM, collectE, and collect(Parsed)
     map: Effect<{ filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>
   ) {
-    return map.flatMap((f) =>
+    return Effect.flatMap(map, (f) =>
       (f.filter ? this.utils.filter(f) : this.utils.all)
-        .flatMap((_) => this.utils.parseMany(_))
-        .map((_) => f.collect ? _.filterMap(f.collect) : _ as any as S[])
-    )
+        .pipe(
+          Effect.flatMap((_) => this.utils.parseMany(_)),
+          Effect.map((_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown[] as S[])
+        ))
   }
 
   queryOneEffect<R, E>(
@@ -302,16 +312,23 @@ export class RepositoryBaseC3<
     // TODO: think about collectPM, collectE, and collect(Parsed)
     map: Effect<{ filter?: Filter<PM>; collect?: (t: T) => Option<S> }, E, R>
   ): Effect<S, E | NotFoundError<ItemType>, R> {
-    return map.flatMap((f) =>
+    return Effect.flatMap(map, (f) =>
       (f.filter ? this.utils.filter({ filter: f.filter, limit: 1 }) : this.utils.all)
-        .flatMap((_) => this.utils.parseMany(_))
-        .flatMap((_) =>
-          (f.collect ? _.filterMap(f.collect) : _ as any as S[])
-            .toNonEmpty
-            .encaseInEffect(() => new NotFoundError<ItemType>({ type: this.itemType, id: f.filter }))
-            .map((_) => _[0])
-        )
-    )
+        .pipe(
+          Effect.flatMap((_) => this.utils.parseMany(_)),
+          Effect
+            .flatMap((_) =>
+              toNonEmptyArray(
+                f.collect
+                  ? ReadonlyArray.filterMap(_, f.collect)
+                  : _ as unknown[] as S[]
+              )
+                .pipe(
+                  Effect.mapError(() => new NotFoundError<ItemType>({ type: this.itemType, id: f.filter })),
+                  Effect.map((_) => _[0])
+                )
+            )
+        ))
   }
 
   queryLegacy<S = T>(
@@ -373,9 +390,7 @@ export class RepositoryBaseC3<
   queryAndSaveOnePureEffect(
     map: any
   ) {
-    return (pure: any) =>
-      queryOneEffect(this, map)
-        .flatMap((_) => saveWithPure_(this, _, pure))
+    return (pure: any) => Effect.flatMap(queryOneEffect(this, map), (_) => saveWithPure_(this, _, pure))
   }
 
   queryAndSaveOnePure<
@@ -412,8 +427,7 @@ export class RepositoryBaseC3<
     map: Effect<{ filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>
   ) {
     return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, S[], S2[]>>) =>
-      queryEffect(this, map)
-        .flatMap((_) => this.saveManyWithPure_(_, pure))
+      Effect.flatMap(queryEffect(this, map), (_) => this.saveManyWithPure_(_, pure))
   }
 
   queryAndSavePure<
@@ -451,9 +465,9 @@ export class RepositoryBaseC3<
     }>
   >
   byIdAndSaveWithPure<R, A, E, S2 extends T>(id: T["id"], pure?: Effect<A, E, FixEnv<R, Evt, T, S2>>) {
-    if (pure) return get(this, id).flatMap((item) => saveWithPure_(this, item, pure))
+    if (pure) return get(this, id).pipe(Effect.flatMap((item) => saveWithPure_(this, item, pure)))
     return (pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) =>
-      get(this, id).flatMap((item) => saveWithPure_(this, item, pure))
+      get(this, id).pipe(Effect.flatMap((item) => saveWithPure_(this, item, pure)))
   }
 
   /**
@@ -495,7 +509,7 @@ export class RepositoryBaseC3<
     return saveAllWithEffectInt(
       this,
       runTerm(pure, item)
-        .map(([item, events, a]) => [[item], events, a])
+        .pipe(Effect.map(([item, events, a]) => [[item], events, a]))
     )
   }
 
@@ -507,10 +521,7 @@ export class RepositoryBaseC3<
   >(
     gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
   ) {
-    return gen
-      .flatMap(
-        ([items, events, a]) => this.saveAndPublish(items, events).map(() => a)
-      )
+    return Effect.flatMap(gen, ([items, events, a]) => Effect.map(this.saveAndPublish(items, events), () => a))
   }
 
   queryAndSavePureEffectBatched<
@@ -523,8 +534,7 @@ export class RepositoryBaseC3<
     batchSize = 100
   ) {
     return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, S[], S2[]>>) =>
-      queryEffect(this, map)
-        .flatMap((_) => this.saveManyWithPureBatched_(_, pure, batchSize))
+      Effect.flatMap(queryEffect(this, map), (_) => this.saveManyWithPureBatched_(_, pure, batchSize))
   }
 
   queryAndSavePureBatched<
@@ -553,14 +563,14 @@ export class RepositoryBaseC3<
     pure: Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>,
     batchSize = 100
   ) {
-    return items
-      .chunk(batchSize)
-      .forEachEffect((batch) =>
+    return Effect.forEach(
+      ReadonlyArray.chunk_(items, batchSize),
+      (batch) =>
         saveAllWithEffectInt(
           this,
           runTerm(pure, batch)
         )
-      )
+    )
   }
 
   readonly save = (...items: NonEmptyArray<T>) => this.saveAndPublish(items)
@@ -624,188 +634,214 @@ export function makeRepo<
           }
         }
     ) {
-      return Do(($) => {
-        const rctx = $(Effect.context<R>())
-        const encode = flow(schema.encode, Effect.provide(rctx))
-        const decode = flow(schema.decode, Effect.provide(rctx))
-
-        const store = $(mkStore(args.makeInitial, args.config))
-        const { get } = $(ContextMapContainer)
-        const cms = get.andThen((_) => ({
-          get: (id: string) => _.get(`${name}.${id}`),
-          set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
-        }))
-
-        const pubCfg = $(Effect.context<R2>())
-        const pub = "publishEvents" in args ? flow(args.publishEvents, (_) => _.provide(pubCfg)) : () => Effect.unit
-        const changeFeed = $(PubSub.unbounded<[T[], "save" | "remove"]>())
-
-        const allE = store.all.flatMap((items) =>
-          Do(($) => {
-            const { set } = $(cms)
-            return items.map((_) => mapReverse(_, set))
-          })
-        )
-
-        const all = allE.flatMap((_) =>
-          _.forEachEffect((_) => decode(_), { concurrency: "inherit", batching: true }).orDie
-        )
+      return Effect
+        .gen(function*($) {
+          const rctx = yield* $(Effect.context<R>())
+          const encode = flow(S.encode(schema), Effect.provide(rctx))
+          const decode = flow(S.decode(schema), Effect.provide(rctx))
+
+          const store = yield* $(mkStore(args.makeInitial, args.config))
+          const { get } = yield* $(ContextMapContainer)
+          const cms = Effect.andThen(get, (_) => ({
+            get: (id: string) => _.get(`${name}.${id}`),
+            set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
+          }))
+
+          const pubCfg = yield* $(Effect.context<R2>())
+          const pub = "publishEvents" in args
+            ? flow(args.publishEvents, Effect.provide(pubCfg))
+            : () => Effect.unit
+          const changeFeed = yield* $(PubSub.unbounded<[T[], "save" | "remove"]>())
+
+          const allE = store.all.pipe(Effect.flatMap((items) =>
+            Effect.gen(function*($) {
+              const { set } = yield* $(cms)
+              return items.map((_) => mapReverse(_, set))
+            })
+          ))
+
+          const all = Effect.flatMap(
+            allE,
+            (_) => Effect.forEach(_, (_) => decode(_), { concurrency: "inherit", batching: true }).pipe(Effect.orDie)
+          )
 
-        const structSchema = schema as unknown as { struct: typeof schema }
-        const i = ("struct" in structSchema ? structSchema["struct"] : schema).pipe((_) =>
-          _.ast._tag === "Union"
-            // we need to get the TypeLiteral, incase of class it's behind a transform...
-            ? S.union(..._.ast.types.map((_) =>
-              (S.make(_._tag === "Transform" ? _.from : _) as unknown as Schema<T, From>)
-                .pipe(S.pick("id"))
-            ))
-            : _
-                .ast
-                ._tag === "Transform"
-            ? (S
-              .make(
-                _
+          const structSchema = schema as unknown as { struct: typeof schema }
+          const i = ("struct" in structSchema ? structSchema["struct"] : schema).pipe((_) =>
+            _.ast._tag === "Union"
+              // we need to get the TypeLiteral, incase of class it's behind a transform...
+              ? S.union(..._.ast.types.map((_) =>
+                (S.make(_._tag === "Transform" ? _.from : _) as unknown as Schema<T, From>)
+                  .pipe(S.pick("id"))
+              ))
+              : _
                   .ast
-                  .from
-              ) as unknown as Schema<T, From>)
-              .pipe(S
-                .pick("id"))
-            : _
-              .pipe(S
-                .pick("id"))
-        )
-        const encodeId = flow(i.encode, Effect.provide(rctx))
-        function findEId(id: From["id"]) {
-          return store
-            .find(id)
-            .flatMap((item) =>
-              Do(($) => {
-                const { set } = $(cms)
-                return item.map((_) => mapReverse(_, set))
-              })
+                  ._tag === "Transform"
+              ? (S
+                .make(
+                  _
+                    .ast
+                    .from
+                ) as unknown as Schema<T, From>)
+                .pipe(S
+                  .pick("id"))
+              : _
+                .pipe(S
+                  .pick("id"))
+          )
+          const encodeId = flow(S.encode(i), Effect.provide(rctx))
+          function findEId(id: From["id"]) {
+            return Effect.flatMap(
+              store.find(id),
+              (item) =>
+                Effect.gen(function*($) {
+                  const { set } = yield* $(cms)
+                  return item.pipe(Option.map((_) => mapReverse(_, set)))
+                })
             )
-        }
-        function findE(id: T["id"]) {
-          return encodeId({ id })
-            .orDie
-            .map((_) => _.id)
-            .flatMap(findEId)
-        }
-
-        function find(id: T["id"]) {
-          return findE(id).flatMapOpt((_) => decode(_).orDie)
-        }
-
-        const saveAllE = (a: Iterable<From>) =>
-          Effect
-            .sync(() => a.toNonEmptyArray)
-            .flatMapOpt((a) =>
-              Do(($) => {
-                const { get, set } = $(cms)
-                const items = a.map((_) => mapToPersistenceModel(_, get))
-                const ret = $(store.batchSet(items))
-                ret.forEach((_) => set(_.id, _._etag))
-              })
+          }
+          function findE(id: T["id"]) {
+            return pipe(
+              encodeId({ id }),
+              Effect.orDie,
+              Effect.map((_) => _.id),
+              Effect.flatMap(findEId)
             )
-            .asUnit
-
-        const saveAll = (a: Iterable<T>) =>
-          a.toChunk.forEachEffect((_) => encode(_), { concurrency: "inherit", batching: true }).orDie.andThen(saveAllE)
-
-        const saveAndPublish = (items: Iterable<T>, events: Iterable<Evt> = []) => {
-          const it = items.toChunk
-          return saveAll(it)
-            .andThen(Effect.sync(() => events.toNonEmptyArray))
-            // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-            .flatMapOpt(pub)
-            .andThen(changeFeed
-              .publish([it.toArray, "save"]))
-            .asUnit
-        }
+          }
 
-        function removeAndPublish(a: Iterable<T>, events: Iterable<Evt> = []) {
-          return Effect.gen(function*($) {
-            const { get, set } = yield* $(cms)
-            const it = a.toChunk
-            const items = yield* $(it.forEachEffect((_) => encode(_), { concurrency: "inherit", batching: true }).orDie)
-            // TODO: we should have a batchRemove on store so the adapter can actually batch...
-            for (const e of items) {
-              yield* $(store.remove(mapToPersistenceModel(e, get)))
-              set(e.id, undefined)
-            }
-            yield* $(
-              Effect
-                .sync(() => events.toNonEmptyArray)
+          function find(id: T["id"]) {
+            return Effect.flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
+          }
+
+          const saveAllE = (a: Iterable<From>) =>
+            Effect
+              .flatMapOption(
+                Effect
+                  .sync(() => toNonEmptyArray([...a])),
+                (a) =>
+                  Effect.gen(function*($) {
+                    const { get, set } = yield* $(cms)
+                    const items = a.map((_) => mapToPersistenceModel(_, get))
+                    const ret = yield* $(store.batchSet(items))
+                    ret.forEach((_) => set(_.id, _._etag))
+                  })
+              )
+              .pipe(Effect.asUnit)
+
+          const saveAll = (a: Iterable<T>) =>
+            Effect
+              .forEach(
+                Array.from(a),
+                (_) => encode(_),
+                { concurrency: "inherit", batching: true }
+              )
+              .pipe(
+                Effect.orDie,
+                Effect.andThen(saveAllE)
+              )
+
+          const saveAndPublish = (items: Iterable<T>, events: Iterable<Evt> = []) => {
+            const it = Chunk.fromIterable(items)
+            return saveAll(it)
+              .pipe(
+                Effect.andThen(Effect.sync(() => toNonEmptyArray([...events]))),
                 // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                .flatMapOpt(pub)
-            )
+                (_) => Effect.flatMapOption(_, pub),
+                Effect.andThen(changeFeed.publish([Chunk.toArray(it), "save"])),
+                Effect.asUnit
+              )
+          }
 
-            yield* $(changeFeed.publish([it.toArray, "remove"]))
-          })
-        }
+          function removeAndPublish(a: Iterable<T>, events: Iterable<Evt> = []) {
+            return Effect.gen(function*($) {
+              const { get, set } = yield* $(cms)
+              const it = [...a]
+              const items = yield* $(
+                Effect.forEach(it, (_) => encode(_), { concurrency: "inherit", batching: true }).pipe(Effect.orDie)
+              )
+              // TODO: we should have a batchRemove on store so the adapter can actually batch...
+              for (const e of items) {
+                yield* $(store.remove(mapToPersistenceModel(e, get)))
+                set(e.id, undefined)
+              }
+              yield* $(
+                Effect
+                  .sync(() => toNonEmptyArray([...events]))
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  .pipe((_) => Effect.flatMapOption(_, pub))
+              )
+
+              yield* $(changeFeed.publish([it, "remove"]))
+            })
+          }
 
-        const r: Repository<T, PM, Evt, ItemType> = {
-          /**
-           * @internal
-           */
-          utils: {
-            parseMany: (items) =>
-              cms.flatMap((cm) =>
-                items
-                  .forEachEffect((_) => decode(mapReverse(_, cm.set)), { concurrency: "inherit", batching: true })
-                  .orDie
-              ),
-            parseMany2: (items, schema) =>
-              cms.flatMap((cm) =>
-                items
-                  .forEachEffect((_) => schema.decode(mapReverse(_, cm.set) as any), {
-                    concurrency: "inherit",
-                    batching: true
-                  })
-                  .orDie
-              ),
-            filter: <U extends keyof PM = keyof PM>(args: FilterArgs<PM, U>) =>
-              store
-                .filter(args)
-                .tap((items) =>
-                  args.select
-                    ? Effect.unit
-                    : cms.map(({ set }) => items.forEach((_) => set((_ as PM).id, (_ as PM)._etag)))
-                ),
-            all: store.all.tap((items) => cms.map(({ set }) => items.forEach((_) => set(_.id, _._etag))))
-          },
-          mapped: <A, R>(schema: S.Schema<A, any, R>) => {
-            // const enc = S.encode(schema)
-            const dec = S.decode(schema)
-            const encMany = S.encode(S.array(schema))
-            const decMany = S.decode(S.array(schema))
-            return {
-              all: cms
-                .flatMap((cm) => r.utils.all.map((_) => _.map((_) => mapReverse(_, cm.set))))
-                .flatMap(decMany)
-                .map((_) => _ as any[]),
-              find: (id: PM["id"]) => flatMapOption(findE(id), dec),
-              query: (b: any) =>
-                r
-                  .utils
-                  .filter({ filter: b })
-                  .flatMap(decMany)
-                  .map((_) => _ as any[]),
-              save: (...xes: any[]) => encMany(xes).flatMap((_) => saveAllE(_ as any))
-            }
-          },
-          changeFeed,
-          itemType: name,
-          find,
-          all,
-          saveAndPublish,
-          removeAndPublish,
-          q2: (q: any) => query(r, typeof q === "function" ? q(makeQuery()) : q) as any
-        }
-        return r
-      })
-        // .withSpan("Repository.make [effect-app/infra]", { attributes: { "repository.model_name": name } })
-        .withLogSpan("Repository.make: " + name)
+          const r: Repository<T, PM, Evt, ItemType> = {
+            /**
+             * @internal
+             */
+            utils: {
+              parseMany: (items) =>
+                Effect.flatMap(cms, (cm) =>
+                  Effect
+                    .forEach(items, (_) => decode(mapReverse(_, cm.set)), { concurrency: "inherit", batching: true })
+                    .pipe(Effect.orDie)),
+              parseMany2: (items, schema) =>
+                Effect.flatMap(cms, (cm) =>
+                  Effect
+                    .forEach(items, (_) => S.decode(schema)(mapReverse(_, cm.set) as any), {
+                      concurrency: "inherit",
+                      batching: true
+                    })
+                    .pipe(Effect.orDie)),
+              filter: <U extends keyof PM = keyof PM>(args: FilterArgs<PM, U>) =>
+                store
+                  .filter(args)
+                  .pipe(Effect.tap((items) =>
+                    args.select
+                      ? Effect.unit
+                      : Effect.map(cms, ({ set }) => items.forEach((_) => set((_ as PM).id, (_ as PM)._etag)))
+                  )),
+              all: Effect.tap(
+                store.all,
+                (items) => Effect.map(cms, ({ set }) => items.forEach((_) => set(_.id, _._etag)))
+              )
+            },
+            mapped: <A, R>(schema: S.Schema<A, any, R>) => {
+              // const enc = S.encode(schema)
+              const dec = S.decode(schema)
+              const encMany = S.encode(S.array(schema))
+              const decMany = S.decode(S.array(schema))
+              return {
+                all: cms
+                  .pipe(
+                    Effect.flatMap((cm) => Effect.map(r.utils.all, (_) => _.map((_) => mapReverse(_, cm.set)))),
+                    Effect.flatMap(decMany),
+                    Effect.map((_) => _ as any[])
+                  ),
+                find: (id: PM["id"]) => flatMapOption(findE(id), dec),
+                query: (b: any) =>
+                  r
+                    .utils
+                    .filter({ filter: b })
+                    .pipe(
+                      Effect.flatMap(decMany),
+                      Effect.map((_) => _ as any[])
+                    ),
+                save: (...xes: any[]) => Effect.flatMap(encMany(xes), (_) => saveAllE(_))
+              }
+            },
+            changeFeed,
+            itemType: name,
+            find,
+            all,
+            saveAndPublish,
+            removeAndPublish,
+            q2: (q: any) => query(r, typeof q === "function" ? q(makeQuery()) : q) as any
+          }
+          return r
+        })
+        .pipe(Effect
+          // .withSpan("Repository.make [effect-app/infra]", { attributes: { "repository.model_name": name } })
+          .withLogSpan("Repository.make: " + name))
     }
 
     return {
@@ -829,7 +865,7 @@ export function removeById<
   self: Repository<T, PM, Evt, ItemType>,
   id: T["id"]
 ) {
-  return self.get(id).flatMap((_) => self.removeAndPublish([_]))
+  return get(self, id).pipe(Effect.flatMap((_) => self.removeAndPublish([_])))
 }
 
 export function makeWhere<PM extends { id: string; _etag: string | undefined }>() {
@@ -880,10 +916,10 @@ export function makeStore<
     function encodeToPM() {
       const getEtag = () => undefined
       return (t: T) =>
-        schema
-          .encode(t)
-          .orDie
-          .map((_) => mapToPersistenceModel(_, getEtag))
+        S.encode(schema)(t).pipe(
+          Effect.orDie,
+          Effect.map((_) => mapToPersistenceModel(_, getEtag))
+        )
     }
 
     function mapToPersistenceModel(
@@ -899,18 +935,20 @@ export function makeStore<
         partitionValue?: (a: PM) => string
       }
     ) {
-      return Do(($) => {
-        const { make } = $(StoreMaker)
+      return Effect.gen(function*($) {
+        const { make } = yield* $(StoreMaker)
 
-        const store = $(
+        const store = yield* $(
           make<PM, string, R | RInitial, EInitial>(
             pluralize(name),
             makeInitial
-              ? (makeInitial
-                .flatMap((_) => _.forEachEffect(encodeToPM())))
-                .withSpan("Repository.makeInitial [effect-app/infra]", {
-                  attributes: { "repository.model_name": name }
-                })
+              ? makeInitial
+                .pipe(
+                  Effect.flatMap(Effect.forEach(encodeToPM())),
+                  Effect.withSpan("Repository.makeInitial [effect-app/infra]", {
+                    attributes: { "repository.model_name": name }
+                  })
+                )
               : undefined,
             {
               ...config,
@@ -1036,7 +1074,7 @@ export const RepositoryBaseImpl = <Service>() => {
     jitM?: (pm: From) => From
   ): Exact<PM, From & { _etag: string | undefined }> extends true ?
       & (abstract new() => RepositoryBaseC1<T, PM, Evt, ItemType>)
-      & Tag<Service, Service>
+      & Context.Tag<Service, Service>
       & Repos<
         T,
         PM,
@@ -1058,7 +1096,7 @@ export const RepositoryBaseImpl = <Service>() => {
         super(itemType)
       }
       static readonly make = mkRepo.make
-      static readonly makeWith = ((a: any, b: any) => mkRepo.make(a).map(b)) as any
+      static readonly makeWith = ((a: any, b: any) => Effect.map(mkRepo.make(a), b)) as any
 
       static readonly Where = makeWhere<PM>()
       static readonly Query = Q.QueryBuilder.make<PM>()
@@ -1082,7 +1120,7 @@ export const RepositoryDefaultImpl = <Service>() => {
       & (abstract new(
         impl: Repository<T, PM, Evt, ItemType>
       ) => RepositoryBaseC3<T, PM, Evt, ItemType>)
-      & Tag<Service, Service>
+      & Context.Tag<Service, Service>
       & Repos<
         T,
         PM,
@@ -1106,7 +1144,7 @@ export const RepositoryDefaultImpl = <Service>() => {
         super(itemType, impl)
       }
       static readonly make = mkRepo.make
-      static readonly makeWith = ((a: any, b: any) => mkRepo.make(a).map(b)) as any
+      static readonly makeWith = ((a: any, b: any) => Effect.map(mkRepo.make(a), b)) as any
 
       static readonly Where = makeWhere<PM>()
       static readonly Query = Q.QueryBuilder.make<PM>()