@effect-app/infra 0.48.0 → 0.49.0

package/_src/services/Operations/service.ts

@@ -19,10 +19,13 @@ export abstract class Operations extends ServiceTaggedClass<Operations>()(Operat
 export function forkOperation<R, E, A>(self: Effect<R, E, A>) {
   return Debug.untraced(() =>
     Operations.flatMap(
-      Operations =>
-        Scope.make()
-          .flatMap(scope =>
-            Operations.register.extend(scope)
+      (Operations) =>
+        Scope
+          .make()
+          .flatMap((scope) =>
+            Operations
+              .register
+              .extend(scope)
               .tap(() => self.use(scope).forkDaemonReportRequestUnexpected)
           )
     )
@@ -40,13 +43,16 @@ export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<R,
  * @tsplus static effect/io/Effect.Ops forkOperation
  */
 export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<R, E, A>) {
-  return Debug.untraced(restore =>
+  return Debug.untraced((restore) =>
     Operations.flatMap(
-      Operations =>
-        Scope.make()
-          .flatMap(scope =>
-            Operations.register.extend(scope)
-              .tap(id => restore(self)(id).use(scope).forkDaemonReportRequestUnexpected)
+      (Operations) =>
+        Scope
+          .make()
+          .flatMap((scope) =>
+            Operations
+              .register
+              .extend(scope)
+              .tap((id) => restore(self)(id).use(scope).forkDaemonReportRequestUnexpected)
           )
     )
   )
@@ -59,14 +65,17 @@ export function forkOperationWithEffect<R, R2, E, E2, A, A2>(
   self: (id: OperationId) => Effect<R, E, A>,
   fnc: (id: OperationId) => Effect<R2, E2, A2>
 ) {
-  return Debug.untraced(restore =>
+  return Debug.untraced((restore) =>
     Operations.flatMap(
-      Operations =>
-        Scope.make()
-          .flatMap(scope =>
-            Operations.register.extend(scope)
-              .tap(opId => restore(self)(opId).use(scope).forkDaemonReportRequestUnexpected)
-              .tap(opId => restore(fnc)(opId).interruptible.forkScoped.extend(scope))
+      (Operations) =>
+        Scope
+          .make()
+          .flatMap((scope) =>
+            Operations
+              .register
+              .extend(scope)
+              .tap((opId) => restore(self)(opId).use(scope).forkDaemonReportRequestUnexpected)
+              .tap((opId) => restore(fnc)(opId).interruptible.forkScoped.extend(scope))
           )
     )
   )

package/_src/services/QueueMaker/errors.ts

@@ -14,10 +14,10 @@ export class FatalQueueException<E> extends CauseException<E> {
   }
 }
 
-const reportQueueError_ = reportError(cause => new MessageException(cause))
+const reportQueueError_ = reportError((cause) => new MessageException(cause))
 
 export const reportQueueError = <E>(cause: Cause<E>, context?: Record<string, unknown> | undefined) =>
-  RequestContextContainer.getOption.flatMap(requestContext =>
+  RequestContextContainer.getOption.flatMap((requestContext) =>
     reportQueueError_(cause, { requestContext: requestContext.value, ...context })
   )
 
@@ -35,16 +35,17 @@ export function forkDaemonReportQueue<R, E, A>(self: Effect<R, E, A>) {
 }
 
 export const reportFatalQueueError = reportError(
-  cause => new FatalQueueException(cause)
+  (cause) => new FatalQueueException(cause)
 )
 
 export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
   const report = reportNonInterruptedFailureCause(context)
   return <R, E, A>(inp: Effect<R, E, A>): Effect<R, never, Exit<E, A>> =>
-    inp.exit
-      .flatMap(result =>
+    inp
+      .exit
+      .flatMap((result) =>
         result.match(
-          cause => report(cause).map(() => result),
+          (cause) => report(cause).map(() => result),
           () => Effect(result)
         )
       )

package/_src/services/QueueMaker/memQueue.ts

@@ -39,17 +39,18 @@ export function makeMemQueue<
         Effect.gen(function*($) {
           const requestContext = yield* $(RequestContextContainer.get)
           return yield* $(
-            messages.forEachEffect(m =>
-              // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-              Effect(
-                JSON.stringify(
-                  encoder({ body: m, meta: requestContext })
+            messages
+              .forEachEffect((m) =>
+                // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+                Effect(
+                  JSON.stringify(
+                    encoder({ body: m, meta: requestContext })
+                  )
                 )
+                  // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
+                  .flatMap((_) => q.offer(_))
+                  .asUnit
               )
-                // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
-                .flatMap(_ => q.offer(_))
-                .asUnit
-            )
               .forkDaemonReportQueue
           )
         }),
@@ -79,8 +80,9 @@ export function makeMemQueue<
                 )
             )
         return yield* $(
-          qDrain.take()
-            .flatMap(x => processMessage(x).uninterruptible.fork.flatMap(_ => _.join))
+          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.
             .apply(silenceAndReportError)

package/_src/services/QueueMaker/sbqueue.ts

@@ -50,8 +50,9 @@ export function makeServiceBusQueue<
         const handleEvent = yield* $(makeHandleEvent)
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function processMessage(messageBody: any) {
-          return Effect.sync(() => JSON.parse(messageBody))
-            .flatMap(x => parseDrain(x))
+          return Effect
+            .sync(() => JSON.parse(messageBody))
+            .flatMap((x) => parseDrain(x))
             .orDie
             .flatMap(({ body, meta }) =>
               Effect
@@ -78,8 +79,8 @@ export function makeServiceBusQueue<
 
         return yield* $(
           subscribe({
-            processMessage: x => processMessage(x.body).uninterruptible.flatMap(_ => _.done),
-            processError: err => Effect(captureException(err.error))
+            processMessage: (x) => processMessage(x.body).uninterruptible.flatMap((_) => _.done),
+            processError: (err) => Effect(captureException(err.error))
           })
             .provideSomeLayer(receiverLayer)
         )
@@ -89,17 +90,18 @@ export function makeServiceBusQueue<
         Effect.gen(function*($) {
           const requestContext = yield* $(RequestContextContainer.get)
           return yield* $(
-            Effect.promise(() =>
-              s.sendMessages(
-                messages.map(x => ({
-                  body: JSON.stringify(
-                    encoder({ body: x, meta: requestContext })
-                  ),
-                  messageId: x.id, /* correllationid: requestId */
-                  contentType: "application/json"
-                }))
+            Effect
+              .promise(() =>
+                s.sendMessages(
+                  messages.map((x) => ({
+                    body: JSON.stringify(
+                      encoder({ body: x, meta: requestContext })
+                    ),
+                    messageId: x.id, /* correllationid: requestId */
+                    contentType: "application/json"
+                  }))
+                )
               )
-            )
               .forkDaemonReportQueue
           )
         })

package/_src/services/Repository.ts

@@ -20,7 +20,7 @@ export interface Repository<
 > {
   itemType: ItemType
   find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Option<T>>
-  all: Effect<ContextMap, never, Chunk<T>>
+  all: Effect<ContextMap, never, T[]>
   saveAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
@@ -32,8 +32,8 @@ export interface Repository<
       setEtag: (id: string, eTag: string | undefined) => void
     ) => unknown // TODO
     parse: (a: unknown, env?: ParserEnv | undefined) => T
-    all: Effect<ContextMap, never, Chunk<PM>>
-    filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<ContextMap, never, Chunk<PM>>
+    all: Effect<ContextMap, never, PM[]>
+    filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<ContextMap, never, PM[]>
   }
 }
 
@@ -61,7 +61,7 @@ export function get<
   self: Repository<T, PM, Evt, ItemType>,
   id: T["id"]
 ) {
-  return self.find(id).flatMap(_ => _.encaseInEffect(() => new NotFoundError(self.itemType, id)))
+  return self.find(id).flatMap((_) => _.encaseInEffect(() => new NotFoundError(self.itemType, id)))
 }
 
 /**
@@ -73,7 +73,7 @@ export function filter<
   Evt,
   ItemType extends string
 >(self: Repository<T, PM, Evt, ItemType>, filter: Predicate<T>) {
-  return self.all.map(_ => _.filter(filter))
+  return self.all.map((_) => _.filter(filter))
 }
 
 /**
@@ -85,7 +85,7 @@ export function filterAll<
   Evt,
   ItemType extends string,
   S extends T
->(self: Repository<T, PM, Evt, ItemType>, map: (items: Chunk<T>) => Chunk<S>) {
+>(self: Repository<T, PM, Evt, ItemType>, map: (items: T[]) => S[]) {
   return self.all.map(map)
 }
 
@@ -99,7 +99,7 @@ export function collect<
   ItemType extends string,
   S extends T
 >(self: Repository<T, PM, Evt, ItemType>, collect: (item: T) => Option<S>) {
-  return self.all.map(_ => _.filterMap(collect))
+  return self.all.map((_) => _.filterMap(collect))
 }
 
 /**
@@ -131,9 +131,9 @@ export function projectEffect<
   map: Effect<R, E, { filter?: Filter<PM>; collect?: (t: PM) => Option<S>; limit?: number; skip?: number }>
 ) {
   // TODO: a projection that gets sent to the db instead.
-  return map.flatMap(f =>
+  return map.flatMap((f) =>
     (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip }) : self.utils.all)
-      .map(_ => f.collect ? _.filterMap(f.collect) : _ as unknown as Chunk<S>)
+      .map((_) => f.collect ? _.filterMap(f.collect) : _ as unknown as S[])
   )
 }
 
@@ -170,16 +170,16 @@ export function queryEffect<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: Effect<R, E, { filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }>
 ) {
-  return map.flatMap(f =>
+  return map.flatMap((f) =>
     (f.filter ? self.utils.filter(f.filter, { limit: f.limit, skip: f.skip }) : self.utils.all)
-      .flatMap(items =>
-        Do($ => {
+      .flatMap((items) =>
+        Do(($) => {
           const { set } = $(ContextMap)
-          return items.map(_ => self.utils.mapReverse(_, set))
+          return items.map((_) => self.utils.mapReverse(_, set))
         })
       )
-      .map(_ => _.map(_ => self.utils.parse(_)))
-      .map(_ => f.collect ? _.filterMap(f.collect) : _ as unknown as Chunk<S>)
+      .map((_) => _.map((_) => self.utils.parse(_)))
+      .map((_) => f.collect ? _.filterMap(f.collect) : _ as unknown as S[])
   )
 }
 
@@ -199,20 +199,20 @@ export function queryOneEffect<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: Effect<R, E, { filter?: Filter<PM>; collect?: (t: T) => Option<S> }>
 ) {
-  return map.flatMap(f =>
+  return map.flatMap((f) =>
     (f.filter ? self.utils.filter(f.filter, { limit: 1 }) : self.utils.all)
-      .flatMap(items =>
-        Do($ => {
+      .flatMap((items) =>
+        Do(($) => {
           const { set } = $(ContextMap)
-          return items.map(_ => self.utils.mapReverse(_, set))
+          return items.map((_) => self.utils.mapReverse(_, set))
         })
       )
-      .map(_ => _.map(_ => self.utils.parse(_)))
-      .flatMap(_ =>
-        (f.collect ? _.filterMap(f.collect) : _ as unknown as Chunk<S>)
-          .toNonEmptyArray.encaseInEffect(() => new NotFoundError(self.itemType, JSON.stringify(f.filter))).map(_ =>
-            _[0]
-          )
+      .map((_) => _.map((_) => self.utils.parse(_)))
+      .flatMap((_) =>
+        (f.collect ? _.filterMap(f.collect) : _ as unknown as S[])
+          .toNonEmpty
+          .encaseInEffect(() => new NotFoundError(self.itemType, JSON.stringify(f.filter)))
+          .map((_) => _[0])
       )
   )
 }
@@ -267,10 +267,10 @@ export function queryAndSavePureEffect<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: Effect<R, E, { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }>
 ) {
-  return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, Chunk<S>, Chunk<S2>>, E2, A>) =>
-    Debug.untraced(restore =>
+  return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, S[], S2[]>, E2, A>) =>
+    Debug.untraced((restore) =>
       queryEffect(self, map)
-        .flatMap(restore(_ => self.saveManyWithPure_(_, pure)))
+        .flatMap(restore((_) => self.saveManyWithPure_(_, pure)))
     )
 }
 
@@ -300,7 +300,7 @@ export function saveManyWithPure<
   Evt,
   ItemType extends string
 >(self: Repository<T, PM, Evt, ItemType>) {
-  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>) =>
+  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>) =>
   (items: Iterable<S1>) => saveManyWithPure_(self, items, pure)
 }
 
@@ -314,7 +314,7 @@ export function byIdAndSaveWithPure<
   ItemType extends string
 >(self: Repository<T, PM, Evt, ItemType>, id: T["id"]) {
   return <R, A, E, S2 extends T>(pure: Effect<FixEnv<R, Evt, T, S2>, E, A>) =>
-    get(self, id).flatMap(item => saveWithPure_(self, item, pure))
+    get(self, id).flatMap((item) => saveWithPure_(self, item, pure))
 }
 
 /**
@@ -350,11 +350,11 @@ export function saveManyWithPure_<
 >(
   self: Repository<T, PM, Evt, ItemType>,
   items: Iterable<S1>,
-  pure: Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>
+  pure: Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>
 ) {
   return saveAllWithEffectInt(
     self,
-    pure.runTerm(items.toChunk)
+    pure.runTerm([...items])
   )
 }
 
@@ -379,7 +379,8 @@ export function saveWithPure_<
 ) {
   return saveAllWithEffectInt(
     self,
-    pure.runTerm(item)
+    pure
+      .runTerm(item)
       .map(([item, events, a]) => [[item], events, a])
   )
 }
@@ -397,7 +398,7 @@ export function saveAllWithEffectInt<
   self: Repository<T, PM, Evt, ItemType>,
   gen: Effect<R, E, readonly [Iterable<P>, Iterable<Evt>, A]>
 ) {
-  return Debug.untraced(restore =>
+  return Debug.untraced((restore) =>
     gen
       .flatMap(
         ([items, events, a]) => restore(() => self.saveAndPublish(items, events))().map(() => a)
@@ -422,9 +423,9 @@ export function queryAndSavePureEffectBatched<
   map: Effect<R, E, { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }>,
   batchSize = 100
 ) {
-  return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, Chunk<S>, Chunk<S2>>, E2, A>) =>
+  return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, S[], S2[]>, E2, A>) =>
     queryEffect(self, map)
-      .flatMap(_ => self.saveManyWithPureBatched_(_, pure, batchSize))
+      .flatMap((_) => self.saveManyWithPureBatched_(_, pure, batchSize))
 }
 
 /**
@@ -454,7 +455,7 @@ export function saveManyWithPureBatched<
   Evt,
   ItemType extends string
 >(self: Repository<T, PM, Evt, ItemType>, batchSize = 100) {
-  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>) =>
+  return <R, A, E, S1 extends T, S2 extends T>(pure: Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>) =>
   (items: Iterable<S1>) => saveManyWithPureBatched_(self, items, pure, batchSize)
 }
 
@@ -475,14 +476,15 @@ export function saveManyWithPureBatched_<
 >(
   self: Repository<T, PM, Evt, ItemType>,
   items: Iterable<S1>,
-  pure: Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>,
+  pure: Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>,
   batchSize = 100
 ) {
-  return items.chunk(batchSize)
-    .forEachEffect(batch =>
+  return items
+    .chunk(batchSize)
+    .forEachEffect((batch) =>
       saveAllWithEffectInt(
         self,
-        pure.runTerm(batch.toChunk)
+        pure.runTerm(batch)
       )
     )
 }
@@ -491,8 +493,8 @@ const anyDSL = makeDSL<any, any, any>()
 
 export type AllDSL<T, Evt> =
   & (<R, A, E, S1 extends T, S2 extends T>(
-    pure: (dsl: PureDSL<Chunk<S1>, Chunk<S2>, Evt>) => Effect<R, E, A>
-  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>)
+    pure: (dsl: PureDSL<S1[], S2[], Evt>) => Effect<R, E, A>
+  ) => Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>)
   & AllDSLExt<T, Evt>
 
 /**
@@ -500,11 +502,11 @@ export type AllDSL<T, Evt> =
  */
 export interface AllDSLExt<T, Evt> {
   modify: <R, E, A, S1 extends T, S2 extends T>(
-    pure: (items: Chunk<S1>, dsl: PureDSL<Chunk<S1>, Chunk<S2>, Evt>) => Effect<R, E, A>
-  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, A>
+    pure: (items: S1[], dsl: PureDSL<S1[], S2[], Evt>) => Effect<R, E, A>
+  ) => Effect<FixEnv<R, Evt, S1[], S2[]>, E, A>
   update: <R, E, S1 extends T, S2 extends T>(
-    pure: (items: Chunk<S1>, log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<R, E, Chunk<S2>>
-  ) => Effect<FixEnv<R, Evt, Chunk<S1>, Chunk<S2>>, E, Chunk<S2>>
+    pure: (items: S1[], log: (...evt: Evt[]) => PureLogT<Evt>) => Effect<R, E, S2[]>
+  ) => Effect<FixEnv<R, Evt, S1[], S2[]>, E, S2[]>
 }
 
 export function makeAllDSL<T, Evt>() {
@@ -542,9 +544,9 @@ export function updateWithOne<T, Evt, S1 extends T, S2 extends T>(self: OneDSL<T
  */
 export function updateWith<T, Evt, S1 extends T, S2 extends T>(
   self: AllDSL<T, Evt>,
-  upd: (item: Chunk<S1>) => Chunk<S2>
+  upd: (item: S1[]) => S2[]
 ) {
-  return self.update((_: Chunk<S1>) => Effect(upd(_)))
+  return self.update((_: S1[]) => Effect(upd(_)))
 }
 
 export function makeOneDSL<T, Evt>(): OneDSL<T, Evt> {
@@ -564,7 +566,7 @@ export function makeDSL<S1, S2, Evt>() {
       dsl: PureDSL<S1, S2, Evt>
     ) => Effect<R, E, A>
   ): Effect<FixEnv<R, Evt, S1, S2>, E, A> {
-    return dsl.get.flatMap(items => pure(items, dsl)) as any
+    return dsl.get.flatMap((items) => pure(items, dsl)) as any
   }
 
   function update<
@@ -576,7 +578,7 @@ export function makeDSL<S1, S2, Evt>() {
       log: (...evt: Evt[]) => PureLogT<Evt>
     ) => Effect<R, E, S2>
   ): Effect<FixEnv<R, Evt, S1, S2>, E, S2> {
-    return dsl.get.flatMap(items => pure(items, dsl.log).tap(dsl.set)) as any
+    return dsl.get.flatMap((items) => pure(items, dsl.log).tap(dsl.set)) as any
   }
 
   function withDSL<

package/_src/services/RepositoryBase.ts

@@ -8,7 +8,7 @@ import type {} from "@effect/data/Hash"
 import type { Opt } from "@effect-app/core/Option"
 import { makeCodec } from "@effect-app/infra/api/codec"
 import { makeFilters } from "@effect-app/infra/filter"
-import type { Chunk, Schema } from "@effect-app/prelude"
+import type { Schema } from "@effect-app/prelude"
 import { EParserFor } from "@effect-app/prelude/schema"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
 
@@ -22,7 +22,7 @@ export const RepositoryBase = <Service>() => {
     abstract class RepositoryBaseC implements Repository<T, PM, Evt, ItemType> {
       itemType: ItemType = itemType
       abstract find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Opt<T>>
-      abstract all: Effect<ContextMap, never, Chunk<T>>
+      abstract all: Effect<ContextMap, never, T[]>
       abstract saveAndPublish: (
         items: Iterable<T>,
         events?: Iterable<Evt>
@@ -33,8 +33,8 @@ export const RepositoryBase = <Service>() => {
           setEtag: (id: string, eTag: string | undefined) => void
         ) => unknown // TODO
         parse: (a: unknown, env?: ParserEnv | undefined) => T
-        all: Effect<ContextMap, never, Chunk<PM>>
-        filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<ContextMap, never, Chunk<PM>>
+        all: Effect<ContextMap, never, PM[]>
+        filter: (filter: Filter<PM>, cursor?: { limit?: number; skip?: number }) => Effect<ContextMap, never, PM[]>
       }
       abstract remove: (item: T) => Effect<ContextMap, never, void>
       static where = makeWhere<PM>()
@@ -94,24 +94,25 @@ export function makeRepo<
         partitionValue?: (a: PM) => string
       }
     ) {
-      return Do($ => {
+      return Do(($) => {
         const store = $(mkStore(makeInitial, config))
 
-        const allE = store.all.flatMap(items =>
-          Do($ => {
+        const allE = store.all.flatMap((items) =>
+          Do(($) => {
             const { set } = $(ContextMap)
-            return items.map(_ => mapReverse(_, set))
+            return items.map((_) => mapReverse(_, set))
           })
         )
 
-        const all = allE.flatMap(_ => _.forEachEffect(EParserFor(schema).condemnDie))
+        const all = allE.flatMap((_) => _.forEachEffect(EParserFor(schema).condemnDie))
 
         function findE(id: T["id"]) {
-          return store.find(id)
-            .flatMap(items =>
-              Do($ => {
+          return store
+            .find(id)
+            .flatMap((items) =>
+              Do(($) => {
                 const { set } = $(ContextMap)
-                return items.map(_ => mapReverse(_, set))
+                return items.map((_) => mapReverse(_, set))
               })
             )
         }
@@ -122,12 +123,12 @@ export function makeRepo<
 
         const saveAllE = (a: Iterable<E>) =>
           Effect(a.toNonEmptyArray)
-            .flatMapOpt(a =>
-              Do($ => {
+            .flatMapOpt((a) =>
+              Do(($) => {
                 const { get, set } = $(ContextMap)
-                const items = a.mapNonEmpty(_ => mapToPersistenceModel(_, get))
+                const items = a.mapNonEmpty((_) => mapToPersistenceModel(_, get))
                 const ret = $(store.batchSet(items))
-                ret.forEach(_ => set(_.id, _._etag))
+                ret.forEach((_) => set(_.id, _._etag))
               })
             )
 
@@ -141,7 +142,7 @@ export function makeRepo<
 
         const encode = Encoder.for(schema)
         function remove(item: T) {
-          return Do($ => {
+          return Do(($) => {
             const { get, set } = $(ContextMap)
             const e = encode(item)
             $(store.remove(mapToPersistenceModel(e, get)))
@@ -156,9 +157,10 @@ export function makeRepo<
           utils: {
             mapReverse,
             parse: Parser.for(schema).unsafe,
-            filter: store.filter
-              .flow(_ => _.tap(items => ContextMap.map(({ set }) => items.forEach(_ => set(_.id, _._etag))))),
-            all: store.all.tap(items => ContextMap.map(({ set }) => items.forEach(_ => set(_.id, _._etag))))
+            filter: store
+              .filter
+              .flow((_) => _.tap((items) => ContextMap.map(({ set }) => items.forEach((_) => set(_.id, _._etag))))),
+            all: store.all.tap((items) => ContextMap.map(({ set }) => items.forEach((_) => set(_.id, _._etag))))
           },
           itemType: name,
           find,
@@ -189,7 +191,7 @@ export function removeById<
   self: Repository<T, PM, Evt, ItemType>,
   id: T["id"]
 ) {
-  return self.get(id).flatMap(_ => self.remove(_))
+  return self.get(id).flatMap((_) => self.remove(_))
 }
 
 export function makeWhere<PM extends { id: string; _etag: string | undefined }>() {
@@ -206,7 +208,7 @@ export function makeWhere<PM extends { id: string; _etag: string | undefined }>(
     ) => Where | readonly [Where, ...Where[]],
     mode?: "or" | "and"
   ) {
-    return makeFilter_(f => {
+    return makeFilter_((f) => {
       const m = makeWhere ? makeWhere(f) : []
       return ({
         mode,
@@ -241,7 +243,7 @@ export function makeStore<
     const [_dec, encode] = makeCodec(schema)
     function encodeToPM() {
       const getEtag = () => undefined
-      return flow(encode, v => mapToPersistenceModel(v, getEtag))
+      return flow(encode, (v) => mapToPersistenceModel(v, getEtag))
     }
 
     function mapToPersistenceModel(
@@ -257,7 +259,7 @@ export function makeStore<
         partitionValue?: (a: PM) => string
       }
     ) {
-      return Do($ => {
+      return Do(($) => {
         const { make } = $(StoreMaker)
 
         const store = $(
@@ -265,11 +267,12 @@ export function makeStore<
             pluralize(name),
             makeInitial
               ? makeInitial
-                .map(_ => _.map(encodeToPM()))
+                .map((_) => _.map(encodeToPM()))
               : undefined,
             {
               ...config,
-              partitionValue: config?.partitionValue ?? (_ => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
+              partitionValue: config?.partitionValue
+                ?? ((_) => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
             }
           )
         )
@@ -352,7 +355,9 @@ export const RepositoryDefaultImpl = <Service>() => {
           partitionValue?: (a: PM) => string
         }
       ) {
-        return this.make(publishEvents, makeInitial, config).map(impl => new this(impl) as any as Service).toLayer(this)
+        return this.make(publishEvents, makeInitial, config).map((impl) => new this(impl) as any as Service).toLayer(
+          this
+        )
       }
       static repo: any
       constructor(

package/_src/services/RequestContextContainer.ts

@@ -7,11 +7,12 @@ export abstract class RequestContextContainer extends TagClass<RequestContextCon
   abstract readonly requestContext: Effect<never, never, RequestContext>
   abstract readonly update: (f: (rc: RequestContext) => RequestContext) => Effect<never, never, void>
   static get get(): Effect<RequestContextContainer, never, RequestContext> {
-    return RequestContextContainer.flatMap(_ => _.requestContext)
+    return RequestContextContainer.flatMap((_) => _.requestContext)
   }
   static get getOption() {
-    return Effect.contextWith((_: Context<never>) => Context.getOption(_, RequestContextContainer))
-      .flatMap(requestContext =>
+    return Effect
+      .contextWith((_: Context<never>) => Context.getOption(_, RequestContextContainer))
+      .flatMap((requestContext) =>
         requestContext.isSome()
           ? requestContext.value.requestContext.map(Option.some)
           : Effect(Option.none)