@effect-app/infra 3.10.0 → 4.0.0-beta.0

package/src/Store/Cosmos.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Array, Chunk, Duration, Effect, Layer, type NonEmptyReadonlyArray, Option, pipe, Redacted, Struct } from "effect-app"
+import { Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Option, pipe, Redacted, Struct } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT, mutable } from "effect-app/utils"
 import { CosmosClient, CosmosClientLayer } from "../adapters/cosmos-client.js"
@@ -70,12 +70,12 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     (x) =>
                       [
                         x,
-                        Option.match(Option.fromNullable(x._etag), {
+                        Option.match(Option.fromNullishOr(x._etag), {
                           onNone: () =>
                             dropUndefinedT({
                               operationType: "Create" as const,
                               resourceBody: {
-                                ...Struct.omit(x, "_etag", idKey),
+                                ...Struct.omit(x, ["_etag", idKey]),
                                 id: x[idKey],
                                 _partitionKey: config?.partitionValue(x)
                               }
@@ -87,7 +87,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                               operationType: "Replace" as const,
                               id: x[idKey],
                               resourceBody: {
-                                ...Struct.omit(x, "_etag", idKey),
+                                ...Struct.omit(x, ["_etag", idKey]),
                                 id: x[idKey],
                                 _partitionKey: config?.partitionValue(x)
                               },
@@ -98,7 +98,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         })
                       ] as const
                   )
-                const batches = Chunk.toReadonlyArray(Array.chunk_(b, config?.maxBulkSize ?? 10))
+                const batches = Array.chunksOf(b, config?.maxBulkSize ?? 10)
 
                 const batchResult = yield* Effect.forEach(
                   batches
@@ -162,9 +162,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 return batchResult.flat() as unknown as NonEmptyReadonlyArray<Encoded>
               })
               .pipe(Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
-                captureStackTrace: false,
                 attributes: { "repository.container_id": containerId, "repository.model_name": name }
-              }))
+              }, { captureStackTrace: false }))
 
           const batchSet = (items: NonEmptyReadonlyArray<PM>) => {
             return Effect
@@ -173,11 +172,11 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   (x) =>
                     [
                       x,
-                      Option.match(Option.fromNullable(x._etag), {
+                      Option.match(Option.fromNullishOr(x._etag), {
                         onNone: () => ({
                           operationType: "Create" as const,
                           resourceBody: {
-                            ...Struct.omit(x, "_etag", idKey),
+                            ...Struct.omit(x, ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: config?.partitionValue(x)
                           }
@@ -188,7 +187,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                           operationType: "Replace" as const,
                           id: x[idKey],
                           resourceBody: {
-                            ...Struct.omit(x, "_etag", idKey),
+                            ...Struct.omit(x, ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: config?.partitionValue(x)
                           },
@@ -228,9 +227,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
               })
               .pipe(Effect
                 .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
-                  captureStackTrace: false,
                   attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                }))
+                }, { captureStackTrace: false }))
           }
 
           const s: Store<IdKey, Encoded> = {
@@ -254,9 +252,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   ),
                   Effect
                     .withSpan("Cosmos.queryRaw [effect-app/infra/Store]", {
-                      captureStackTrace: false,
                       attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                    })
+                    }, { captureStackTrace: false })
                 ),
             batchRemove: (ids, partitionKey?: string) =>
               Effect.promise(() =>
@@ -294,9 +291,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 ),
                 Effect
                   .withSpan("Cosmos.all [effect-app/infra/Store]", {
-                    captureStackTrace: false,
                     attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                  })
+                  }, { captureStackTrace: false })
               ),
             /**
              * May return duplicate results for "join_find", when matching more than once.
@@ -336,7 +332,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                                 ({
                                   ...pipe(
                                     defaultValues,
-                                    Struct.pick(...f.select!.filter((_) => typeof _ === "string"))
+                                    Struct.pick(f.select!.filter((_) => typeof _ === "string"))
                                   ),
                                   ...mapReverseId(_ as any)
                                 }) as any
@@ -354,9 +350,8 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 )
                 .pipe(
                   Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
-                    captureStackTrace: false,
                     attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                  })
+                  }, { captureStackTrace: false })
                 )
             },
             find: (id) =>
@@ -366,24 +361,23 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     .item(id, config?.partitionValue({ [idKey]: id } as Encoded))
                     .read<Encoded>()
                     .then(({ resource }) =>
-                      Option.fromNullable(resource).pipe(Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) })))
+                      Option.fromNullishOr(resource).pipe(Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) })))
                     )
                 )
                 .pipe(Effect
                   .withSpan("Cosmos.find [effect-app/infra/Store]", {
-                    captureStackTrace: false,
                     attributes: {
                       "repository.container_id": containerId,
                       "repository.model_name": name,
                       partitionValue: config?.partitionValue({ [idKey]: id } as Encoded),
                       id
                     }
-                  })),
+                  }, { captureStackTrace: false })),
             set: (e) =>
               Option
                 .match(
                   Option
-                    .fromNullable(e._etag),
+                    .fromNullishOr(e._etag),
                   {
                     onNone: () =>
                       Effect.promise(() =>
@@ -410,7 +404,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .flatMap((x) => {
                       if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
-                        return new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
+                        return Effect.fail(new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode }))
                       }
                       if (x.statusCode > 299 || x.statusCode < 200) {
                         return Effect.die(
@@ -426,13 +420,12 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                     }),
                   Effect
                     .withSpan("Cosmos.set [effect-app/infra/Store]", {
-                      captureStackTrace: false,
                       attributes: {
                         "repository.container_id": containerId,
                         "repository.model_name": name,
                         id: e[idKey]
                       }
-                    })
+                    }, { captureStackTrace: false })
                 ),
             batchSet,
             bulkSet
@@ -443,7 +436,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
             container
               .item(importedMarkerId, importedMarkerId)
               .read<{ id: string }>()
-              .then(({ resource }) => Option.fromNullable(resource))
+              .then(({ resource }) => Option.fromNullishOr(resource))
           )
 
           if (!Option.isSome(marker)) {

package/src/Store/Disk.ts

@@ -3,7 +3,7 @@ import * as fu from "../fileUtil.js"
 
 import fs from "fs"
 
-import { Console, Effect, flow } from "effect-app"
+import { Console, Effect, flow, Semaphore } from "effect-app"
 import type { FieldValues } from "../Model/filter/types.js"
 import { makeMemoryStoreInt, storeId } from "./Memory.js"
 import { type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "./service.js"
@@ -30,26 +30,24 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
       get: fu
         .readTextFile(file)
         .pipe(
-          Effect.withSpan("Disk.read.readFile [effect-app/infra/Store]", { captureStackTrace: false }),
+          Effect.withSpan("Disk.read.readFile [effect-app/infra/Store]", {}, { captureStackTrace: false }),
           Effect.flatMap((x) =>
             Effect.sync(() => JSON.parse(x) as PM[]).pipe(
-              Effect.withSpan("Disk.read.parse [effect-app/infra/Store]", { captureStackTrace: false })
+              Effect.withSpan("Disk.read.parse [effect-app/infra/Store]", {}, { captureStackTrace: false })
             )
           ),
           Effect.orDie,
           Effect.withSpan("Disk.read [effect-app/infra/Store]", {
-            captureStackTrace: false,
             attributes: { "disk.file": file }
-          })
+          }, { captureStackTrace: false })
         ),
       setRaw: (v: Iterable<PM>) =>
         Effect
           .sync(() => JSON.stringify([...v], undefined, 2))
           .pipe(
             Effect.withSpan("Disk.stringify [effect-app/infra/Store]", {
-              captureStackTrace: false,
               attributes: { "disk.file": file }
-            }),
+            }, { captureStackTrace: false }),
             Effect
               .flatMap(
                 (json) =>
@@ -57,15 +55,13 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
                     .writeTextFile(file, json)
                     .pipe(Effect
                       .withSpan("Disk.write.writeFile [effect-app/infra/Store]", {
-                        captureStackTrace: false,
                         attributes: { "disk.file_size": json.length }
-                      }))
+                      }, { captureStackTrace: false }))
               ),
             Effect
               .withSpan("Disk.write [effect-app/infra/Store]", {
-                captureStackTrace: false,
                 attributes: { "disk.file": file }
-              })
+              }, { captureStackTrace: false })
           )
     }
 
@@ -95,14 +91,14 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
       })
     )
 
-    const sem = Effect.unsafeMakeSemaphore(1)
+    const sem = Semaphore.makeUnsafe(1)
     const withPermit = sem.withPermits(1)
     const flushToDisk = Effect.flatMap(store.all, fsStore.setRaw).pipe(withPermit)
     const flushToDiskInBackground = flushToDisk
       .pipe(
-        Effect.tapErrorCause(Console.error),
+        Effect.tapCause(Console.error),
         Effect.uninterruptible,
-        Effect.forkDaemon
+        Effect.forkDetach
       )
 
     return {
@@ -144,13 +140,13 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
         config?: StoreConfig<Encoded>
       ) =>
         Effect.gen(function*() {
-          const storesSem = Effect.unsafeMakeSemaphore(1)
+          const storesSem = Semaphore.makeUnsafe(1)
           const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues)
           const stores = new Map<string, Store<IdKey, Encoded>>([["primary", primary]])
-          const ctx = yield* Effect.context<R>()
+          const ctx = yield* Effect.services<R>()
           const getStore = !config?.allowNamespace
             ? Effect.succeed(primary)
-            : storeId.pipe(Effect.flatMap((namespace) => {
+            : storeId.asEffect().pipe(Effect.flatMap((namespace) => {
               const store = stores.get(namespace)
               if (store) {
                 return Effect.succeed(store)

package/src/Store/Memory.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Array, Context, Effect, Either, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Struct } from "effect-app"
+import { Array, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, ServiceMap, Struct } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { get } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
 import type { FieldValues } from "../Model/filter/types.js"
-import { codeFilter } from "./codeFilter.js"
+import { codeFilter, codeFilter3_ } from "./codeFilter.js"
 import { type FilterArgs, type PersistenceModelType, type Store, type StoreConfig, StoreMaker } from "./service.js"
 import { makeUpdateETag } from "./utils.js"
 
@@ -18,20 +18,20 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
       return r.map((i) => {
         const [keys, subKeys] = pipe(
           sel,
-          Array.partitionMap((r) =>
-            typeof r === "string" ? Either.left(String(r)) : Either.right(r as { key: string; subKeys: string[] })
+          Array.partition((r) =>
+            typeof r === "string" ? Result.fail(String(r)) : Result.succeed(r as { key: string; subKeys: string[] })
           )
         )
-        const n = Struct.pick(i, ...keys)
+        const n = Struct.pick(i, keys)
         subKeys.forEach((subKey) => {
-          n[subKey.key] = i[subKey.key]!.map(Struct.pick(...subKey.subKeys))
+          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys))
         })
         return n as M
       }) as any
     }
     const skip = f?.skip
     const limit = f?.limit
-    const ords = Option.map(Option.fromNullable(f.order), (_) =>
+    const ords = Option.map(Option.fromNullishOr(f.order), (_) =>
       _.map((_) =>
         Order.make<T>((self, that) => {
           // TODO: inspect data types for the right comparison?
@@ -59,7 +59,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
         )
       )
     }
-    let r = f.filter ? Array.filterMap(c, codeFilter(f.filter)) : c
+    let r = f.filter ? Array.filter(c, (x) => codeFilter3_(f.filter!, x)) : c
     if (skip) {
       r = Array.drop(r, skip)
     }
@@ -71,9 +71,9 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
   })
 }
 
-const defaultNs = NonEmptyString255("primary")
+const defaultNs: NonEmptyString255 = NonEmptyString255("primary")
 export class storeId
-  extends Context.Reference<storeId>()("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs })
+  extends ServiceMap.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs })
 {}
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
@@ -107,8 +107,8 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
     const defaultValues = _defaultValues ?? {}
 
     const items = new Map([...items_].map((_) => [_[idKey], { _etag: undefined, ...defaultValues, ..._ }] as const))
-    const store = Ref.unsafeMake<ReadonlyMap<Encoded[IdKey], PM>>(items)
-    const sem = Effect.unsafeMakeSemaphore(1)
+    const store = Ref.makeUnsafe<ReadonlyMap<Encoded[IdKey], PM>>(items)
+    const sem = Semaphore.makeUnsafe(1)
     const withPermit = sem.withPermits(1)
     const values = Effect.map(Ref.get(store), (s) => s.values())
 
@@ -159,31 +159,28 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
             // Effect.tap(() => logQuery(query, defaultValues)),
             Effect.map(query.memory),
             Effect.withSpan("Memory.queryRaw [effect-app/infra/Store]", {
-              captureStackTrace: false,
               attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-            })
+            }, { captureStackTrace: false })
           ),
 
       all: all.pipe(Effect.withSpan("Memory.all [effect-app/infra/Store]", {
-        captureStackTrace: false,
         attributes: {
           modelName,
           namespace
         }
-      })),
+      }, { captureStackTrace: false })),
       find: (id) =>
         Ref
           .get(store)
           .pipe(
-            Effect.map((_) => Option.fromNullable(_.get(id))),
+            Effect.map((_) => Option.fromNullishOr(_.get(id))),
             Effect
               .withSpan("Memory.find [effect-app/infra/Store]", {
-                captureStackTrace: false,
                 attributes: {
                   modelName,
                   namespace
                 }
-              })
+              }, { captureStackTrace: false })
           ),
       filter: (f) =>
         all
@@ -191,9 +188,8 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
             Effect.tap(() => logQuery(f, defaultValues)),
             Effect.map(memFilter(f)),
             Effect.withSpan("Memory.filter [effect-app/infra/Store]", {
-              captureStackTrace: false,
               attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-            })
+            }, { captureStackTrace: false })
           ),
       set: (e) =>
         s
@@ -210,9 +206,8 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
             withPermit,
             Effect
               .withSpan("Memory.set [effect-app/infra/Store]", {
-                captureStackTrace: false,
                 attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-              })
+              }, { captureStackTrace: false })
           ),
       batchRemove: (items: NonEmptyReadonlyArray<Encoded[IdKey]>) =>
         pipe(
@@ -220,13 +215,13 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
             .sync(() => items)
             // align with CosmosDB
             .pipe(
-              Effect.filterOrDieMessage((_) => _.length <= 100, "BatchRemove: a batch may not exceed 100 items"),
+              Effect.filterOrFail((_) => _.length <= 100, () => "BatchRemove: a batch may not exceed 100 items"),
+              Effect.orDie,
               Effect.andThen(batchRemove),
               Effect
                 .withSpan("Memory.batchRemove [effect-app/infra/Store]", {
-                  captureStackTrace: false,
                   attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-                })
+                }, { captureStackTrace: false })
             )
         ),
       batchSet: (items: readonly [PM, ...PM[]]) =>
@@ -235,22 +230,21 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
             .sync(() => items)
             // align with CosmosDB
             .pipe(
-              Effect.filterOrDieMessage((_) => _.length <= 100, "BatchSet: a batch may not exceed 100 items"),
+              Effect.filterOrFail((_) => _.length <= 100, () => "BatchSet: a batch may not exceed 100 items"),
+              Effect.orDie,
               Effect.andThen(batchSet),
               Effect
                 .withSpan("Memory.batchSet [effect-app/infra/Store]", {
-                  captureStackTrace: false,
                   attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-                })
+                }, { captureStackTrace: false })
             )
         ),
       bulkSet: flow(
         batchSet,
         (_) =>
           _.pipe(Effect.withSpan("Memory.bulkSet [effect-app/infra/Store]", {
-            captureStackTrace: false,
             attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          }))
+          }, { captureStackTrace: false }))
       )
     }
     return s
@@ -265,7 +259,7 @@ export const makeMemoryStore = () => ({
     config?: StoreConfig<Encoded>
   ) =>
     Effect.gen(function*() {
-      const storesSem = Effect.unsafeMakeSemaphore(1)
+      const storesSem = Semaphore.makeUnsafe(1)
       const primary = yield* makeMemoryStoreInt<IdKey, Encoded, R, E>(
         modelName,
         idKey,
@@ -273,11 +267,11 @@ export const makeMemoryStore = () => ({
         seed,
         config?.defaultValues
       )
-      const ctx = yield* Effect.context<R>()
+      const ctx = yield* Effect.services<R>()
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace
         ? Effect.succeed(primary)
-        : storeId.pipe(Effect.flatMap((namespace) => {
+        : storeId.asEffect().pipe(Effect.flatMap((namespace) => {
           const store = stores.get(namespace)
           if (store) {
             return Effect.succeed(store)

package/src/Store/index.ts

@@ -27,7 +27,7 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrapEffect)
+    .pipe(Layer.unwrap)
 }
 
 export * from "./service.js"

package/src/Store/service.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-import { Context, Effect, type NonEmptyReadonlyArray, type Option, type Redacted } from "effect-app"
+import { Effect, type NonEmptyReadonlyArray, type Option, type Redacted, ServiceMap } from "effect-app"
 import type { OptimisticConcurrencyException } from "../errors.js"
 import type { FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
@@ -89,14 +89,14 @@ export interface Store<
   queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
 }
 
-export class StoreMaker extends Context.TagId("effect-app/StoreMaker")<StoreMaker, {
+export class StoreMaker extends ServiceMap.Opaque<StoreMaker, {
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
     idKey: IdKey,
     seed?: Effect.Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
   ) => Effect.Effect<Store<IdKey, Encoded>, E, R>
-}>() {
+}>()("effect-app/StoreMaker") {
 }
 
 export const makeContextMap = () => {
@@ -170,7 +170,7 @@ export const makeContextMap = () => {
 
 const makeMap = Effect.sync(() => makeContextMap())
 
-export class ContextMap extends Context.TagMakeId("effect-app/ContextMap", makeMap)<ContextMap>() {
+export class ContextMap extends ServiceMap.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
 }
 
 export type PersistenceModelType<Encoded extends object> = Encoded & {

package/src/Store/utils.ts

@@ -17,11 +17,15 @@ export const makeUpdateETag =
   <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
     Effect.gen(function*() {
       if (e._etag) {
-        yield* Effect.mapError(
-          current,
-          () =>
-            new OptimisticConcurrencyException({ type, id: e[idKey] as string, current: "", found: e._etag, code: 409 })
-        )
+        if (Option.isNone(current)) {
+          return yield* new OptimisticConcurrencyException({
+            type,
+            id: e[idKey] as string,
+            current: "",
+            found: e._etag,
+            code: 409
+          })
+        }
       }
       if (Option.isSome(current) && current.value._etag !== e._etag) {
         return yield* new OptimisticConcurrencyException({