@effect-app/infra 1.23.2 → 1.23.4

package/src/services/RepositoryBase.ts

@@ -365,8 +365,8 @@ export function makeRepo<
         }
     ) {
       return Effect
-        .gen(function*($) {
-          const rctx = yield* $(Effect.context<R>())
+        .gen(function*() {
+          const rctx = yield* Effect.context<R>()
           const encodeMany = flow(
             S.encode(S.Array(schema)),
             Effect.provide(rctx),
@@ -379,18 +379,18 @@ export function makeRepo<
             Effect.withSpan("decodeMany", { captureStackTrace: false })
           )
 
-          const store = yield* $(mkStore(args.makeInitial, args.config))
-          const { get } = yield* $(ContextMapContainer)
+          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 pubCfg = yield* Effect.context<R2>()
           const pub = "publishEvents" in args
             ? flow(args.publishEvents, Effect.provide(pubCfg))
             : () => Effect.void
-          const changeFeed = yield* $(PubSub.unbounded<[T[], "save" | "remove"]>())
+          const changeFeed = yield* PubSub.unbounded<[T[], "save" | "remove"]>()
 
           const allE = cms
             .pipe(Effect.flatMap((cm) => Effect.map(store.all, (_) => _.map((_) => mapReverse(_, cm.set)))))
@@ -431,8 +431,8 @@ export function makeRepo<
             return Effect.flatMap(
               store.find(id),
               (item) =>
-                Effect.gen(function*($) {
-                  const { set } = yield* $(cms)
+                Effect.gen(function*() {
+                  const { set } = yield* cms
                   return item.pipe(Option.map((_) => mapReverse(_, set)))
                 })
             )
@@ -456,10 +456,10 @@ export function makeRepo<
                 Effect
                   .sync(() => toNonEmptyArray([...a])),
                 (a) =>
-                  Effect.gen(function*($) {
-                    const { get, set } = yield* $(cms)
+                  Effect.gen(function*() {
+                    const { get, set } = yield* cms
                     const items = a.map((_) => mapToPersistenceModel(_, get))
-                    const ret = yield* $(store.batchSet(items))
+                    const ret = yield* store.batchSet(items)
                     ret.forEach((_) => set(_.id, _._etag))
                   })
               )
@@ -489,23 +489,21 @@ export function makeRepo<
           }
 
           function removeAndPublish(a: Iterable<T>, events: Iterable<Evt> = []) {
-            return Effect.gen(function*($) {
-              const { get, set } = yield* $(cms)
+            return Effect.gen(function*() {
+              const { get, set } = yield* cms
               const it = [...a]
-              const items = yield* $(encodeMany(it).pipe(Effect.orDie))
+              const items = yield* encodeMany(it).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)))
+                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* 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"]))
+              yield* changeFeed.publish([it, "remove"])
             })
           }
 
@@ -691,28 +689,27 @@ export function makeStore<
         partitionValue?: (a: Encoded) => string
       }
     ) {
-      return Effect.gen(function*($) {
-        const { make } = yield* $(StoreMaker)
-
-        const store = yield* $(
-          make<Encoded, string, R | RInitial, EInitial>(
-            pluralize(name),
-            makeInitial
-              ? makeInitial
-                .pipe(
-                  Effect.flatMap(Effect.forEach(encodeToEncoded())),
-                  Effect.withSpan("Repository.makeInitial [effect-app/infra]", {
-                    attributes: { "repository.model_name": name }
-                  })
-                )
-              : undefined,
-            {
-              ...config,
-              partitionValue: config?.partitionValue
-                ?? ((_) => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
-            }
-          )
+      return Effect.gen(function*() {
+        const { make } = yield* StoreMaker
+
+        const store = yield* make<Encoded, string, R | RInitial, EInitial>(
+          pluralize(name),
+          makeInitial
+            ? makeInitial
+              .pipe(
+                Effect.flatMap(Effect.forEach(encodeToEncoded())),
+                Effect.withSpan("Repository.makeInitial [effect-app/infra]", {
+                  attributes: { "repository.model_name": name }
+                })
+              )
+            : undefined,
+          {
+            ...config,
+            partitionValue: config?.partitionValue
+              ?? ((_) => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
+          }
         )
+
         return store
       })
     }

package/src/services/Store/Cosmos/query.ts

@@ -1,6 +1,7 @@
 import { Array, Effect, Equivalence, pipe } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { assertUnreachable } from "effect-app/utils"
+import { InfraLogger } from "../../../logger.js"
 import type { FilterR, FilterResult } from "../filterApi/query.js"
 import type { SupportedValues } from "../service.js"
 
@@ -11,7 +12,7 @@ export function logQuery(q: {
     value: SupportedValues | readonly SupportedValues[]
   }[]
 }) {
-  return Effect
+  return InfraLogger
     .logDebug("cosmos query")
     .pipe(Effect.annotateLogs({
       query: q.query,
@@ -114,15 +115,15 @@ export function buildWhereCosmosQuery3(
           s += ` AND ${statement(e, i++)}`
           break
         case "or-scope": {
-          ;++l
+          ++l
           s += ` OR (\n${printN(l + 1)}${print(e.result)}\n${printN(l)})`
-          ;--l
+          --l
           break
         }
         case "and-scope": {
-          ;++l
+          ++l
           s += ` AND (\n${printN(l + 1)}${print(e.result)}\n${printN(l)})`
-          ;--l
+          --l
           break
         }
         case "where-scope": {

package/src/services/Store/Cosmos.ts

@@ -6,6 +6,7 @@ import { Array, Chunk, Duration, Effect, Layer, Option, pipe, Secret, Struct } f
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { dropUndefinedT } from "effect-app/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
+import { InfraLogger } from "../../logger.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
 import type { FilterArgs, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
@@ -15,27 +16,26 @@ class CosmosDbOperationError {
 } // TODO: Retry operation when running into RU limit.
 
 function makeCosmosStore({ prefix }: StorageConfig) {
-  return Effect.gen(function*($) {
-    const { db } = yield* $(CosmosClient)
+  return Effect.gen(function*() {
+    const { db } = yield* CosmosClient
     return {
       make: <Id extends string, Encoded extends Record<string, any> & { id: Id }, R = never, E = never>(
         name: string,
         seed?: Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) =>
-        Effect.gen(function*($) {
+        Effect.gen(function*() {
           type PM = PersistenceModelType<Encoded>
           const containerId = `${prefix}${name}`
-          yield* $(
-            Effect.promise(() =>
-              db.containers.createIfNotExists(dropUndefinedT({
-                id: containerId,
-                uniqueKeyPolicy: config?.uniqueKeys
-                  ? { uniqueKeys: config.uniqueKeys }
-                  : undefined
-              }))
-            )
+          yield* Effect.promise(() =>
+            db.containers.createIfNotExists(dropUndefinedT({
+              id: containerId,
+              uniqueKeyPolicy: config?.uniqueKeys
+                ? { uniqueKeys: config.uniqueKeys }
+                : undefined
+            }))
           )
+
           const defaultValues = config?.defaultValues ?? {}
           const container = db.container(containerId)
           const bulk = container.items.bulk.bind(container.items)
@@ -44,7 +44,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
 
           const bulkSet = (items: NonEmptyReadonlyArray<PM>) =>
             Effect
-              .gen(function*($) {
+              .gen(function*() {
                 // TODO: disable batching if need atomicity
                 // we delay and batch to keep low amount of RUs
                 const b = [...items].map(
@@ -77,51 +77,46 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 )
                 const batches = Chunk.toReadonlyArray(Array.chunk_(b, config?.maxBulkSize ?? 10))
 
-                const batchResult = yield* $(
-                  Effect.forEach(
-                    batches
-                      .map((x, i) => [i, x] as const),
-                    ([i, batch]) =>
-                      Effect
-                        .promise(() => bulk(batch.map(([, op]) => op)))
-                        .pipe(
-                          Effect
-                            .delay(Duration.millis(i === 0 ? 0 : 1100)),
-                          Effect
-                            .flatMap((responses) =>
-                              Effect.gen(function*($) {
-                                const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)
-                                if (r) {
-                                  return yield* $(
-                                    Effect.fail(
-                                      new OptimisticConcurrencyException(
-                                        { type: name, id: JSON.stringify(r.resourceBody?.["id"]) }
-                                      )
-                                    )
+                const batchResult = yield* Effect.forEach(
+                  batches
+                    .map((x, i) => [i, x] as const),
+                  ([i, batch]) =>
+                    Effect
+                      .promise(() => bulk(batch.map(([, op]) => op)))
+                      .pipe(
+                        Effect
+                          .delay(Duration.millis(i === 0 ? 0 : 1100)),
+                        Effect
+                          .flatMap((responses) =>
+                            Effect.gen(function*() {
+                              const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)
+                              if (r) {
+                                return yield* Effect.fail(
+                                  new OptimisticConcurrencyException(
+                                    { type: name, id: JSON.stringify(r.resourceBody?.["id"]) }
                                   )
-                                }
-                                const r2 = responses.find(
-                                  (x) => x.statusCode > 299 || x.statusCode < 200
                                 )
-                                if (r2) {
-                                  return yield* $(
-                                    Effect.die(
-                                      new CosmosDbOperationError(
-                                        "not able to update record: " + r2.statusCode
-                                      )
-                                    )
+                              }
+                              const r2 = responses.find(
+                                (x) => x.statusCode > 299 || x.statusCode < 200
+                              )
+                              if (r2) {
+                                return yield* Effect.die(
+                                  new CosmosDbOperationError(
+                                    "not able to update record: " + r2.statusCode
                                   )
-                                }
-                                return batch.map(([e], i) => ({
-                                  ...e,
-                                  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                  _etag: responses[i]!.eTag
-                                }))
-                              })
-                            )
-                        )
-                  )
+                                )
+                              }
+                              return batch.map(([e], i) => ({
+                                ...e,
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                _etag: responses[i]!.eTag
+                              }))
+                            })
+                          )
+                      )
                 )
+
                 return batchResult.flat() as unknown as NonEmptyReadonlyArray<Encoded>
               })
               .pipe(Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
@@ -162,7 +157,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 return Effect
                   .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
                   .pipe(Effect.flatMap((x) =>
-                    Effect.gen(function*($) {
+                    Effect.gen(function*() {
                       const result = x.result ?? []
                       const firstFailed = result.find(
                         (x: any) => x.statusCode > 299 || x.statusCode < 200
@@ -170,15 +165,11 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                       if (firstFailed) {
                         const code = firstFailed.statusCode ?? 0
                         if (code === 412 || code === 404) {
-                          return yield* $(
-                            new OptimisticConcurrencyException({ type: name, id: "batch" })
-                          )
+                          return yield* new OptimisticConcurrencyException({ type: name, id: "batch" })
                         }
 
-                        return yield* $(
-                          Effect.die(
-                            new CosmosDbOperationError("not able to update record: " + code)
-                          )
+                        return yield* Effect.die(
+                          new CosmosDbOperationError("not able to update record: " + code)
                         )
                       }
 
@@ -347,41 +338,35 @@ function makeCosmosStore({ prefix }: StorageConfig) {
           }
 
           // handle mock data
-          const marker = yield* $(
-            Effect.promise(() =>
-              container
-                .item(importedMarkerId, importedMarkerId)
-                .read<{ id: string }>()
-                .then(({ resource }) => Option.fromNullable(resource))
-            )
+          const marker = yield* Effect.promise(() =>
+            container
+              .item(importedMarkerId, importedMarkerId)
+              .read<{ id: string }>()
+              .then(({ resource }) => Option.fromNullable(resource))
           )
 
           if (!Option.isSome(marker)) {
-            console.log("Creating mock data for " + name)
+            yield* InfraLogger.logInfo("Creating mock data for " + name)
             if (seed) {
-              const m = yield* $(seed)
-              yield* $(
-                Effect.flatMapOption(
-                  Effect.succeed(toNonEmptyArray([...m])),
-                  (a) =>
-                    s.bulkSet(a).pipe(
-                      Effect.orDie,
-                      Effect
-                        // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
-                        .delay(Duration.millis(1100))
-                    )
-                )
+              const m = yield* seed
+              yield* Effect.flatMapOption(
+                Effect.succeed(toNonEmptyArray([...m])),
+                (a) =>
+                  s.bulkSet(a).pipe(
+                    Effect.orDie,
+                    Effect
+                      // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
+                      .delay(Duration.millis(1100))
+                  )
               )
             }
             // Mark as imported
-            yield* $(
-              Effect.promise(() =>
-                container.items.create({
-                  _partitionKey: importedMarkerId,
-                  id: importedMarkerId,
-                  ttl: -1
-                })
-              )
+            yield* Effect.promise(() =>
+              container.items.create({
+                _partitionKey: importedMarkerId,
+                id: importedMarkerId,
+                ttl: -1
+              })
             )
           }
           return s

package/src/services/Store/Disk.ts

@@ -17,7 +17,7 @@ function makeDiskStoreInt<Id extends string, Encoded extends { id: Id }, R, E>(
   defaultValues?: Partial<Encoded>
 ) {
   type PM = PersistenceModelType<Encoded>
-  return Effect.gen(function*($) {
+  return Effect.gen(function*() {
     if (namespace !== "primary") {
       dir = dir + "/" + namespace
       if (!fs.existsSync(dir)) {
@@ -68,18 +68,16 @@ function makeDiskStoreInt<Id extends string, Encoded extends { id: Id }, R, E>(
           )
     }
 
-    const store = yield* $(
-      makeMemoryStoreInt<Id, Encoded, R, E>(
-        name,
-        namespace,
-        !fs.existsSync(file)
-          ? seed
-          : fsStore.get,
-        defaultValues
-      )
+    const store = yield* makeMemoryStoreInt<Id, Encoded, R, E>(
+      name,
+      namespace,
+      !fs.existsSync(file)
+        ? seed
+        : fsStore.get,
+      defaultValues
     )
 
-    yield* $(store.all.pipe(Effect.flatMap(fsStore.setRaw)))
+    yield* store.all.pipe(Effect.flatMap(fsStore.setRaw))
 
     const sem = Effect.unsafeMakeSemaphore(1)
     const withPermit = sem.withPermits(1)
@@ -128,11 +126,11 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
         seed?: Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) =>
-        Effect.gen(function*($) {
+        Effect.gen(function*() {
           const storesSem = Effect.unsafeMakeSemaphore(1)
-          const primary = yield* $(makeDiskStoreInt(prefix, "primary", dir, name, seed, config?.defaultValues))
+          const primary = yield* makeDiskStoreInt(prefix, "primary", dir, name, seed, config?.defaultValues)
           const stores = new Map<string, Store<Encoded, Id>>([["primary", primary]])
-          const ctx = yield* $(Effect.context<R>())
+          const ctx = yield* Effect.context<R>()
           const getStore = !config?.allowNamespace
             ? Effect.succeed(primary)
             : FiberRef.get(storeId).pipe(Effect.flatMap((namespace) => {

package/src/services/Store/Memory.ts

@@ -3,6 +3,7 @@
 import { Array, Effect, FiberRef, flow, Option, Order, pipe, Ref, Struct } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { get } from "effect-app/utils"
+import { InfraLogger } from "../../logger.js"
 import type { RequestContext } from "../../RequestContext.js"
 import type { FilterArgs, PersistenceModelType, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
@@ -62,7 +63,7 @@ export const storeId = FiberRef.unsafeMake("primary")
 export const restoreFromRequestContext = (ctx: RequestContext) => FiberRef.set(storeId, ctx.namespace ?? "primary")
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
-  return Effect
+  return InfraLogger
     .logDebug("mem query")
     .pipe(Effect.annotateLogs({
       filter: JSON.stringify(
@@ -85,9 +86,9 @@ export function makeMemoryStoreInt<Id extends string, Encoded extends { id: Id }
   _defaultValues?: Partial<Encoded>
 ) {
   type PM = PersistenceModelType<Encoded>
-  return Effect.gen(function*($) {
+  return Effect.gen(function*() {
     const updateETag = makeUpdateETag(modelName)
-    const items_ = yield* $(seed ?? Effect.sync(() => []))
+    const items_ = yield* seed ?? Effect.sync(() => [])
     const defaultValues = _defaultValues ?? {}
 
     const items = new Map([...items_].map((_) => [_.id, { _etag: undefined, ...defaultValues, ..._ }] as const))
@@ -218,10 +219,10 @@ export const makeMemoryStore = () => ({
     seed?: Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
   ) =>
-    Effect.gen(function*($) {
+    Effect.gen(function*() {
       const storesSem = Effect.unsafeMakeSemaphore(1)
-      const primary = yield* $(makeMemoryStoreInt<Id, Encoded, R, E>(modelName, "primary", seed, config?.defaultValues))
-      const ctx = yield* $(Effect.context<R>())
+      const primary = yield* makeMemoryStoreInt<Id, Encoded, R, E>(modelName, "primary", seed, config?.defaultValues)
+      const ctx = yield* Effect.context<R>()
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace
         ? Effect.succeed(primary)

package/src/services/Store/utils.ts

@@ -12,24 +12,20 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
 }) as any)
 export const makeUpdateETag =
   (type: string) => <E extends PersistenceModelType<{ id: string }>>(e: E, current: Option<E>) =>
-    Effect.gen(function*($) {
+    Effect.gen(function*() {
       if (e._etag) {
-        yield* $(
-          Effect.mapError(
-            current,
-            () => new OptimisticConcurrencyException({ type, id: e.id, current: "", found: e._etag })
-          )
+        yield* Effect.mapError(
+          current,
+          () => new OptimisticConcurrencyException({ type, id: e.id, current: "", found: e._etag })
         )
       }
       if (Option.isSome(current) && current.value._etag !== e._etag) {
-        return yield* $(
-          new OptimisticConcurrencyException({
-            type,
-            id: current.value.id,
-            current: current.value._etag,
-            found: e._etag
-          })
-        )
+        return yield* new OptimisticConcurrencyException({
+          type,
+          id: current.value.id,
+          current: current.value._etag,
+          found: e._etag
+        })
       }
       const newE = makeETag(e)
       return newE