@effect-app/infra 0.198.1 → 0.199.0

package/src/services/QueueMaker/memQueue.ts

@@ -1,18 +1,21 @@
 import { MemQueue } from "@effect-app/infra-adapters/memQueue"
 import { RequestContext } from "@effect-app/infra/RequestContext"
+import { NonEmptyString255, struct } from "@effect-app/schema"
 import { Tracer } from "effect"
-import type { S } from "effect-app"
+import { Effect, Fiber, flow, S } from "effect-app"
 import { RequestId } from "effect-app/ids"
+import { pretty } from "effect-app/utils"
+import { setupRequestContext } from "../../api/setupRequest.js"
 import { RequestContextContainer } from "../RequestContextContainer.js"
-import { reportNonInterruptedFailure } from "./errors.js"
+import { forkDaemonReportQueue, reportNonInterruptedFailure } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 /**
  * @tsplus static QueueMaker.Ops makeMem
  */
 export function makeMemQueue<
-  Evt extends { id: StringId; _tag: string },
-  DrainEvt extends { id: StringId; _tag: string },
+  Evt extends { id: S.StringId; _tag: string },
+  DrainEvt extends { id: S.StringId; _tag: string },
   EvtE,
   DrainEvtE
 >(
@@ -29,27 +32,28 @@ export function makeMemQueue<
 
     const wireSchema = struct({ body: schema, meta: QueueMeta })
     const drainW = struct({ body: drainSchema, meta: QueueMeta })
-    const parseDrain = flow(drainW.decodeUnknown, (_) => _.orDie)
+    const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
 
     return {
       publish: (...messages) =>
         Effect.gen(function*($) {
           const requestContext = yield* $(rcc.requestContext)
-          const currentSpan = yield* $(Effect.currentSpan.orDie)
+          const currentSpan = yield* $(Effect.currentSpan.pipe(Effect.orDie))
           const span = Tracer.externalSpan(currentSpan)
           return yield* $(
-            messages
-              .forEachEffect((m) =>
+            Effect
+              .forEach(messages, (m) =>
                 // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-                wireSchema
-                  .encode({ body: m, meta: { requestContext, span } })
-                  .orDie
-                  .andThen(JSON.stringify)
+                S.encode(wireSchema)({ body: m, meta: { requestContext, span } }).pipe(
+                  Effect.orDie,
+                  Effect
+                    .andThen(JSON.stringify),
                   // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
-                  .flatMap((_) => q.offer(_))
-                  .asUnit
-              )
-              .forkDaemonReportQueue
+                  Effect.flatMap((_) => q.offer(_)),
+                  Effect
+                    .asUnit
+                ))
+              .pipe(forkDaemonReportQueue)
           )
         }),
       makeDrain: <DrainE, DrainR>(
@@ -61,35 +65,50 @@ export function makeMemQueue<
             // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
             Effect
               .sync(() => JSON.parse(msg))
-              .flatMap(parseDrain)
-              .orDie
-              .flatMap(({ body, meta }) =>
+              .pipe(
+                Effect.flatMap(parseDrain),
                 Effect
-                  .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
-                  .pipe(Effect.annotateLogs({ body: body.$$.pretty, meta: meta.$$.pretty }))
-                  .zipRight(handleEvent(body))
-                  .pipe(silenceAndReportError)
-                  .setupRequestContext(RequestContext.inherit(meta.requestContext, {
-                    id: RequestId(body.id),
-                    locale: "en" as const,
-                    name: NonEmptyString255(body._tag)
-                  }))
-                  .withSpan("queue.drain", {
-                    attributes: { "queue.name": queueDrainName },
-                    parent: meta.span
-                      ? Tracer.externalSpan(meta.span)
-                      : undefined
-                  })
+                  .orDie,
+                Effect
+                  .flatMap(({ body, meta }) =>
+                    Effect
+                      .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
+                      .pipe(
+                        Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+                        Effect.zipRight(handleEvent(body)),
+                        silenceAndReportError,
+                        (_) =>
+                          setupRequestContext(
+                            _,
+                            RequestContext.inherit(meta.requestContext, {
+                              id: RequestId(body.id),
+                              locale: "en" as const,
+                              name: NonEmptyString255(body._tag)
+                            })
+                          ),
+                        Effect
+                          .withSpan("queue.drain", {
+                            attributes: { "queue.name": queueDrainName },
+                            parent: meta.span
+                              ? Tracer.externalSpan(meta.span)
+                              : undefined
+                          })
+                      )
+                  )
               )
           return yield* $(
             qDrain
               .take
-              .flatMap((x) => processMessage(x).uninterruptible.fork.flatMap((_) => _.join))
-              // TODO: normally a failed item would be returned to the queue and retried up to X times.
-              // .flatMap(_ => _._tag === "Failure" && !isInterrupted ? qDrain.offer(x) : Effect.unit) // TODO: retry count tracking and max retries.
-              .pipe(silenceAndReportError)
-              .forever
-              .forkScoped
+              .pipe(
+                Effect.flatMap((x) =>
+                  processMessage(x).pipe(Effect.uninterruptible, Effect.fork, Effect.flatMap(Fiber.join))
+                ),
+                // TODO: normally a failed item would be returned to the queue and retried up to X times.
+                // .flatMap(_ => _._tag === "Failure" && !isInterrupted ? qDrain.offer(x) : Effect.unit) // TODO: retry count tracking and max retries.
+                silenceAndReportError,
+                Effect.forever,
+                Effect.forkScoped
+              )
           )
         })
     } satisfies QueueBase<Evt, DrainEvt>

package/src/services/QueueMaker/sbqueue.ts

@@ -10,11 +10,14 @@ import type {} from "@azure/service-bus"
 import { captureException } from "@effect-app/infra/errorReporter"
 import { RequestContext } from "@effect-app/infra/RequestContext"
 import { Tracer } from "effect"
-import type { S } from "effect-app"
+import { Effect, flow, Layer, S } from "effect-app"
 import { RequestId } from "effect-app/ids"
-import { struct } from "effect-app/schema"
+import type { StringId } from "effect-app/schema"
+import { NonEmptyString255, struct } from "effect-app/schema"
+import { pretty } from "effect-app/utils"
+import { setupRequestContext } from "../../api/setupRequest.js"
 import { RequestContextContainer } from "../RequestContextContainer.js"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
+import { forkDaemonReportQueue, reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 /**
@@ -36,12 +39,12 @@ export function makeServiceBusQueue<
     meta: QueueMeta
   })
   const drainW = struct({ body: drainSchema, meta: QueueMeta })
-  const parseDrain = flow(drainW.decodeUnknown, (_) => _.orDie)
+  const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
 
   return Effect.gen(function*($) {
     const s = yield* $(Sender)
     const receiver = yield* $(Receiver)
-    const receiverLayer = Receiver.makeLayer(receiver)
+    const receiverLayer = Layer.succeed(Receiver, receiver)
     const silenceAndReportError = reportNonInterruptedFailure({ name: "ServiceBusQueue.drain." + queueDrainName })
     const reportError = reportNonInterruptedFailureCause({ name: "ServiceBusQueue.drain." + queueDrainName })
     const rcc = yield* $(RequestContextContainer)
@@ -55,45 +58,63 @@ export function makeServiceBusQueue<
           function processMessage(messageBody: any) {
             return Effect
               .sync(() => JSON.parse(messageBody))
-              .flatMap((x) => parseDrain(x))
-              .orDie
-              .flatMap(({ body, meta }) =>
+              .pipe(
+                Effect.flatMap((x) => parseDrain(x)),
+                Effect.orDie,
                 Effect
-                  .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
-                  .pipe(Effect.annotateLogs({ body: body.$$.pretty, meta: meta.$$.pretty }))
-                  .zipRight(handleEvent(body))
-                  .orDie
-                  // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-                  .pipe(silenceAndReportError)
-                  .setupRequestContext(RequestContext.inherit(meta.requestContext, {
-                    id: RequestId(body.id),
-                    locale: "en" as const,
-                    name: NonEmptyString255(body._tag)
-                  }))
-                  .withSpan("queue.drain", {
-                    attributes: { "queue.name": queueDrainName },
-                    parent: meta.span
-                      ? Tracer.externalSpan(meta.span)
-                      : undefined
-                  })
+                  .flatMap(({ body, meta }) =>
+                    Effect
+                      .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
+                      .pipe(
+                        Effect.annotateLogs({
+                          body: pretty(body),
+                          meta: pretty(meta)
+                        }),
+                        Effect
+                          .zipRight(handleEvent(body)),
+                        Effect
+                          .orDie
+                      )
+                      // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
+                      .pipe(
+                        silenceAndReportError,
+                        (_) =>
+                          setupRequestContext(
+                            _,
+                            RequestContext.inherit(meta.requestContext, {
+                              id: RequestId(body.id),
+                              locale: "en" as const,
+                              name: NonEmptyString255(body._tag)
+                            })
+                          ),
+                        Effect
+                          .withSpan("queue.drain", {
+                            attributes: { "queue.name": queueDrainName },
+                            parent: meta.span
+                              ? Tracer.externalSpan(meta.span)
+                              : undefined
+                          })
+                      )
+                  ),
+                Effect
+                  // we reportError here, so that we report the error only, and keep flowing
+                  .tapErrorCause(reportError)
               )
-              // we reportError here, so that we report the error only, and keep flowing
-              .tapErrorCause(reportError)
           }
 
           return yield* $(
             subscribe({
-              processMessage: (x) => processMessage(x.body).uninterruptible,
+              processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
               processError: (err) => Effect.sync(() => captureException(err.error))
             })
-              .provide(receiverLayer)
+              .pipe(Effect.provide(receiverLayer))
           )
         }),
 
       publish: (...messages) =>
         Effect.gen(function*($) {
           const requestContext = yield* $(rcc.requestContext)
-          const currentSpan = yield* $(Effect.currentSpan.orDie)
+          const currentSpan = yield* $(Effect.currentSpan.pipe(Effect.orDie))
           const span = Tracer.externalSpan(currentSpan)
           return yield* $(
             Effect
@@ -101,14 +122,14 @@ export function makeServiceBusQueue<
                 s.sendMessages(
                   messages.map((m) => ({
                     body: JSON.stringify(
-                      wireSchema.encodeSync({ body: m, meta: { requestContext, span } })
+                      S.encodeSync(wireSchema)({ body: m, meta: { requestContext, span } })
                     ),
                     messageId: m.id, /* correllationid: requestId */
                     contentType: "application/json"
                   }))
                 )
               )
-              .forkDaemonReportQueue
+              .pipe(forkDaemonReportQueue)
           )
         })
     } satisfies QueueBase<Evt, DrainEvt>
@@ -119,5 +140,5 @@ export function makeServiceBusQueue<
  * @tsplus static QueueMaker.Ops makeServiceBusLayers
  */
 export function makeServiceBusLayers(url: string, queueName: string, queueDrainName: string) {
-  return Layer.merge(LiveReceiver(queueDrainName), LiveSender(queueName)).provide(LiveServiceBusClient(url))
+  return Layer.merge(LiveReceiver(queueDrainName), LiveSender(queueName)).pipe(Layer.provide(LiveServiceBusClient(url)))
 }

package/src/services/QueueMaker/service.ts

@@ -1,3 +1,5 @@
+import { struct } from "@effect-app/schema"
+import { type Effect, type NonEmptyReadonlyArray, S, type Scope } from "effect-app"
 import { RequestContext } from "../../RequestContext.js"
 import type { RequestContextContainer } from "../RequestContextContainer.js"
 import type { ContextMapContainer } from "../Store/ContextMapContainer.js"
@@ -19,10 +21,9 @@ export const QueueMaker: QueueMakerOps = {}
 
 export const QueueMeta = struct({
   requestContext: RequestContext,
-  span: struct({
-    spanId: string,
-    traceId: string,
-    sampled: boolean.optional()
-  })
-    .optional()
+  span: S.optional(struct({
+    spanId: S.string,
+    traceId: S.string,
+    sampled: S.optional(S.boolean)
+  }))
 })

package/src/services/Repository/dsl.ts

@@ -1,4 +1,8 @@
-import type { FixEnv, PureLogT } from "effect-app/Pure"
+import { toNonEmptyArray } from "@effect-app/core/Array"
+import type { NonEmptyReadonlyArray } from "effect-app"
+import { Effect } from "effect-app"
+import { get, logMany, set } from "effect-app/Pure"
+import type { FixEnv, Pure, PureEnvEnv, PureLogT } from "effect-app/Pure"
 
 export interface PureDSL<S, S2, W> {
   get: Pure<never, S, S, never, never, S>
@@ -7,9 +11,9 @@ export interface PureDSL<S, S2, W> {
 }
 
 export const AnyPureDSL: PureDSL<any, any, any> = {
-  get: Pure.get(),
-  set: Pure.set as any,
-  log: (...evt: any[]) => Pure.logMany(evt)
+  get: get(),
+  set: set as any,
+  log: (...evt: any[]) => logMany(evt)
 }
 
 const anyDSL = makeDSL<any, any, any>()
@@ -78,7 +82,7 @@ export function makeDSL<S1, S2, Evt>() {
       dsl: PureDSL<S1, S2, Evt>
     ) => Effect<A, E, R>
   ): Effect<A, E, FixEnv<R, Evt, S1, S2>> {
-    return dsl.get.flatMap((items) => pure(items, dsl)) as any
+    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl))) as any
   }
 
   function update<
@@ -90,7 +94,7 @@ export function makeDSL<S1, S2, Evt>() {
       log: (...evt: Evt[]) => PureLogT<Evt>
     ) => Effect<S2, E, R>
   ): Effect<S2, E, FixEnv<R, Evt, S1, S2>> {
-    return dsl.get.flatMap((items) => pure(items, dsl.log).tap(dsl.set)) as any
+    return dsl.get.pipe(Effect.flatMap((items) => pure(items, dsl.log).pipe(Effect.tap(dsl.set)))) as any
   }
 
   function withDSL<
@@ -120,12 +124,12 @@ export function makeDSL<S1, S2, Evt>() {
 export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
 
 export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect<A, E, R>) {
-  return (items: Iterable<T>) => Effect.sync(() => items.toNonEmptyArray).flatMapOpt(fn)
+  return (items: Iterable<T>) => Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
 }
 
 /**
  * @tsplus fluent Iterable ifAny
  */
 export function ifAny_<T, R, E, A>(items: Iterable<T>, fn: (items: NonEmptyReadonlyArray<T>) => Effect<A, E, R>) {
-  return Effect.sync(() => items.toNonEmptyArray).flatMapOpt(fn)
+  return Effect.flatMapOption(Effect.sync(() => toNonEmptyArray([...items])), fn)
 }

package/src/services/Repository/ext.ts

@@ -1,7 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // Update = Must return updated items
 // Modify = Must `set` updated items, and can return anything.
-import type { FixEnv } from "effect-app/Pure"
+import { toNonEmptyArray } from "@effect-app/core/Array"
+import { NonNegativeInt } from "@effect-app/schema"
+import { Effect, ReadonlyArray } from "effect-app"
+import type { NonEmptyArray, NonEmptyReadonlyArray, Option } from "effect-app"
+import { type FixEnv, type PureEnv, runTerm } from "effect-app/Pure"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../../errors.js"
 import { NotFoundError } from "../../errors.js"
 import type { Filter, PersistenceModelType } from "../../services/Store.js"
@@ -23,7 +27,7 @@ export function get<
 ) {
   return self
     .find(id)
-    .flatMap((_) => _.encaseInEffect(() => new NotFoundError<ItemType>({ type: self.itemType, id })))
+    .pipe(Effect.flatMap((_) => Effect.mapError(_, () => new NotFoundError<ItemType>({ type: self.itemType, id }))))
 }
 
 /**
@@ -109,12 +113,11 @@ export function projectEffect<
   >
 ): Effect<S[], E, R> {
   // TODO: a projection that gets sent to the db instead.
-  return map.flatMap((f) =>
+  return Effect.flatMap(map, (f) =>
     self
       .utils
       .filter(f)
-      .map((_) => f.collect ? _.filterMap(f.collect) : _ as unknown as S[])
-  )
+      .pipe(Effect.map((_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown as S[])))
 }
 
 /**
@@ -168,7 +171,7 @@ export function project<
     skip?: number
   }
 ): Effect<S[]> {
-  return self.projectEffect(Effect.sync(() => map))
+  return projectEffect(self, Effect.sync(() => map))
 }
 
 /**
@@ -184,9 +187,8 @@ export function count<
   self: RepositoryBaseC<T, PM, Evt, ItemType>,
   filter?: Filter<PM>
 ) {
-  return self
-    .projectEffect(Effect.sync(() => ({ filter })))
-    .map((_) => NonNegativeInt(_.length))
+  return projectEffect(self, Effect.sync(() => ({ filter })))
+    .pipe(Effect.map((_) => NonNegativeInt(_.length)))
 }
 
 /**
@@ -205,11 +207,12 @@ export function queryEffect<
   // 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 ? self.utils.filter(f) : self.utils.all)
-      .flatMap((_) => self.utils.parseMany(_))
-      .map((_) => f.collect ? _.filterMap(f.collect) : _ as any as S[])
-  )
+      .pipe(
+        Effect.flatMap((_) => self.utils.parseMany(_)),
+        Effect.map((_) => f.collect ? ReadonlyArray.filterMap(_, f.collect) : _ as unknown[] as S[])
+      ))
 }
 
 /**
@@ -253,16 +256,24 @@ export function queryOneEffect<
   // 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 ? self.utils.filter({ filter: f.filter, limit: 1 }) : self.utils.all)
-      .flatMap((_) => self.utils.parseMany(_))
-      .flatMap((_) =>
-        (f.collect ? _.filterMap(f.collect) : _ as any as S[])
-          .toNonEmpty
-          .encaseInEffect(() => new NotFoundError<ItemType>({ type: self.itemType, id: f.filter }))
-          .map((_) => _[0])
-      )
-  )
+      .pipe(
+        Effect.flatMap((_) => self.utils.parseMany(_)),
+        Effect
+          .flatMap((_) =>
+            toNonEmptyArray(
+              f.collect
+                ? ReadonlyArray.filterMap(_, f.collect)
+                : _ as unknown[] as S[]
+            )
+              .pipe(
+                Effect.mapError(() => new NotFoundError<ItemType>({ type: self.itemType, id: f.filter })),
+                Effect
+                  .map((_) => _[0])
+              )
+          )
+      ))
 }
 
 /**
@@ -279,7 +290,7 @@ export function query<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: { filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
 ) {
-  return self.queryEffect(Effect.sync(() => map))
+  return queryEffect(self, Effect.sync(() => map))
 }
 
 /**
@@ -314,7 +325,7 @@ export function queryOne<
   self: RepositoryBaseC<T, PM, Evt, ItemType>,
   map: { filter?: Filter<PM>; collect?: (t: T) => Option<S> }
 ) {
-  return self.queryOneEffect(Effect.sync(() => map))
+  return queryOneEffect(self, Effect.sync(() => map))
 }
 
 /**
@@ -367,7 +378,7 @@ export function queryAndSaveOnePureEffect(
 ) {
   return (pure: any) =>
     queryOneEffect(self, map)
-      .flatMap((_) => saveWithPure_(self, _, pure))
+      .pipe(Effect.flatMap((_) => saveWithPure_(self, _, pure)))
 }
 
 /**
@@ -428,7 +439,7 @@ export function queryAndSavePureEffect<
 ) {
   return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, S[], S2[]>>) =>
     queryEffect(self, map)
-      .flatMap((_) => self.saveManyWithPure_(_, pure))
+      .pipe(Effect.flatMap((_) => saveManyWithPure_(self, _, pure)))
 }
 
 /**
@@ -444,7 +455,7 @@ export function queryAndSavePure<
   self: RepositoryBaseC<T, PM, Evt, ItemType>,
   map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
 ) {
-  return self.queryAndSavePureEffect(Effect.sync(() => map))
+  return queryAndSavePureEffect(self, Effect.sync(() => map))
 }
 
 /**
@@ -470,7 +481,7 @@ export function byIdAndSaveWithPure<
   ItemType extends string
 >(self: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"]) {
   return <R, A, E, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) =>
-    get(self, id).flatMap((item) => saveWithPure_(self, item, pure))
+    get(self, id).pipe(Effect.flatMap((item) => saveWithPure_(self, item, pure)))
 }
 
 /**
@@ -509,7 +520,7 @@ export function saveManyWithPure_<
 ) {
   return saveAllWithEffectInt(
     self,
-    pure.runTerm([...items])
+    runTerm(pure, [...items])
   )
 }
 
@@ -533,9 +544,9 @@ export function saveWithPure_<
 ) {
   return saveAllWithEffectInt(
     self,
-    pure
-      .runTerm(item)
-      .map(([item, events, a]) => [[item], events, a])
+    runTerm(pure, item)
+      .pipe(Effect
+        .map(([item, events, a]) => [[item], events, a]))
   )
 }
 
@@ -552,10 +563,7 @@ export function saveAllWithEffectInt<
   self: RepositoryBaseC<T, PM, Evt, ItemType>,
   gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>
 ) {
-  return gen
-    .flatMap(
-      ([items, events, a]) => self.saveAndPublish(items, events).map(() => a)
-    )
+  return Effect.flatMap(gen, ([items, events, a]) => self.saveAndPublish(items, events).pipe(Effect.map(() => a)))
 }
 
 /**
@@ -577,7 +585,7 @@ export function queryAndSavePureEffectBatched<
 ) {
   return <R2, A, E2, S2 extends T>(pure: Effect<A, E2, FixEnv<R2, Evt, S[], S2[]>>) =>
     queryEffect(self, map)
-      .flatMap((_) => self.saveManyWithPureBatched_(_, pure, batchSize))
+      .pipe(Effect.flatMap((_) => saveManyWithPureBatched_(self, _, pure, batchSize)))
 }
 
 /**
@@ -595,7 +603,7 @@ export function queryAndSavePureBatched<
   map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number },
   batchSize = 100
 ) {
-  return self.queryAndSavePureEffectBatched(Effect.sync(() => map), batchSize)
+  return queryAndSavePureEffectBatched(self, Effect.sync(() => map), batchSize)
 }
 
 /**
@@ -630,14 +638,14 @@ export function saveManyWithPureBatched_<
   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(
         self,
-        pure.runTerm(batch)
+        runTerm(pure, batch)
       )
-    )
+  )
 }
 
 /**
@@ -683,7 +691,7 @@ export function itemUpdateWithEffect<
   id: T["id"],
   mod: (item: T) => Effect<T, E, R>
 ) {
-  return repo.get(id).andThen(mod).andThen(repo.save)
+  return get(repo, id).pipe(Effect.andThen(mod), Effect.andThen(save(repo)))
 }
 
 /**