@effect-app/infra 0.198.2 → 0.199.2

package/src/services/RepositoryBase.ts

@@ -17,14 +17,20 @@ 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"
+import { make as makeQuery, page, query } from "./query.js"
+import type { QAll, Query, QueryEnd, QueryProjection, QueryWhere } from "./query.js"
 import { ContextMapContainer } from "./Store/ContextMapContainer.js"
 import * as Q from "./Store/filterApi/query.js"
 
@@ -67,7 +73,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,12 +89,13 @@ 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>
   ) => Effect<void>
 
+  /** @deprecated use q2 */
   abstract readonly mapped: Mapped<PM, Omit<PM, "_etag">>
   abstract readonly q2: {
     <A, R, From extends FieldValues>(
@@ -158,18 +165,108 @@ 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([_]))
+  }
+
+  count(filter?: Filter<PM>) {
+    return Effect.map(
+      this.projectEffect(Effect.sync(() => ({ filter }))),
+      (_) => NonNegativeInt(_.length)
+    )
   }
 
-  // TODO: project inside the db.
+  readonly save = (...items: NonEmptyArray<T>) => this.saveAndPublish(items)
+
+  readonly saveWithEvents = (events: Iterable<Evt>) => (...items: NonEmptyArray<T>) =>
+    this.saveAndPublish(items, events)
+
+  readonly q2AndSaveOnePure = <A, E2, R2, T2 extends T>(
+    q: (q: Query<Omit<PM, "_etag">>) => Query<Omit<PM, "_etag">> | QueryEnd<Omit<PM, "_etag">>,
+    pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
+  ) =>
+    this.q2(flow(q, page({ limit: 1 }))).pipe(
+      Effect.map(ReadonlyArray.toNonEmptyArray),
+      Effect.flatMap(Effect.mapError(() => new NotFoundError({ type: this.itemType, id: q }))),
+      Effect.andThen((_) => saveWithPure_(this, _[0], pure))
+    )
+
+  readonly q2AndSavePure = <A, E2, R2, T2 extends T>(
+    q: (q: Query<Omit<PM, "_etag">>) => Query<Omit<PM, "_etag">> | QueryEnd<Omit<PM, "_etag">>,
+    pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>,
+    batchSize?: number
+  ) =>
+    this.q2(flow(q, page({ limit: 1 }))).pipe(
+      Effect.andThen((_) =>
+        batchSize === undefined
+          ? saveManyWithPure_(this, _, pure)
+          : saveManyWithPureBatched_(this, _, pure, batchSize)
+      )
+    )
+
+  /**
+   * NOTE: it's not as composable, only useful when the request is simple, and only this part needs request args.
+   */
+  readonly handleByIdAndSaveWithPure = <Req extends { id: T["id"] }, Context, R, A, E, S2 extends T>(
+    pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>
+  ) =>
+  (req: Req, ctx: Context) => byIdAndSaveWithPure(this, req.id)(pure(req, ctx))
+
+  saveManyWithPure = <
+    R,
+    A,
+    E,
+    S1 extends T,
+    S2 extends T
+  >(
+    items: Iterable<S1>,
+    pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>
+  ) =>
+    saveAllWithEffectInt(
+      this,
+      runTerm(pure, [...items])
+    )
+
+  byIdAndSaveWithPure: {
+    <R, A, E, S2 extends T>(
+      id: T["id"],
+      pure: Effect<A, E, FixEnv<R, Evt, T, S2>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E,
+      Exclude<R, {
+        env: PureEnv<Evt, T, S2>
+      }>
+    >
+  } = (id, pure): any => get(this, id).pipe(Effect.flatMap((item) => saveWithPure_(this, item, pure)))
+
+  saveWithPure<
+    R,
+    A,
+    E,
+    S1 extends T,
+    S2 extends T
+  >(
+    item: S1,
+    pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>
+  ) {
+    return saveAllWithEffectInt(
+      this,
+      runTerm(pure, item)
+        .pipe(Effect.map(([item, events, a]) => [[item], events, a]))
+    )
+  }
+
+  /** @deprecated use q2 */
   projectEffect<
     R,
     E,
@@ -186,6 +283,7 @@ export class RepositoryBaseC3<
       R
     >
   ): Effect<S[], E, R>
+  /** @deprecated use q2 */
   projectEffect<
     R,
     E,
@@ -203,6 +301,7 @@ export class RepositoryBaseC3<
       R
     >
   ): Effect<Pick<PM, U>[], E, R>
+  /** @deprecated use q2 */
   projectEffect<
     R,
     E,
@@ -222,14 +321,16 @@ 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[]
+      ))
   }
 
+  /** @deprecated use q2 */
   project<S = PM>(
     map: {
       filter?: Filter<PM>
@@ -238,6 +339,7 @@ export class RepositoryBaseC3<
       skip?: number
     }
   ): Effect<S[]>
+  /** @deprecated use q2 */
   project<U extends keyof PM>(
     map: {
       filter?: Q.QueryBuilder<PM>
@@ -246,6 +348,7 @@ export class RepositoryBaseC3<
       skip?: number
     }
   ): Effect<Pick<PM, U>[]>
+  /** @deprecated use q2 */
   project<
     U extends keyof PM,
     S = Pick<PM, U>
@@ -261,12 +364,7 @@ export class RepositoryBaseC3<
     return this.projectEffect(Effect.sync(() => map))
   }
 
-  count(filter?: Filter<PM>) {
-    return this
-      .projectEffect(Effect.sync(() => ({ filter })))
-      .map((_) => NonNegativeInt(_.length))
-  }
-
+  /** @deprecated use q2 */
   queryEffect<
     R,
     E,
@@ -275,17 +373,20 @@ 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[])
+        ))
   }
 
+  /** @deprecated use q2 */
   queryOneEffect<R, E>(
     // TODO: think about collectPM, collectE, and collect(Parsed)
     map: Effect<{ filter?: Filter<PM> }, E, R>
   ): Effect<T, E | NotFoundError<ItemType>, R>
+  /** @deprecated use q2 */
   queryOneEffect<
     R,
     E,
@@ -294,6 +395,7 @@ 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>
+  /** @deprecated use q2 */
   queryOneEffect<
     R,
     E,
@@ -302,18 +404,26 @@ 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])
+                )
+            )
+        ))
   }
 
+  /** @deprecated use q2 */
   queryLegacy<S = T>(
     // TODO: think about collectPM, collectE, and collect(Parsed)
     map: { filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
@@ -321,24 +431,29 @@ export class RepositoryBaseC3<
     return this.queryEffect(Effect.sync(() => map))
   }
 
+  /** @deprecated use q2 */
   query(
     b: (fn: Q.FilterTest<PM>, fields: Q.Filter<PM, never>) => Q.QueryBuilder<PM>
   ) {
     return this.queryEffect(Effect.sync(() => ({ filter: anyQb((_, fields) => b(_, fields as any)) })))
   }
 
+  /** @deprecated use q2 */
   queryOne<S = T>(
     map: { filter?: Filter<PM>; collect: (t: T) => Option<S> }
   ): Effect<S, NotFoundError<ItemType>>
+  /** @deprecated use q2 */
   queryOne(
     map: { filter?: Filter<PM> }
   ): Effect<T, NotFoundError<ItemType>>
+  /** @deprecated use q2 */
   queryOne<S = T>(
     map: { filter?: Filter<PM>; collect?: (t: T) => Option<S> }
   ) {
     return this.queryOneEffect(Effect.sync(() => map))
   }
 
+  /** @deprecated */
   queryAndSaveOnePureEffect<
     R,
     E,
@@ -355,6 +470,7 @@ export class RepositoryBaseC3<
       env: PureEnv<Evt, S, S2>
     }>
   >
+  /** @deprecated */
   queryAndSaveOnePureEffect<
     R,
     E
@@ -370,14 +486,13 @@ export class RepositoryBaseC3<
       env: PureEnv<Evt, T, T2>
     }>
   >
+  /** @deprecated */
   queryAndSaveOnePureEffect(
     map: any
   ) {
-    return (pure: any) =>
-      queryOneEffect(this, map)
-        .flatMap((_) => saveWithPure_(this, _, pure))
+    return (pure: any) => Effect.flatMap(queryOneEffect(this, map), (_) => saveWithPure_(this, _, pure))
   }
-
+  /** @deprecated */
   queryAndSaveOnePure<
     S extends T = T
   >(
@@ -389,6 +504,7 @@ export class RepositoryBaseC3<
       env: PureEnv<Evt, S, S2>
     }>
   >
+  /** @deprecated */
   queryAndSaveOnePure(
     map: { filter: Filter<PM> }
   ): <R2, A, E2, T2>(pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>) => Effect<
@@ -398,12 +514,13 @@ export class RepositoryBaseC3<
       env: PureEnv<Evt, T, T2>
     }>
   >
+  /** @deprecated */
   queryAndSaveOnePure<S = T>(
     map: { filter: Filter<PM>; collect: (t: T) => Option<S> }
   ) {
     return this.queryAndSaveOnePureEffect(Effect.sync(() => map))
   }
-
+  /** @deprecated */
   queryAndSavePureEffect<
     R,
     E,
@@ -411,11 +528,10 @@ 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))
+    return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, readonly S[], readonly S2[]>>) =>
+      Effect.flatMap(queryEffect(this, map), (_) => this.saveManyWithPure(_, pure))
   }
-
+  /** @deprecated */
   queryAndSavePure<
     S extends T = T
   >(
@@ -424,95 +540,7 @@ export class RepositoryBaseC3<
     return this.queryAndSavePureEffect(Effect.sync(() => map))
   }
 
-  get saveManyWithPure() {
-    return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>) =>
-    (items: Iterable<S1>) => saveManyWithPure_(this, items, pure)
-  }
-
-  byIdAndSaveWithPure(
-    id: T["id"]
-  ): <R, A, E, S2 extends T>(
-    pure: Effect<A, E, FixEnv<R, Evt, T, S2>>
-  ) => Effect<
-    A,
-    InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E,
-    Exclude<R, {
-      env: PureEnv<Evt, T, S2>
-    }>
-  >
-  byIdAndSaveWithPure<R, A, E, S2 extends T>(
-    id: T["id"],
-    pure: Effect<A, E, FixEnv<R, Evt, T, S2>>
-  ): Effect<
-    A,
-    InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E,
-    Exclude<R, {
-      env: PureEnv<Evt, T, S2>
-    }>
-  >
-  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))
-    return (pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) =>
-      get(this, id).flatMap((item) => saveWithPure_(this, item, pure))
-  }
-
-  /**
-   * NOTE: it's not as composable, only useful when the request is simple, and only this part needs request args.
-   */
-  get handleByIdAndSaveWithPure() {
-    return <Req extends { id: T["id"] }, Context, R, A, E, S2 extends T>(
-      pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>
-    ) =>
-    (req: Req, ctx: Context) => byIdAndSaveWithPure(this, req.id)(pure(req, ctx))
-  }
-
-  saveManyWithPure_<
-    R,
-    A,
-    E,
-    S1 extends T,
-    S2 extends T
-  >(
-    items: Iterable<S1>,
-    pure: Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>
-  ) {
-    return saveAllWithEffectInt(
-      this,
-      runTerm(pure, [...items])
-    )
-  }
-
-  saveWithPure_<
-    R,
-    A,
-    E,
-    S1 extends T,
-    S2 extends T
-  >(
-    item: S1,
-    pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>
-  ) {
-    return saveAllWithEffectInt(
-      this,
-      runTerm(pure, item)
-        .map(([item, events, a]) => [[item], events, a])
-    )
-  }
-
-  saveAllWithEffectInt<
-    P extends T,
-    R,
-    E,
-    A
-  >(
-    gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
-  ) {
-    return gen
-      .flatMap(
-        ([items, events, a]) => this.saveAndPublish(items, events).map(() => a)
-      )
-  }
-
+  /** @deprecated use q2 */
   queryAndSavePureEffectBatched<
     R,
     E,
@@ -522,11 +550,11 @@ export class RepositoryBaseC3<
     map: Effect<{ filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }, E, R>,
     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))
+    return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, readonly S[], readonly S2[]>>) =>
+      Effect.flatMap(queryEffect(this, map), (_) => this.saveManyWithPureBatched(_, pure, batchSize))
   }
 
+  /** @deprecated use q2 */
   queryAndSavePureBatched<
     S extends T = T
   >(
@@ -537,12 +565,8 @@ export class RepositoryBaseC3<
     return this.queryAndSavePureEffectBatched(Effect.sync(() => map), batchSize)
   }
 
-  saveManyWithPureBatched(batchSize = 100) {
-    return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>) =>
-    (items: Iterable<S1>) => saveManyWithPureBatched_(this, items, pure, batchSize)
-  }
-
-  saveManyWithPureBatched_<
+  /** @deprecated use q2 */
+  saveManyWithPureBatched<
     R,
     A,
     E,
@@ -550,25 +574,18 @@ export class RepositoryBaseC3<
     S2 extends T
   >(
     items: Iterable<S1>,
-    pure: Effect<A, E, FixEnv<R, Evt, S1[], S2[]>>,
+    pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly 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)
-
-  readonly saveWithEvents = (
-    events: Iterable<Evt>
-  ) =>
-  (...items: NonEmptyArray<T>) => this.saveAndPublish(items, events)
 }
 
 type Exact<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false
@@ -624,188 +641,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 +872,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 +923,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 +942,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,
@@ -988,6 +1033,7 @@ export interface RepoFunctions<T extends { id: unknown }, PM extends { id: strin
   save: (...items: T[]) => Effect<void, InvalidStateError | OptimisticConcurrencyException, Service>
   get: (id: T["id"]) => Effect<T, NotFoundError<ItemType>, Service>
 
+  /** @deprecated use q2 */
   query: (b: (fn: Q.FilterTest<PM>, fields: Q.Filter<PM, never>) => Q.QueryBuilder<PM>) => Effect<T[], never, Service>
   queryLegacy: <S = T>(map: {
     filter?: Filter<PM>
@@ -996,8 +1042,64 @@ export interface RepoFunctions<T extends { id: unknown }, PM extends { id: strin
     skip?: number
   }) => Effect<S[], never, Service>
 
+  /** @deprecated use q2 */
   mapped: MM<Service, PM, Omit<PM, "_etag">>
 
+  byIdAndSaveWithPure: {
+    <R, A, E, S2 extends T>(
+      id: T["id"],
+      pure: Effect<A, E, FixEnv<R, never, T, S2>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E | NotFoundError<ItemType>,
+      | Service
+      | Exclude<R, {
+        env: PureEnv<never, T, S2>
+      }>
+    >
+  }
+
+  q2AndSaveOnePure: {
+    <
+      R2,
+      A,
+      E2,
+      T2 extends T
+    >(
+      q: (initial: Query<Omit<PM, "_etag">>) =>
+        | Query<Omit<PM, "_etag">>
+        | QueryWhere<Omit<PM, "_etag">>,
+      pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E2 | NotFoundError<ItemType>,
+      | Service
+      | Exclude<R2, {
+        env: PureEnv<Evt, T, T2>
+      }>
+    >
+  }
+  q2AndSavePure: {
+    <
+      R2,
+      A,
+      E2,
+      T2 extends T
+    >(
+      q: (initial: Query<Omit<PM, "_etag">>) =>
+        | Query<Omit<PM, "_etag">>
+        | QueryWhere<Omit<PM, "_etag">>,
+      pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>
+    ): Effect<
+      A,
+      InvalidStateError | OptimisticConcurrencyException | E2,
+      | Service
+      | Exclude<R2, {
+        env: PureEnv<Evt, readonly T[], readonly T2[]>
+      }>
+    >
+  }
+
   readonly q2: {
     <A, R, From extends FieldValues>(
       q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
@@ -1015,14 +1117,39 @@ export interface RepoFunctions<T extends { id: unknown }, PM extends { id: strin
 
 const makeRepoFunctions = (tag: any) => {
   const { all } = Effect.serviceConstants(tag) as any
-  const { find, get, q2, query, queryLegacy, removeAndPublish, removeById, save, saveAndPublish } = Effect
-    .serviceFunctions(
-      tag
-    ) as any
+  const {
+    byIdAndSaveWithPure,
+    find,
+    get,
+    q2,
+    q2AndSaveOnePure,
+    q2AndSavePure,
+    query,
+    queryLegacy,
+    removeAndPublish,
+    removeById,
+    save,
+    saveAndPublish
+  } = Effect.serviceFunctions(tag) as any
 
   const mapped = (s: any) => tag.map((_: any) => _.mapped(s))
 
-  return { all, find, removeById, saveAndPublish, removeAndPublish, save, get, query, queryLegacy, q2, mapped }
+  return {
+    all,
+    byIdAndSaveWithPure,
+    find,
+    removeById,
+    saveAndPublish,
+    removeAndPublish,
+    save,
+    get,
+    query,
+    queryLegacy,
+    q2,
+    mapped,
+    q2AndSaveOnePure,
+    q2AndSavePure
+  }
 }
 
 export const RepositoryBaseImpl = <Service>() => {
@@ -1036,7 +1163,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 +1185,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 +1209,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 +1233,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>()