@effect-app/infra 4.0.0-beta.20 → 4.0.0-beta.200

package/src/Store/index.ts

@@ -1,12 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Effect, Layer, Redacted } from "effect-app"
+import type { SqlClient } from "effect/unstable/sql"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
 // import { RedisStoreLayer } from "./Redis.js"
+import { RepositoryRegistryLive } from "../Model.js"
 import type { StorageConfig } from "./service.js"
+import { SQLiteStoreLayer } from "./SQL.js"
+import { PgStoreLayer } from "./SQL/Pg.js"
 
-export function StoreMakerLayer(cfg: StorageConfig) {
+export function StoreMakerLayer(
+  cfg: StorageConfig,
+  options?: { makeSqlClientLayer?: (namespace: string) => Layer.Layer<SqlClient.SqlClient> }
+) {
   return Effect
     .sync(() => {
       const storageUrl = Redacted.value(cfg.url)
@@ -19,6 +26,14 @@ export function StoreMakerLayer(cfg: StorageConfig) {
         console.log("Using disk store at " + dir)
         return DiskStoreLayer(cfg, dir)
       }
+      if (storageUrl.startsWith("sqlite://")) {
+        console.log("Using SQLite store")
+        return SQLiteStoreLayer(cfg, options)
+      }
+      if (storageUrl.startsWith("pg://")) {
+        console.log("Using PostgreSQL store")
+        return PgStoreLayer(cfg)
+      }
       // if (storageUrl.startsWith("redis://")) {
       //   console.log("Using Redis store")
       //   return RedisStoreLayer(cfg)
@@ -27,7 +42,7 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrap)
+    .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
 
 export * from "./service.js"

package/src/Store/service.ts

@@ -1,6 +1,7 @@
 /* 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 * as Semaphore from "effect/Semaphore"
 import type { OptimisticConcurrencyException } from "../errors.js"
 import type { FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
@@ -10,8 +11,8 @@ import { type RawQuery } from "../Model/query.js"
 export interface StoreConfig<E> {
   partitionValue: (e?: E) => string
   /**
-   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database
-   * currently only supported in disk/memory. CosmosDB is TODO.
+   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database.
+   * Memory/Disk use separate store instances per namespace. CosmosDB uses namespace-prefixed partition keys. SQL uses a `_namespace` column.
    */
   allowNamespace?: (namespace: string) => boolean
   /**
@@ -87,9 +88,14 @@ export interface Store<
   ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
   batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
   queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
+  /**
+   * Explicitly seed a namespace. Primary is seeded eagerly on initialization.
+   * Non-primary namespaces must be seeded explicitly before use.
+   */
+  seedNamespace: (namespace: string) => Effect.Effect<void>
 }
 
-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 +167,34 @@ export const makeContextMap = () => {
   //   }
   // }
 
+  const store = new Map<symbol, unknown>()
+  const sem = Semaphore.makeUnsafe(1)
+
   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
+    },
+    getOrCreateStoreEffect: <T, E, R>(key: symbol, make: Effect.Effect<T, E, R>): Effect.Effect<T, E, R> =>
+      sem.withPermits(1)(Effect.uninterruptible(Effect.gen(function*() {
+        const value = store.get(key) as T | undefined
+        if (value !== undefined) return value
+        const v = yield* make
+        store.set(key, v)
+        return v
+      })))
   }
 }
 
 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 & {
@@ -178,7 +202,7 @@ export type PersistenceModelType<Encoded extends object> = Encoded & {
 }
 
 export interface StorageConfig {
-  url: Redacted.Redacted<string>
+  url: Redacted.Redacted
   prefix: string
   dbName: string
 }

package/src/Store/utils.ts

@@ -12,33 +12,34 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
     _etag: crypto.createHash("sha256").update(JSON.stringify(e)).digest("hex")
   }) as any
 
-export const makeUpdateETag =
-  (type: string) =>
-  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
-    Effect.gen(function*() {
-      if (e._etag) {
-        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) {
+export const makeUpdateETag = (type: string) =>
+  Effect.fnUntraced(function*<IdKey extends keyof E, E extends PersistenceModelType<{}>>(
+    e: E,
+    idKey: IdKey,
+    current: Option.Option<E>
+  ) {
+    if (e._etag) {
+      if (Option.isNone(current)) {
         return yield* new OptimisticConcurrencyException({
           type,
-          id: current.value[idKey] as string,
-          current: current.value._etag,
+          id: e[idKey] as string,
+          current: "",
           found: e._etag,
-          code: 412
+          code: 409
         })
       }
-      const newE = makeETag(e)
-      return newE
-    })
+    }
+    if (Option.isSome(current) && current.value._etag !== e._etag) {
+      return yield* new OptimisticConcurrencyException({
+        type,
+        id: current.value[idKey] as string,
+        current: current.value._etag,
+        found: e._etag,
+        code: 412
+      })
+    }
+    return makeETag(e)
+  })
 
 export function lowercaseIfString<T>(val: T) {
   if (typeof val === "string") {

package/src/adapters/SQL/Model.ts

@@ -545,9 +545,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  */
 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 select: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly insert: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly update: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
     readonly json: S
     readonly jsonCreate: S
     readonly jsonUpdate: S
@@ -565,7 +571,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema))
   return Field({
     select: parsed,
     insert: parsed,

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,49 +19,46 @@ 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))
 }
 
-function makeSender_(queueName: string) {
-  return Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
+const makeSender_ = Effect.fnUntraced(function*(queueName: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
 
-    return yield* Effect.acquireRelease(
-      Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
-        withSpanAndLog(`ServiceBus.sender.create ${queueName}`)
-      ),
-      (sender) => Effect.promise(() => sender.close()).pipe(withSpanAndLog(`ServiceBus.sender.close ${queueName}`))
-    )
-  })
-}
-
-const makeSender = (name: string) =>
-  Effect.gen(function*() {
-    const sender = yield* makeSender_(name)
-    const sendMessages = Effect.fnUntraced(function*(
-      messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-      options?: Omit<OperationOptionsBase, "abortSignal">
-    ) {
-      return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
-    })
+  return yield* Effect.acquireRelease(
+    Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
+      withSpanAndLog(`ServiceBus.sender.create ${queueName}`)
+    ),
+    (sender) => Effect.promise(() => sender.close()).pipe(withSpanAndLog(`ServiceBus.sender.close ${queueName}`))
+  )
+})
 
-    return { name, sendMessages }
+const makeSender = Effect.fnUntraced(function*(name: string) {
+  const sender = yield* makeSender_(name)
+  const sendMessages = Effect.fnUntraced(function*(
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal">
+  ) {
+    return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
   })
 
-export class Sender extends ServiceMap.Opaque<Sender, {
+  return { name, sendMessages }
+})
+
+export class Sender extends Context.Opaque<Sender, {
   name: string
   sendMessages: (
     messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
     options?: Omit<OperationOptionsBase, "abortSignal">
-  ) => Effect.Effect<void, never, never>
+  ) => Effect.Effect<void>
 }>()("Sender", { make: makeSender }) {
   static readonly layer = (name: string) => this.toLayer(this.make(name))
 }
 
 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(
@@ -71,99 +68,98 @@ export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
   })
 }
 
-const makeReceiver = (name: string) =>
-  Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
-
-    const makeReceiver = Effect.fnUntraced(
-      function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
-        return yield* Effect.acquireRelease(
-          (sessionId
-            ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-            : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-            .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
-          (r) =>
-            waitTillEmpty.pipe(
-              withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
-              Effect.andThen(
-                Effect.promise(() => r.close()).pipe(
-                  withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`)
-                )
-              ),
-              withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
-            )
+const makeReceiver = Effect.fnUntraced(function*(name: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
+
+  const makeReceiver = Effect.fnUntraced(
+    function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
+      return yield* Effect.acquireRelease(
+        (sessionId
+          ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
+          : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
+          .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
+        (r) =>
+          waitTillEmpty.pipe(
+            withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
+            Effect.andThen(
+              Effect.promise(() => r.close()).pipe(
+                withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`)
+              )
+            ),
+            withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
+          )
+      )
+    }
+  )
+
+  const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
+
+  const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
+    makeReceiver(name, waitTillEmpty, sessionId)
+
+  return {
+    name,
+    make,
+    makeSession,
+    subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
+      const fs = yield* FiberSet.make()
+      const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
+      const wait = Effect
+        .gen(function*() {
+          if ((yield* FiberSet.size(fs)) > 0) {
+            yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
+          }
+          while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
+        })
+      const r = yield* sessionId
+        ? makeSession(
+          sessionId,
+          wait
+        )
+        : make(wait)
+
+      const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
+        new Promise<void>((resolve, reject) =>
+          fr(effect)
+            .addObserver((exit) => {
+              if (Exit.isSuccess(exit)) {
+                resolve(exit.value)
+              } else {
+                // disable @typescript-eslint/prefer-promise-reject-errors
+                reject(Cause.pretty(exit.cause))
+              }
+            })
         )
-      }
-    )
 
-    const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
-
-    const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
-      makeReceiver(name, waitTillEmpty, sessionId)
-
-    return {
-      name,
-      make,
-      makeSession,
-      subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-        const fs = yield* FiberSet.make()
-        const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
-        const wait = Effect
-          .gen(function*() {
-            if ((yield* FiberSet.size(fs)) > 0) {
-              yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
-            }
-            while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
-          })
-        const r = yield* sessionId
-          ? makeSession(
-            sessionId,
-            wait
-          )
-          : make(wait)
-
-        const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
-          new Promise<void>((resolve, reject) =>
-            fr(effect)
-              .addObserver((exit) => {
-                if (Exit.isSuccess(exit)) {
-                  resolve(exit.value)
-                } else {
-                  // disable @typescript-eslint/prefer-promise-reject-errors
-                  reject(Cause.pretty(exit.cause))
-                }
+      yield* Effect.acquireRelease(
+        Effect
+          .sync(() => {
+            const s = r
+              .subscribe({
+                processError: (err) =>
+                  runEffect(
+                    hndlr
+                      .processError(err)
+                      .pipe(
+                        Effect.catchCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
+                      )
+                  ),
+                processMessage: (msg) => runEffect(hndlr.processMessage(msg))
+                // DO NOT CATCH ERRORS here as they should return to the queue!
               })
+            return { close: Effect.promise(() => s.close()) }
+          })
+          .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
+        (subscription) =>
+          subscription.close.pipe(
+            withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
           )
+      ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
+    })
+  }
+})
 
-        yield* Effect.acquireRelease(
-          Effect
-            .sync(() => {
-              const s = r
-                .subscribe({
-                  processError: (err) =>
-                    runEffect(
-                      hndlr
-                        .processError(err)
-                        .pipe(
-                          Effect.catchCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
-                        )
-                    ),
-                  processMessage: (msg) => runEffect(hndlr.processMessage(msg))
-                  // DO NOT CATCH ERRORS here as they should return to the queue!
-                })
-              return { close: Effect.promise(() => s.close()) }
-            })
-            .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
-          (subscription) =>
-            subscription.close.pipe(
-              withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
-            )
-        ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
-      })
-    }
-  })
-
-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,7 +176,7 @@ 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(

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/index.ts

@@ -0,0 +1,7 @@
+export * from "./cosmos-client.js"
+export * from "./logger.js"
+export * from "./memQueue.js"
+export * from "./mongo-client.js"
+export * from "./redis-client.js"
+export * from "./ServiceBus.js"
+export * from "./SQL.js"

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>

package/src/api/ContextProvider.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope } from "effect-app"
 
 import { type HttpRouter } from "effect-app/http"
 import { type EffectGenUtils } from "effect-app/utils/gen"
@@ -23,7 +23,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // E = never => the context provided cannot trigger errors
   // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope.Scope?
   //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
-  ContextTagWithDefault.Base<Effect.Effect<ServiceMap.ServiceMap<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
+  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
     ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
@@ -58,9 +58,9 @@ export const mergeContextProviders = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -78,14 +78,14 @@ export const mergeContextProviders = <
             handle: handle[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(handle)() : handle
           }
         ))
-        // services are effects which return some ServiceMap.ServiceMap<...>
+        // services are effects which return some Context.Context<...>
         const context = yield* mergeContexts(services as any)
         return context
       })
   }) as any
 })
 
-// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing ServiceMap or Layer (bad boy) we could use Wrap..
+// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing Context or Layer (bad boy) we could use Wrap..
 export const ContextProvider = <
   ContextProviderA,
   MakeContextProviderE,
@@ -98,8 +98,7 @@ export const ContextProvider = <
       | Effect.Effect<ContextProviderA, never, ContextProviderR>
       | (() => Generator<
         Yieldable<any, any, never, ContextProviderR>,
-        ContextProviderA,
-        any
+        ContextProviderA
       >),
       MakeContextProviderE,
       MakeContextProviderR | Scope.Scope
@@ -107,7 +106,7 @@ export const ContextProvider = <
     dependencies?: Dependencies
   }
 ) => {
-  const ctx = ServiceMap.Service<
+  const ctx = Context.Service<
     ContextProviderId,
     Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
@@ -146,17 +145,17 @@ export const MergedContextProvider = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     // v4: Identifier here is correct — it's the nominal service identity for layer provide/exclude
     | Exclude<
-      ServiceMap.Service.Identifier<TDeps[number]>,
+      Context.Service.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
   >
 
-export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(ServiceMap.empty())) })
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })

package/src/api/internal/RequestContextMiddleware.ts

@@ -21,7 +21,7 @@ export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
       const namespace = NonEmptyString255((ns && (Array.isArray(ns) ? ns[0] : ns)) || "primary")
       const deviceId = req.headers["x-fe-device-id"]
 
-      const requestContext = new RequestContext({
+      const requestContext = RequestContext.make({
         span: {
           traceId: currentSpan.traceId,
           spanId: currentSpan.spanId,