@effect-app/infra 4.0.0-beta.8 → 4.0.0-beta.81

package/src/Store/ContextMapContainer.ts

@@ -1,4 +1,8 @@
-import { Data, Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Data, Effect, type Exit, Layer, RequestResolver } from "effect-app"
+import type { NonEmptyArray } from "effect/Array"
+import { dual } from "effect/Function"
+import * as MutableHashMap from "effect/MutableHashMap"
+import type * as Request from "effect/Request"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -7,7 +11,7 @@ import { ContextMap } from "./service.js"
 // we can call another start after startup. but it would be even better if we could Die on accessing rootmap
 // we could also make the ContextMap optional, and when missing, issue a warning instead?
 
-export class ContextMapContainer extends ServiceMap.Reference("ContextMapContainer", {
+export class ContextMapContainer extends Context.Reference("ContextMapContainer", {
   defaultValue: (): ContextMap | "root" => "root"
 }) {
   static readonly layer = Layer.effect(this, ContextMap.make.pipe(Effect.map(ContextMap.of)))
@@ -18,3 +22,95 @@ export class ContextMapNotStartedError extends Data.TaggedError("ContextMapNotSt
 export const getContextMap = ContextMapContainer.asEffect().pipe(
   Effect.filterOrFail((_) => _ !== "root", () => new ContextMapNotStartedError())
 )
+
+export const withRequestResolverCache: {
+  <A extends Request.Request<any, any>>(options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }): (self: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+  <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A>,
+    options: {
+      readonly capacity: number
+      readonly strategy?: "lru" | "fifo" | undefined
+    }
+  ): RequestResolver.RequestResolver<A>
+} = dual(2, <A extends Request.Request<any, any>>(
+  self: RequestResolver.RequestResolver<A>,
+  options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }
+): RequestResolver.RequestResolver<A> => {
+  const cacheKey = Symbol()
+  const strategy = options.strategy ?? "lru"
+  type CacheEntry = {
+    readonly entry: Request.Entry<A>
+    exit: Exit.Exit<Request.Success<A>, Request.Error<A>> | undefined
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  return RequestResolver.makeWith({
+    ...(self as any),
+    runAll(
+      entries: NonEmptyArray<Request.Entry<A>>,
+      key: unknown
+    ) {
+      return Effect.flatMap(
+        getContextMap.pipe(Effect.orDie),
+        (contextMap) => {
+          const cache = contextMap.getOrCreateStore<MutableHashMap.MutableHashMap<A, CacheEntry>>(
+            cacheKey,
+            () => MutableHashMap.empty()
+          )
+
+          const uncached: Array<Request.Entry<A>> = []
+          for (const entry of entries) {
+            const ocached = MutableHashMap.get(cache, entry.request)
+            if (ocached._tag === "None") {
+              const cached: CacheEntry = { entry, exit: undefined }
+              MutableHashMap.set(cache, entry.request, cached)
+              const prevComplete = entry.completeUnsafe.bind(entry)
+              entry.completeUnsafe = (exit) => {
+                cached.exit = exit
+                prevComplete(exit)
+              }
+              uncached.push(entry)
+            } else {
+              const cached = ocached.value
+              if (cached.exit) {
+                if (strategy === "lru") {
+                  MutableHashMap.remove(cache, cached.entry.request)
+                  MutableHashMap.set(cache, cached.entry.request, cached)
+                }
+                entry.completeUnsafe(cached.exit as any)
+              } else {
+                cached.entry.uninterruptible = true
+                const prevComplete = cached.entry.completeUnsafe.bind(cached.entry)
+                cached.entry.completeUnsafe = (exit) => {
+                  prevComplete(exit)
+                  entry.completeUnsafe(exit)
+                }
+              }
+            }
+          }
+
+          if (uncached.length === 0) return Effect.void
+
+          return Effect.onExit(
+            (self as any).runAll(uncached, key),
+            () => {
+              let toRemove = MutableHashMap.size(cache) - options.capacity
+              if (toRemove <= 0) return Effect.void
+              for (const k of MutableHashMap.keys(cache)) {
+                MutableHashMap.remove(cache, k)
+                toRemove--
+                if (toRemove <= 0) break
+              }
+              return Effect.void
+            }
+          )
+        }
+      )
+    }
+  })
+})

package/src/Store/Cosmos.ts

@@ -328,15 +328,13 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             .query<M>(q, { partitionKey: mainPartitionKey })
                             .fetchAll()
                             .then(({ resources }) =>
-                              resources.map((_) =>
-                                ({
-                                  ...pipe(
-                                    defaultValues,
-                                    Struct.pick(f.select!.filter((_) => typeof _ === "string"))
-                                  ),
-                                  ...mapReverseId(_ as any)
-                                }) as any
-                              )
+                              resources.map((_) => ({
+                                ...pipe(
+                                  defaultValues,
+                                  Struct.pick(f.select!.filter((_) => typeof _ === "string") as never[])
+                                ),
+                                ...mapReverseId(_ as any)
+                              }))
                             )
                           : container
                             .items
@@ -404,7 +402,9 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .flatMap((x) => {
                       if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
-                        return Effect.fail(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(

package/src/Store/Disk.ts

@@ -66,11 +66,10 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
     }
 
     // lock file for cross-process coordination during initialization
-    const lockFile = file + ".lock"
 
     // wrap initialization in file lock to prevent race conditions in multi-worker setups
     const store = yield* fu.withFileLock(
-      lockFile,
+      file,
       Effect.gen(function*() {
         const shouldSeed = !(fs.existsSync(file))
 
@@ -143,7 +142,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
           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.services<R>()
+          const ctx = yield* Effect.context<R>()
           const getStore = !config?.allowNamespace
             ? Effect.succeed(primary)
             : storeId.asEffect().pipe(Effect.flatMap((namespace) => {

package/src/Store/Memory.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Array, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, ServiceMap, Struct } from "effect-app"
+import { Array, Context, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, Struct } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { get } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
@@ -24,7 +24,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
         )
         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 as never[]))
         })
         return n as M
       }) as any
@@ -72,9 +72,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
 }
 
 const defaultNs: NonEmptyString255 = NonEmptyString255("primary")
-export class storeId
-  extends ServiceMap.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs })
-{}
+export class storeId extends Context.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs }) {}
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
   return InfraLogger
@@ -267,7 +265,7 @@ export const makeMemoryStore = () => ({
         seed,
         config?.defaultValues
       )
-      const ctx = yield* Effect.services<R>()
+      const ctx = yield* Effect.context<R>()
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace
         ? Effect.succeed(primary)

package/src/Store/service.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-import { Effect, type NonEmptyReadonlyArray, type Option, type Redacted, ServiceMap } from "effect-app"
+import { Context, Effect, type NonEmptyReadonlyArray, type Option, type Redacted } 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,7 +89,7 @@ export interface Store<
   queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
 }
 
-export class StoreMaker extends ServiceMap.Opaque<StoreMaker, {
+export class StoreMaker extends Context.Opaque<StoreMaker, {
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
     idKey: IdKey,
@@ -161,16 +161,25 @@ export const makeContextMap = () => {
   //   }
   // }
 
+  const store = new Map<symbol, unknown>()
+
   return {
     get: getEtag,
-    set: setEtag
-    // parserEnv
+    set: setEtag,
+    getOrCreateStore: <T>(key: symbol, make: () => T): T => {
+      let value = store.get(key) as T | undefined
+      if (value === undefined) {
+        value = make()
+        store.set(key, value)
+      }
+      return value
+    }
   }
 }
 
 const makeMap = Effect.sync(() => makeContextMap())
 
-export class ContextMap extends ServiceMap.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
+export class ContextMap extends Context.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
 }
 
 export type PersistenceModelType<Encoded extends object> = Encoded & {

package/src/adapters/SQL/Model.ts

@@ -7,10 +7,6 @@
 /**
  * @since 1.0.0
  */
-import * as VariantSchema from "effect/unstable/schema/VariantSchema"
-import { SqlClient } from "effect/unstable/sql/SqlClient"
-import * as SqlResolver from "effect/unstable/sql/SqlResolver"
-import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 import crypto from "crypto" // TODO
 import type { Brand } from "effect/Brand"
 import * as DateTime from "effect/DateTime"
@@ -24,6 +20,10 @@ import * as Schema from "effect/Schema"
 import * as Getter from "effect/SchemaGetter"
 import * as Transformation from "effect/SchemaTransformation"
 import type { Scope } from "effect/Scope"
+import * as VariantSchema from "effect/unstable/schema/VariantSchema"
+import { SqlClient } from "effect/unstable/sql/SqlClient"
+import * as SqlResolver from "effect/unstable/sql/SqlResolver"
+import * as SqlSchema from "effect/unstable/sql/SqlSchema"
 
 const {
   Class,
@@ -190,14 +190,13 @@ export const Generated = <S extends Schema.Top>(
  * @since 1.0.0
  * @category generated
  */
-export interface GeneratedByApp<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: S
-      readonly insert: S
-      readonly update: S
-      readonly json: S
-    }>
+export interface GeneratedByApp<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: S
+    readonly insert: S
+    readonly update: S
+    readonly json: S
+  }>
 {}
 
 /**
@@ -303,8 +302,7 @@ export const FieldOption: <Field extends VariantSchema.Field<any> | Schema.Top>(
 ) => Field extends Schema.Top ? FieldOption<Field>
   : Field extends VariantSchema.Field<infer S> ? VariantSchema.Field<
       {
-        readonly [K in keyof S]: S[K] extends Schema.Top
-          ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
+        readonly [K in keyof S]: S[K] extends Schema.Top ? K extends VariantsDatabase ? Schema.OptionFromNullOr<S[K]>
           : optionalOption<S[K]>
           : never
       }
@@ -545,16 +543,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  * @since 1.0.0
  * @category json
  */
-export interface JsonFromString<S extends Schema.Top>
-  extends
-    VariantSchema.Field<{
-      readonly select: Schema.fromJsonString<S>
-      readonly insert: Schema.fromJsonString<S>
-      readonly update: Schema.fromJsonString<S>
-      readonly json: S
-      readonly jsonCreate: S
-      readonly jsonUpdate: S
-    }>
+export interface JsonFromString<S extends Schema.Top> extends
+  VariantSchema.Field<{
+    readonly select: Schema.fromJsonString<S>
+    readonly insert: Schema.fromJsonString<S>
+    readonly update: Schema.fromJsonString<S>
+    readonly json: S
+    readonly jsonCreate: S
+    readonly jsonUpdate: S
+  }>
 {}
 
 /**
@@ -825,26 +822,28 @@ export const makeDataLoaders = <
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
-      Request: Model.insert,
-      Result: Model,
-      execute: (request: any) =>
-        sql.onDialectOrElse({
-          mysql: () =>
-            Effect.forEach(request, (request: any) =>
-              sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
+    const insertResolver = SqlResolver
+      .ordered({
+        Request: Model.insert,
+        Result: Model,
+        execute: (request: any) =>
+          sql.onDialectOrElse({
+            mysql: () =>
+              Effect.forEach(request, (request: any) =>
+                sql`insert into ${sql(options.tableName)} ${sql.insert(request)};
 select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID();`
-                .unprepared
-                .pipe(
-                  Effect.map(([, results]) => results![0] as any)
-                ), { concurrency: 10 }),
-          orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
-        })
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
-    )
+                  .unprepared
+                  .pipe(
+                    Effect.map(([, results]) => results![0] as any)
+                  ), { concurrency: 10 }),
+            orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
+          })
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
+      )
     const insertExecute = SqlResolver.request(insertResolver)
     const insert = (
       insert: S["insert"]["Type"]
@@ -860,14 +859,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const insertVoidResolver = SqlResolver.void({
-      Request: Model.insert,
-      execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
-    )
+    const insertVoidResolver = SqlResolver
+      .void({
+        Request: Model.insert,
+        execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
+      )
     const insertVoidExecute = SqlResolver.request(insertVoidResolver)
     const insertVoid = (
       insert: S["insert"]["Type"]
@@ -878,18 +879,20 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const findByIdResolver = SqlResolver.findById({
-      Id: idSchema,
-      Result: Model,
-      ResultId(request: any) {
-        return request[idColumn]
-      },
-      execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
-    )
+    const findByIdResolver = SqlResolver
+      .findById({
+        Id: idSchema,
+        Result: Model,
+        ResultId(request: any) {
+          return request[idColumn]
+        },
+        execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
+      )
     const findByIdExecute = SqlResolver.request(findByIdResolver)
     const findById = (
       id: S["fields"][Id]["Type"]
@@ -904,14 +907,16 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const deleteResolver = SqlResolver.void({
-      Request: idSchema,
-      execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
-    }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
-      RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
-    )
+    const deleteResolver = SqlResolver
+      .void({
+        Request: idSchema,
+        execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
+      })
+      .pipe(
+        RequestResolver.setDelay(options.window),
+        setMaxBatchSize,
+        RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
+      )
     const deleteExecute = SqlResolver.request(deleteResolver)
     const delete_ = (
       id: S["fields"][Id]["Type"]

package/src/adapters/ServiceBus.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
 import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
-import { Cause, Effect, Exit, FiberSet, Layer, type Scope, ServiceMap } from "effect-app"
+import { Cause, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
 const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
@@ -19,7 +19,7 @@ function makeClient(url: string) {
 }
 
 export class ServiceBusClientTag
-  extends ServiceMap.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
+  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
 {
   static readonly layer = (url: string) => this.toLayer(this.make(url))
 }
@@ -50,7 +50,7 @@ const makeSender = (name: string) =>
     return { name, sendMessages }
   })
 
-export class Sender extends ServiceMap.Opaque<Sender, {
+export class Sender extends Context.Opaque<Sender, {
   name: string
   sendMessages: (
     messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
@@ -61,12 +61,12 @@ export class Sender extends ServiceMap.Opaque<Sender, {
 }
 
 export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
+  const tag = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      Sender.make(queueName).pipe(Effect.map((_) => Sender.of(_)))
+      Sender.make(queueName).pipe(Effect.map(Sender.of))
     )
   })
 }
@@ -163,7 +163,7 @@ const makeReceiver = (name: string) =>
     }
   })
 
-export class Receiver extends ServiceMap.Opaque<Receiver, {
+export class Receiver extends Context.Opaque<Receiver, {
   name: string
   make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
   makeSession: (
@@ -180,12 +180,12 @@ export class Receiver extends ServiceMap.Opaque<Receiver, {
 }
 
 export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
+  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(
       tag,
-      makeReceiver(queueName).pipe(Effect.map((_) => Receiver.of(_)))
+      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
     )
   })
 }

package/src/adapters/cosmos-client.ts

@@ -1,12 +1,12 @@
 import { CosmosClient as ComosClient_ } from "@azure/cosmos"
-import { Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Layer } from "effect-app"
 
 const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
 
 export const makeCosmosClient = (url: string, dbName: string) =>
   Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
 
-export class CosmosClient extends ServiceMap.Service<CosmosClient, {
+export class CosmosClient extends Context.Service<CosmosClient, {
   readonly db: ReturnType<InstanceType<typeof ComosClient_>["database"]>
 }>()("@services/CosmosClient") {}
 

package/src/adapters/memQueue.ts

@@ -1,4 +1,4 @@
-import { Effect, type Queue, ServiceMap } from "effect-app"
+import { Context, Effect, type Queue } from "effect-app"
 import * as Q from "effect/Queue"
 
 const make = Effect
@@ -16,6 +16,6 @@ const make = Effect
     }
   })
 
-export class MemQueue extends ServiceMap.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
+export class MemQueue extends Context.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
   static readonly Live = this.toLayer(this.make)
 }

package/src/adapters/mongo-client.ts

@@ -1,4 +1,4 @@
-import { Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Layer } from "effect-app"
 import { MongoClient as MongoClient_ } from "mongodb"
 
 // TODO: we should probably share a single client...
@@ -15,7 +15,7 @@ const withClient = (url: string) =>
 
 const makeMongoClient = (url: string, dbName?: string) => Effect.map(withClient(url), (x) => ({ db: x.db(dbName) }))
 
-export class MongoClient extends ServiceMap.Service<MongoClient, {
+export class MongoClient extends Context.Service<MongoClient, {
   readonly db: ReturnType<InstanceType<typeof MongoClient_>["db"]>
 }>()("@services/MongoClient") {}
 

package/src/adapters/redis-client.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Layer, Option, ServiceMap } from "effect-app"
+import { Context, Data, Effect, Layer, Option } from "effect-app"
 import type { RedisClient as Client } from "redis"
 import Redlock from "redlock"
 
@@ -90,7 +90,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
         .pipe(Effect.uninterruptible, Effect.orDie)
   )
 
-export class RedisClient extends ServiceMap.Service<RedisClient, {
+export class RedisClient extends Context.Service<RedisClient, {
   readonly client: Client
   readonly lock: Redlock
   readonly get: (key: string) => Effect.Effect<Option.Option<string>, ConnectionException>