@effect-app/infra 0.198.1 → 0.199.0

package/src/services/Store/Disk.ts

@@ -3,6 +3,7 @@ import * as fu from "@effect-app/infra-adapters/fileUtil"
 
 import fs from "fs"
 
+import { Effect, FiberRef, flow } from "effect-app"
 import { makeMemoryStoreInt, storeId } from "./Memory.js"
 import type { PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
 import { StoreMaker } from "./service.js"
@@ -26,25 +27,34 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
     const fsStore = {
       get: fu
         .readTextFile(file)
-        .withSpan("Disk.read.readFile [effect-app/infra/Store]")
-        .flatMap((x) => Effect.sync(() => JSON.parse(x) as PM[]).withSpan("Disk.read.parse [effect-app/infra/Store]"))
-        .orDie
-        .withSpan("Disk.read [effect-app/infra/Store]", { attributes: { "disk.file": file } }),
+        .pipe(
+          Effect.withSpan("Disk.read.readFile [effect-app/infra/Store]"),
+          Effect.flatMap((x) =>
+            Effect.sync(() => JSON.parse(x) as PM[]).pipe(Effect.withSpan("Disk.read.parse [effect-app/infra/Store]"))
+          ),
+          Effect.orDie,
+          Effect.withSpan("Disk.read [effect-app/infra/Store]", { attributes: { "disk.file": file } })
+        ),
       setRaw: (v: Iterable<PM>) =>
         Effect
           .sync(() => JSON.stringify([...v], undefined, 2))
-          .withSpan("Disk.stringify [effect-app/infra/Store]", { attributes: { "disk.file": file } })
-          .flatMap(
-            (json) =>
-              fu
-                .writeTextFile(file, json)
-                .withSpan("Disk.write.writeFile [effect-app/infra/Store]", {
-                  attributes: { "disk.file_size": json.length }
-                })
+          .pipe(
+            Effect.withSpan("Disk.stringify [effect-app/infra/Store]", { attributes: { "disk.file": file } }),
+            Effect
+              .flatMap(
+                (json) =>
+                  fu
+                    .writeTextFile(file, json)
+                    .pipe(Effect
+                      .withSpan("Disk.write.writeFile [effect-app/infra/Store]", {
+                        attributes: { "disk.file_size": json.length }
+                      }))
+              ),
+            Effect
+              .withSpan("Disk.write [effect-app/infra/Store]", {
+                attributes: { "disk.file": file }
+              })
           )
-          .withSpan("Disk.write [effect-app/infra/Store]", {
-            attributes: { "disk.file": file }
-          })
     }
 
     const store = yield* $(
@@ -58,33 +68,35 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
       )
     )
 
-    yield* $(store.all.flatMap(fsStore.setRaw))
+    yield* $(store.all.pipe(Effect.flatMap(fsStore.setRaw)))
 
-    const sem = Semaphore.unsafeMake(1)
+    const sem = Effect.unsafeMakeSemaphore(1)
     const withPermit = sem.withPermits(1)
-    const flushToDisk = store.all.flatMap(fsStore.setRaw).pipe(withPermit)
+    const flushToDisk = Effect.flatMap(store.all, fsStore.setRaw).pipe(withPermit)
     const flushToDiskInBackground = flushToDisk
-      .tapErrorCause((err) => Effect.sync(() => console.error(err)))
-      .uninterruptible
-      .forkDaemon
+      .pipe(
+        Effect.tapErrorCause((err) => Effect.sync(() => console.error(err))),
+        Effect.uninterruptible,
+        Effect.forkDaemon
+      )
 
     return {
       ...store,
       batchSet: flow(
         store.batchSet,
-        (t) => t.tap(() => flushToDiskInBackground)
+        Effect.tap(flushToDiskInBackground)
       ),
       bulkSet: flow(
         store.bulkSet,
-        (t) => t.tap(() => flushToDiskInBackground)
+        Effect.tap(flushToDiskInBackground)
       ),
       set: flow(
         store.set,
-        (t) => t.tap(() => flushToDiskInBackground)
+        Effect.tap(flushToDiskInBackground)
       ),
       remove: flow(
         store.remove,
-        (t) => t.tap(() => flushToDiskInBackground)
+        Effect.tap(flushToDiskInBackground)
       )
     } satisfies Store<PM, Id>
   })
@@ -106,39 +118,43 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
         config?: StoreConfig<PM>
       ) =>
         Effect.gen(function*($) {
-          const storesSem = Semaphore.unsafeMake(1)
+          const storesSem = Effect.unsafeMakeSemaphore(1)
           const primary = yield* $(makeDiskStoreInt(prefix, "primary", dir, name, seed, config?.defaultValues))
           const stores = new Map<string, Store<PM, Id>>([["primary", primary]])
           const ctx = yield* $(Effect.context<R>())
-          const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap((namespace) => {
-            const store = stores.get(namespace)
-            if (store) {
-              return Effect.succeed(store)
-            }
-            if (!config.allowNamespace!(namespace)) {
-              throw new Error(`Namespace ${namespace} not allowed!`)
-            }
-            return storesSem.withPermits(1)(
-              Effect.suspend(() => {
-                const existing = stores.get(namespace)
-                if (existing) return Effect.sync(() => existing)
-                return makeDiskStoreInt<Id, PM, R, E>(prefix, namespace, dir, name, seed, config?.defaultValues)
-                  .orDie
-                  .provide(ctx)
-                  .tap((store) => Effect.sync(() => stores.set(namespace, store)))
-              })
-            )
-          })
+          const getStore = !config?.allowNamespace
+            ? Effect.succeed(primary)
+            : FiberRef.get(storeId).pipe(Effect.flatMap((namespace) => {
+              const store = stores.get(namespace)
+              if (store) {
+                return Effect.succeed(store)
+              }
+              if (!config.allowNamespace!(namespace)) {
+                throw new Error(`Namespace ${namespace} not allowed!`)
+              }
+              return storesSem.withPermits(1)(
+                Effect.suspend(() => {
+                  const existing = stores.get(namespace)
+                  if (existing) return Effect.sync(() => existing)
+                  return makeDiskStoreInt<Id, PM, R, E>(prefix, namespace, dir, name, seed, config?.defaultValues)
+                    .pipe(
+                      Effect.orDie,
+                      Effect.provide(ctx),
+                      Effect.tap((store) => Effect.sync(() => stores.set(namespace, store)))
+                    )
+                })
+              )
+            }))
 
           const s: Store<PM, Id> = {
-            all: getStore.flatMap((_) => _.all),
-            find: (...args) => getStore.flatMap((_) => _.find(...args)),
-            filter: (...args) => getStore.flatMap((_) => _.filter(...args)),
-            filterJoinSelect: (...args) => getStore.flatMap((_) => _.filterJoinSelect(...args)),
-            set: (...args) => getStore.flatMap((_) => _.set(...args)),
-            batchSet: (...args) => getStore.flatMap((_) => _.batchSet(...args)),
-            bulkSet: (...args) => getStore.flatMap((_) => _.bulkSet(...args)),
-            remove: (...args) => getStore.flatMap((_) => _.remove(...args))
+            all: Effect.flatMap(getStore, (_) => _.all),
+            find: (...args) => Effect.flatMap(getStore, (_) => _.find(...args)),
+            filter: (...args) => Effect.flatMap(getStore, (_) => _.filter(...args)),
+            filterJoinSelect: (...args) => Effect.flatMap(getStore, (_) => _.filterJoinSelect(...args)),
+            set: (...args) => Effect.flatMap(getStore, (_) => _.set(...args)),
+            batchSet: (...args) => Effect.flatMap(getStore, (_) => _.batchSet(...args)),
+            bulkSet: (...args) => Effect.flatMap(getStore, (_) => _.bulkSet(...args)),
+            remove: (...args) => Effect.flatMap(getStore, (_) => _.remove(...args))
           }
           return s
         })

package/src/services/Store/Memory.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { Effect, FiberRef, flow, Option, Order, pipe, ReadonlyArray, Ref } from "effect-app"
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
 import { get, pick } from "effect-app/utils"
 import type { RequestContext } from "../../RequestContext.js"
 import type { FilterArgs, FilterJoinSelect, PersistenceModelType, Store, StoreConfig } from "./service.js"
@@ -12,7 +14,7 @@ export function memFilter<T extends PersistenceModelType<string>, U extends keyo
     const select = (r: T[]): M[] => (f.select ? r.map((_) => pick(_, f.select!)) : r) as any
     const skip = f?.skip
     const limit = f?.limit
-    const ords = Option.fromNullable(f.order).map((_) =>
+    const ords = Option.map(Option.fromNullable(f.order), (_) =>
       _.map((_) =>
         Order.make<T>((self, that) => {
           // TODO: inspect data types for the right comparison?
@@ -26,24 +28,26 @@ export function memFilter<T extends PersistenceModelType<string>, U extends keyo
           }
           return selfV < thatV ? 1 : -1
         })
-      )
-    )
-    if (ords.value) {
-      c = c.sortBy(...ords.value)
+      ))
+    if (Option.isSome(ords)) {
+      c = ReadonlyArray.sortBy(...ords.value)(c)
     }
     if (!skip && limit === 1) {
       return select(
-        c.findFirstMap(f.filter ? codeFilter(f.filter) : (_) => Option.some(_)).map(ReadonlyArray.make).getOrElse(
-          () => []
+        ReadonlyArray.findFirst(c, f.filter ? codeFilter(f.filter) : (_) => Option.some(_)).pipe(
+          Option.map(ReadonlyArray.make),
+          Option.getOrElse(
+            () => []
+          )
         )
       )
     }
-    let r = f.filter ? c.filterMap(codeFilter(f.filter)) : c
+    let r = f.filter ? ReadonlyArray.filterMap(c, codeFilter(f.filter)) : c
     if (skip) {
-      r = r.drop(skip)
+      r = ReadonlyArray.drop(r, skip)
     }
     if (limit !== undefined) {
-      r = r.take(limit)
+      r = ReadonlyArray.take(r, limit)
     }
 
     return select(r)
@@ -55,7 +59,7 @@ export const storeId = FiberRef.unsafeMake("primary")
 /**
  * @tsplus getter RequestContext restoreStoreId
  */
-export const restoreFromRequestContext = (ctx: RequestContext) => storeId.set(ctx.namespace ?? "primary")
+export const restoreFromRequestContext = (ctx: RequestContext) => FiberRef.set(storeId, ctx.namespace ?? "primary")
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
   return Effect
@@ -85,100 +89,131 @@ export function makeMemoryStoreInt<Id extends string, PM extends PersistenceMode
     const items_ = yield* $(seed ?? Effect.sync(() => []))
     const defaultValues = _defaultValues ?? {}
 
-    const items = new Map(items_.toChunk.map((_) => [_.id, { ...defaultValues, ..._ }] as const))
+    const items = new Map([...items_].map((_) => [_.id, { ...defaultValues, ..._ }] as const))
     const store = Ref.unsafeMake<ReadonlyMap<Id, PM>>(items)
-    const sem = Semaphore.unsafeMake(1)
+    const sem = Effect.unsafeMakeSemaphore(1)
     const withPermit = sem.withPermits(1)
-    const values = store.get.map((s) => s.values())
+    const values = Effect.map(Ref.get(store), (s) => s.values())
 
-    const all = values.map(ReadonlyArray.fromIterable)
+    const all = Effect.map(values, ReadonlyArray.fromIterable)
 
     const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
-      items
-        .forEachEffect((i) => s.find(i.id).flatMap((current) => updateETag(i, current)))
-        .tap((items) =>
-          store
-            .get
-            .map((m) => {
-              const mut = m as Map<Id, PM>
-              items.forEach((e) => mut.set(e.id, e))
-              return mut
-            })
-            .flatMap((_) => store.set(_))
+      Effect
+        .forEach(items, (i) => Effect.flatMap(s.find(i.id), (current) => updateETag(i, current)))
+        .pipe(
+          Effect
+            .tap((items) =>
+              Ref
+                .get(store)
+                .pipe(
+                  Effect
+                    .map((m) => {
+                      const mut = m as Map<Id, PM>
+                      items.forEach((e) => mut.set(e.id, e))
+                      return mut
+                    }),
+                  Effect
+                    .flatMap((_) => Ref.set(store, _))
+                )
+            ),
+          Effect
+            .map((_) => _ as NonEmptyArray<PM>),
+          withPermit
         )
-        .map((_) => _ as NonEmptyArray<PM>)
-        .pipe(withPermit)
     const s: Store<PM, Id> = {
-      all: all.withSpan("Memory.all [effect-app/infra/Store]", {
+      all: all.pipe(Effect.withSpan("Memory.all [effect-app/infra/Store]", {
         attributes: {
           modelName,
           namespace
         }
-      }),
+      })),
       find: (id) =>
-        store
-          .get
-          .map((_) => Option.fromNullable(_.get(id)))
-          .withSpan("Memory.find [effect-app/infra/Store]", {
-            attributes: {
-              modelName,
-              namespace
-            }
-          }),
+        Ref
+          .get(store)
+          .pipe(
+            Effect.map((_) => Option.fromNullable(_.get(id))),
+            Effect
+              .withSpan("Memory.find [effect-app/infra/Store]", {
+                attributes: {
+                  modelName,
+                  namespace
+                }
+              })
+          ),
       filter: (f) =>
         all
-          .tap(() => logQuery(f, defaultValues))
-          .map(memFilter(f))
-          .withSpan("Memory.filter [effect-app/infra/Store]", {
-            attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          }),
+          .pipe(
+            Effect.tap(() => logQuery(f, defaultValues)),
+            Effect.map(memFilter(f)),
+            Effect.withSpan("Memory.filter [effect-app/infra/Store]", {
+              attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
+            })
+          ),
       filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
         all
-          .map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter)))
-          .withSpan(
-            "Memory.filterJoinSelect [effect-app/infra/Store]",
-            {
-              attributes: {
-                modelName
-              }
-            }
+          .pipe(
+            Effect.map((c) => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
+            Effect
+              .withSpan(
+                "Memory.filterJoinSelect [effect-app/infra/Store]",
+                {
+                  attributes: {
+                    modelName
+                  }
+                }
+              )
           ),
       set: (e) =>
         s
           .find(e.id)
-          .flatMap((current) => updateETag(e, current))
-          .tap((e) => store.get.map((_) => new Map([..._, [e.id, e]])).flatMap((_) => store.set(_)))
-          .pipe(withPermit)
-          .withSpan("Memory.set [effect-app/infra/Store]", {
-            attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          }),
+          .pipe(
+            Effect.flatMap((current) => updateETag(e, current)),
+            Effect
+              .tap((e) =>
+                Ref.get(store).pipe(
+                  Effect.map((_) => new Map([..._, [e.id, e]])),
+                  Effect.flatMap((_) => Ref.set(store, _))
+                )
+              ),
+            withPermit,
+            Effect
+              .withSpan("Memory.set [effect-app/infra/Store]", {
+                attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
+              })
+          ),
       batchSet: (items: readonly [PM, ...PM[]]) =>
         pipe(
           Effect
             .sync(() => items)
             // align with CosmosDB
-            .filterOrDieMessage((_) => _.length <= 100, "BatchSet: a batch may not exceed 100 items")
-            .andThen(batchSet)
-            .withSpan("Memory.batchSet [effect-app/infra/Store]", {
-              attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-            })
+            .pipe(
+              Effect.filterOrDieMessage((_) => _.length <= 100, "BatchSet: a batch may not exceed 100 items"),
+              Effect
+                .andThen(batchSet),
+              Effect
+                .withSpan("Memory.batchSet [effect-app/infra/Store]", {
+                  attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
+                })
+            )
         ),
       bulkSet: flow(
         batchSet,
         (_) =>
-          _.withSpan("Memory.bulkSet [effect-app/infra/Store]", {
+          _.pipe(Effect.withSpan("Memory.bulkSet [effect-app/infra/Store]", {
             attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          })
+          }))
       ),
       remove: (e: PM) =>
-        store
-          .get
-          .map((_) => new Map([..._].filter(([_]) => _ !== e.id)))
-          .flatMap((_) => store.set(_))
-          .pipe(withPermit)
-          .withSpan("Memory.remove [effect-app/infra/Store]", {
-            attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          })
+        Ref
+          .get(store)
+          .pipe(
+            Effect.map((_) => new Map([..._].filter(([_]) => _ !== e.id))),
+            Effect.flatMap((_) => Ref.set(store, _)),
+            withPermit,
+            Effect.withSpan("Memory.remove [effect-app/infra/Store]", {
+              attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
+            })
+          )
     }
     return s
   })
@@ -191,36 +226,42 @@ export const makeMemoryStore = () => ({
     config?: StoreConfig<PM>
   ) =>
     Effect.gen(function*($) {
-      const storesSem = Semaphore.unsafeMake(1)
+      const storesSem = Effect.unsafeMakeSemaphore(1)
       const primary = yield* $(makeMemoryStoreInt<Id, PM, 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) : storeId.get.flatMap((namespace) => {
-        const store = stores.get(namespace)
-        if (store) {
-          return Effect.succeed(store)
-        }
-        if (!config.allowNamespace!(namespace)) {
-          throw new Error(`Namespace ${namespace} not allowed!`)
-        }
-        return storesSem.withPermits(1)(Effect.suspend(() => {
+      const getStore = !config?.allowNamespace
+        ? Effect.succeed(primary)
+        : FiberRef.get(storeId).pipe(Effect.flatMap((namespace) => {
           const store = stores.get(namespace)
-          if (store) return Effect.sync(() => store)
-          return makeMemoryStoreInt(modelName, namespace, seed, config?.defaultValues)
-            .orDie
-            .provide(ctx)
-            .tap((store) => Effect.sync(() => stores.set(namespace, store)))
+          if (store) {
+            return Effect.succeed(store)
+          }
+          if (!config.allowNamespace!(namespace)) {
+            throw new Error(`Namespace ${namespace} not allowed!`)
+          }
+          return storesSem.withPermits(1)(Effect.suspend(() => {
+            const store = stores.get(namespace)
+            if (store) return Effect.sync(() => store)
+            return makeMemoryStoreInt(modelName, namespace, seed, config?.defaultValues)
+              .pipe(
+                Effect.orDie,
+                Effect
+                  .provide(ctx),
+                Effect
+                  .tap((store) => Effect.sync(() => stores.set(namespace, store)))
+              )
+          }))
         }))
-      })
       const s: Store<PM, Id> = {
-        all: getStore.flatMap((_) => _.all),
-        find: (...args) => getStore.flatMap((_) => _.find(...args)),
-        filter: (...args) => getStore.flatMap((_) => _.filter(...args)),
-        filterJoinSelect: (...args) => getStore.flatMap((_) => _.filterJoinSelect(...args)),
-        set: (...args) => getStore.flatMap((_) => _.set(...args)),
-        batchSet: (...args) => getStore.flatMap((_) => _.batchSet(...args)),
-        bulkSet: (...args) => getStore.flatMap((_) => _.bulkSet(...args)),
-        remove: (...args) => getStore.flatMap((_) => _.remove(...args))
+        all: Effect.flatMap(getStore, (_) => _.all),
+        find: (...args) => Effect.flatMap(getStore, (_) => _.find(...args)),
+        filter: (...args) => Effect.flatMap(getStore, (_) => _.filter(...args)),
+        filterJoinSelect: (...args) => Effect.flatMap(getStore, (_) => _.filterJoinSelect(...args)),
+        set: (...args) => Effect.flatMap(getStore, (_) => _.set(...args)),
+        batchSet: (...args) => Effect.flatMap(getStore, (_) => _.batchSet(...args)),
+        bulkSet: (...args) => Effect.flatMap(getStore, (_) => _.bulkSet(...args)),
+        remove: (...args) => Effect.flatMap(getStore, (_) => _.remove(...args))
       }
       return s
     })

package/src/services/Store/{Redis.ts → Redis.ts.bak}

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { RedisClient, RedisClientLayer } from "@effect-app/infra-adapters/redis-client"
+import { Effect, Layer, Option, ReadonlyArray, Secret } from "effect-app"
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
 import { NotFoundError } from "../../errors.js"
 import { memFilter } from "./Memory.js"
 import type { FilterJoinSelect, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
@@ -30,21 +32,21 @@ function makeRedisStore({ prefix }: StorageConfig) {
           }
           const get = redis
             .get(key)
-            .flatMap((x) => x.encaseInEffect(() => new NotFoundError<"data">({ type: "data", id: "" })))
+            .flatMap((x) => x.mapError(() => new NotFoundError<"data">({ type: "data", id: "" })))
             .orDie
             .map((x) => JSON.parse(x) as { data: readonly PM[] })
             .map((_) => _.data)
 
           const set = (i: ReadonlyMap<Id, PM>) => redis.set(key, JSON.stringify({ data: [...i.values()] })).orDie
 
-          const sem = Semaphore.unsafeMake(1)
+          const sem = Effect.unsafeMakeSemaphore(1)
           const withPermit = sem.withPermits(1)
 
           const asMap = get.map((x) => new Map(x.map((x) => [x.id, x] as const)))
           const all = get.map(ReadonlyArray.fromIterable)
           const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
-            items
-              .forEachEffect((e) => s.find(e.id).flatMap((current) => updateETag(e, current)))
+            Effect
+              .forEach(items, (e) => s.find(e.id).flatMap((current) => updateETag(e, current)))
               .tap((items) =>
                 asMap
                   .map((m) => {
@@ -84,5 +86,5 @@ function makeRedisStore({ prefix }: StorageConfig) {
 export function RedisStoreLayer(cfg: StorageConfig) {
   return StoreMaker
     .toLayer(makeRedisStore(cfg))
-    .provide(RedisClientLayer(cfg.url.value))
+    .pipe(Layer.provide(RedisClientLayer(Secret.value(cfg.url))))
 }