@effect-app/infra 4.0.0-beta.11 → 4.0.0-beta.110

package/src/Model/Repository/internal/internal.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
-import { Array, Chunk, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, ServiceMap, Unify } from "effect-app"
+import { Array, Chunk, Context, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, Unify } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { NotFoundError } from "effect-app/client/errors"
 import { flatMapOption } from "effect-app/Effect"
@@ -55,14 +55,14 @@ export function makeRepoInternal<
 
     function make<RInitial = never, E = never, RPublish = never, RCtx = never>(
       args: [Evt] extends [never] ? {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (e?: Encoded) => string
           }
         }
         : {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect.Effect<void, never, RPublish>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
@@ -72,12 +72,12 @@ export function makeRepoInternal<
     ) {
       return Effect
         .gen(function*() {
-          const rctx: ServiceMap.ServiceMap<RCtx> = args.schemaContext ?? ServiceMap.empty() as any
+          const rctx: Context.Context<RCtx> = args.schemaContext ?? Context.empty() as any
           const provideRctx = Effect.provide(rctx)
           const encodeMany = flow(
             S.encodeEffect(S.Array(schema)),
             provideRctx,
-            Effect.withSpan("encodeMany", {}, { captureStackTrace: false })
+            Effect.withSpan("encodeMany", { attributes: { itemType: name } }, { captureStackTrace: false })
           )
           const decode = flow(S.decodeEffect(schema), provideRctx)
           const decodeMany = flow(
@@ -113,11 +113,14 @@ export function makeRepoInternal<
               let ast = _.ast
               if (ast._tag === "Declaration") ast = ast.typeParameters[0]!
 
-              // In v4, to get the encoded (from) side of a schema, use SchemaAST.toEncoded
               const pickIdFromAst = (a: SchemaAST.AST) => {
-                const encoded = SchemaAST.toEncoded(a)
-                if (SchemaAST.isObjects(encoded)) {
-                  const field = encoded.propertySignatures.find((_) => _.name === idKey)
+                // Unwrap Declaration (e.g. TaggedClass) to get the underlying Objects AST
+                let inner = a
+                if (inner._tag === "Declaration") inner = inner.typeParameters[0]!
+                // Pick from the original AST to preserve the full encoding chain (e.g. decodeTo transformations).
+                // Using toEncoded would lose transformation info needed to encode Type -> Encoded.
+                if (SchemaAST.isObjects(inner)) {
+                  const field = inner.propertySignatures.find((_) => _.name === idKey)
                   if (field) {
                     return S.Struct({ [idKey]: S.make(field.type) }) as unknown as Codec<T, Encoded>
                   }
@@ -161,7 +164,7 @@ export function makeRepoInternal<
             )
           })
 
-          const find = Effect.fn("find")(function*(id: T[IdKey]) {
+          const find = Effect.fn("find", { attributes: { itemType: name } })(function*(id: T[IdKey]) {
             yield* Effect.annotateCurrentSpan({ itemId: id })
 
             return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
@@ -188,62 +191,71 @@ export function makeRepoInternal<
                 Effect.andThen(saveAllE)
               )
 
-          const saveAndPublish = Effect.fn("saveAndPublish")(function*(items: Iterable<T>, events: Iterable<Evt> = []) {
-            const it = Chunk.fromIterable(items)
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: [...Chunk.map(it, (_) => _[idKey])], events: evts.length })
-            return yield* saveAll(it)
-              .pipe(
-                Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                (_) => flatMapOption(_, pub),
-                Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
-                Effect.asVoid
-              )
-          })
+          const saveAndPublish = Effect.fn("saveAndPublish", { attributes: { itemType: name } })(
+            function*(items: Iterable<T>, events: Iterable<Evt> = []) {
+              const it = Chunk.fromIterable(items)
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({ itemIds: [...Chunk.map(it, (_) => _[idKey])], events: evts.length })
+              return yield* saveAll(it)
+                .pipe(
+                  Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  (_) => flatMapOption(_, pub),
+                  Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
+                  Effect.asVoid
+                )
+            }
+          )
 
-          const removeAndPublish = Effect.fn("removeAndPublish")(function*(a: Iterable<T>, events: Iterable<Evt> = []) {
-            const { set } = yield* cms
-            const it = [...a]
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
-            const items = yield* encodeMany(it).pipe(Effect.orDie)
-            if (Array.isReadonlyArrayNonEmpty(items)) {
-              yield* store.batchRemove(
-                items.map((_) => (_[idKey])),
-                args.config?.partitionValue?.(items[0])
-              )
-              for (const e of items) {
-                set(e[idKey], undefined)
-              }
-              yield* Effect
-                .sync(() => toNonEmptyArray(evts))
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                .pipe((_) => flatMapOption(_, pub))
+          const removeAndPublish = Effect.fn("removeAndPublish", { attributes: { itemType: name } })(
+            function*(a: Iterable<T>, events: Iterable<Evt> = []) {
+              const { set } = yield* cms
+              const it = [...a]
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
+              const items = yield* encodeMany(it).pipe(Effect.orDie)
+              if (Array.isReadonlyArrayNonEmpty(items)) {
+                yield* store.batchRemove(
+                  items.map((_) => (_[idKey])),
+                  args.config?.partitionValue?.(items[0])
+                )
+                for (const e of items) {
+                  set(e[idKey], undefined)
+                }
+                yield* Effect
+                  .sync(() => toNonEmptyArray(evts))
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  .pipe((_) => flatMapOption(_, pub))
 
-              yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
+                yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
+              }
             }
-          })
+          )
 
-          const removeById = Effect.fn("removeById")(function*(...ids: readonly T[IdKey][]) {
-            if (!Array.isReadonlyArrayNonEmpty(ids)) {
-              return
-            }
-            const { set } = yield* cms
-            const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
-            yield* Effect.annotateCurrentSpan({ itemIds: eids })
-            yield* store.batchRemove(eids)
-            for (const id of eids) {
-              set(id, undefined)
+          const removeById = Effect.fn("removeById", { attributes: { itemType: name } })(
+            function*(...ids: readonly T[IdKey][]) {
+              if (!Array.isReadonlyArrayNonEmpty(ids)) {
+                return
+              }
+              const { set } = yield* cms
+              const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
+              yield* Effect.annotateCurrentSpan({ itemIds: eids })
+              yield* store.batchRemove(eids)
+              for (const id of eids) {
+                set(id, undefined)
+              }
+              yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
             }
-            yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
-          })
+          )
 
           const parseMany = (items: readonly PM[]) =>
             Effect
               .flatMap(cms, (cm) =>
                 decodeMany(items.map((_) => mapReverse(_, cm.set)))
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany", {}, { captureStackTrace: false })))
+                  .pipe(
+                    Effect.orDie,
+                    Effect.withSpan("parseMany", { attributes: { itemType: name } }, { captureStackTrace: false })
+                  ))
           const parseMany2 = <A, R>(
             items: readonly PM[],
             schema: S.Codec<A, Encoded, R>
@@ -254,7 +266,10 @@ export function makeRepoInternal<
                   .decodeEffect(S.Array(schema))(
                     items.map((_) => mapReverse(_, cm.set))
                   )
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany2", {}, { captureStackTrace: false })))
+                  .pipe(
+                    Effect.orDie,
+                    Effect.withSpan("parseMany2", { attributes: { itemType: name } }, { captureStackTrace: false })
+                  ))
           const filter = <U extends keyof Encoded = keyof Encoded>(args: FilterArgs<Encoded, U>) =>
             store
               .filter(
@@ -327,6 +342,7 @@ export function makeRepoInternal<
                 : eff,
               Effect.withSpan("Repository.query [effect-app/infra]", {
                 attributes: {
+                  itemType: name,
                   "repository.model_name": name,
                   query: { ...a, schema: a.schema ? "__SCHEMA__" : a.schema, filter: a.filter }
                 }
@@ -334,7 +350,7 @@ export function makeRepoInternal<
             )
           }) as any
 
-          const validateSample = Effect.fn("validateSample")(function*(options?: {
+          const validateSample = Effect.fn("validateSample", { attributes: { itemType: name } })(function*(options?: {
             percentage?: number
             maxItems?: number
           }) {
@@ -441,7 +457,7 @@ export function makeRepoInternal<
                 // },
                 save: (...xes: any[]) =>
                   Effect.flatMap(encMany(xes), (_) => saveAllE(_)).pipe(
-                    Effect.withSpan("mapped.save", {}, { captureStackTrace: false })
+                    Effect.withSpan("mapped.save", { attributes: { itemType: name } }, { captureStackTrace: false })
                   )
               }
             }

package/src/Model/Repository/makeRepo.ts

@@ -7,7 +7,7 @@
 // import type { ParserEnv } from "effect-app/Schema/custom/Parser"
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
-import { Effect, type NonEmptyReadonlyArray, type S, type ServiceMap } from "effect-app"
+import { type Context, Effect, type NonEmptyReadonlyArray, type S } from "effect-app"
 import type { StoreConfig, StoreMaker } from "../../Store.js"
 import type { FieldValues } from "../filter/types.js"
 import { type ExtendedRepository, extendRepo } from "./ext.js"
@@ -52,7 +52,7 @@ export interface RepositoryOptions<
    * Optional context to be provided to Schema decode/encode.
    * Useful for effectful transformations like XWithItems, where items is a transformation retrieving elements from another database table or other source.
    */
-  schemaContext?: ServiceMap.ServiceMap<RCtx>
+  schemaContext?: Context.Context<RCtx>
 
   overrides?: (
     repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>

package/src/Operations.ts

@@ -1,6 +1,6 @@
 import { reportError } from "@effect-app/infra/errorReporter"
 import { subHours } from "date-fns"
-import { Cause, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule, ServiceMap } from "effect-app"
+import { Cause, Context, copy, Duration, Effect, Exit, type Fiber, Layer, Option, S, Schedule } from "effect-app"
 import { annotateLogscoped } from "effect-app/Effect"
 import { dual, pipe } from "effect-app/Function"
 import { Operation, OperationFailure, OperationId, type OperationProgress, OperationSuccess } from "effect-app/Operations"
@@ -189,7 +189,7 @@ const make = Effect.gen(function*() {
   }
 })
 
-export class Operations extends ServiceMap.Opaque<Operations>()("effect-app/Operations", { make }) {
+export class Operations extends Context.Opaque<Operations>()("effect-app/Operations", { make }) {
   private static readonly CleanupLive = this
     .use((_) =>
       _.cleanup.pipe(

package/src/OperationsRepo.ts

@@ -1,8 +1,8 @@
-import { Effect, ServiceMap } from "effect-app"
+import { Context, Effect } from "effect-app"
 import { Operation } from "effect-app/Operations"
 import { makeRepo } from "./Model.js"
 
-export class OperationsRepo extends ServiceMap.Service<OperationsRepo>()(
+export class OperationsRepo extends Context.Service<OperationsRepo>()(
   "OperationRepo",
   {
     make: Effect.gen(function*() {

package/src/QueueMaker/SQLQueue.ts

@@ -3,13 +3,13 @@ import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors
 import { type QueueBase, QueueMeta } from "@effect-app/infra/QueueMaker/service"
 import { subMinutes } from "date-fns"
 import { Effect, Fiber, type NonEmptyReadonlyArray, Option, S, Tracer } from "effect-app"
-import type { NonEmptyString255 } from "effect-app/Schema"
+import { type NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 import { SqlClient } from "effect/unstable/sql"
 import { SQLModel } from "../adapters/SQL.js"
 import { InfraLogger } from "../logger.js"
 
-export const QueueId = S.Number.pipe(S.brand("QueueId"))
+export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
 
 // TODO: let the model track and Auto Generate versionColumn on every update instead
@@ -78,14 +78,14 @@ export function makeSQLQueue<
 
     const q = {
       offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-        yield* queueRepo.insertVoid({
+        yield* queueRepo.insertVoid(Queue.insert.make({
           body,
           meta,
           name: queueName,
           processingAt: Option.none(),
           finishedAt: Option.none(),
           etag: crypto.randomUUID()
-        })
+        }))
       }),
       take: Effect.gen(function*() {
         while (true) {
@@ -94,15 +94,16 @@ export function makeSQLQueue<
             const dec = yield* decodeDrain(first)
             const { createdAt, updatedAt, ...rest } = dec
             return yield* drainRepo.update(
-              { ...rest, processingAt: Option.some(new Date()) } // auto in lib , etag: crypto.randomUUID()
+              Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
             )
           }
           if (first) return first
           yield* Effect.sleep(250)
         }
       }),
-      finish: ({ createdAt, updatedAt, ...q }: Drain) =>
-        drainRepo.updateVoid({ ...q, finishedAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
+      finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
+        return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
+      })
     }
     const queue = {
       publish: (...messages: NonEmptyReadonlyArray<Evt>) =>

package/src/QueueMaker/memQueue.ts

@@ -25,10 +25,10 @@ export function makeMemQueue<
     const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
 
     const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
-    const wireSchemaJson = S.fromJsonString(wireSchema)
+    const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
     const encodePublish = S.encodeEffect(wireSchemaJson)
     const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-    const drainWJson = S.fromJsonString(drainW)
+    const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
 
     const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 

package/src/QueueMaker/sbqueue.ts

@@ -21,10 +21,10 @@ export function makeServiceBusQueue<
     body: schema,
     meta: QueueMeta
   })
-  const wireSchemaJson = S.fromJsonString(wireSchema)
+  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
   const encodePublish = S.encodeEffect(wireSchemaJson)
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(drainW)
+  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
   const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 
   return Effect.gen(function*() {

package/src/RequestContext.ts

@@ -1,11 +1,11 @@
-import { S, ServiceMap } from "effect-app"
+import { Context, S } from "effect-app"
 import { UserProfileId } from "effect-app/ids"
 import { NonEmptyString255 } from "effect-app/Schema"
 
-export const Locale = S.Literal("en", "de")
+export const Locale = S.Literals(["en", "de"])
 export type Locale = typeof Locale.Type
 
-export class LocaleRef extends ServiceMap.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
+export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
 
 export class RequestContext extends S.ExtendedClass<
   RequestContext,
@@ -23,7 +23,7 @@ export class RequestContext extends S.ExtendedClass<
   /** @deprecated */
   userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
 }) {
-  // static Tag = ServiceMap.Tag<RequestContext>()
+  // static Tag = Context.Tag<RequestContext>()
 
   static toMonitoring(this: void, self: RequestContext) {
     return {

package/src/RequestFiberSet.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Fiber, FiberSet, Layer, ServiceMap, type Tracer } from "effect-app"
+import { Context, Effect, Fiber, FiberSet, Layer, Option, type Tracer } from "effect-app"
 import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
 import { InfraLogger } from "./logger.js"
 
@@ -8,8 +8,8 @@ const getRootParentSpan = Effect.gen(function*() {
     Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
   )
   if (!span) return span
-  while (span._tag === "Span" && span.parent !== undefined) {
-    span = span.parent
+  while (span._tag === "Span" && Option.isSome(span.parent)) {
+    span = span.parent.value
   }
   return span
 })
@@ -92,7 +92,7 @@ const make = Effect.gen(function*() {
  * Whenever you fork a fiber for a Request, and you want to prevent dependent services to close prematurely on interruption,
  * like the ServiceBus Sender, you should register these fibers in this FiberSet.
  */
-export class RequestFiberSet extends ServiceMap.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
+export class RequestFiberSet extends Context.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
   static readonly Live = Layer.effect(this, this.make)
   static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
     this.asEffect().pipe(Effect.andThen((_) => _.register(self)))

package/src/Store/ContextMapContainer.ts

@@ -1,4 +1,6 @@
-import { Data, Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Data, Effect, Layer, RequestResolver } from "effect-app"
+import { dual } from "effect/Function"
+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 +9,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 +20,40 @@ export class ContextMapNotStartedError extends Data.TaggedError("ContextMapNotSt
 export const getContextMap = ContextMapContainer.asEffect().pipe(
   Effect.filterOrFail((_) => _ !== "root", () => new ContextMapNotStartedError())
 )
+
+/**
+ * Uses the official `RequestResolver.withCache` internally,
+ * creating one cached resolver per ContextMap (i.e. per request).
+ * Uses a shared semaphore in the ContextMap to ensure safe single initialization.
+ */
+export const withRequestResolverCache: {
+  <A extends Request.Request<any, any>>(options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }): (
+    self: RequestResolver.RequestResolver<A>
+  ) => Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError>
+  <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A>,
+    options: {
+      readonly capacity: number
+      readonly strategy?: "lru" | "fifo" | undefined
+    }
+  ): Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError>
+} = dual(2, <A extends Request.Request<any, any>>(
+  self: RequestResolver.RequestResolver<A>,
+  options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }
+): Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError> => {
+  const cacheKey = Symbol()
+  return getContextMap.pipe(
+    Effect.flatMap((ctxMap) =>
+      ctxMap.getOrCreateStoreEffect(
+        cacheKey,
+        RequestResolver.withCache(self, options)
+      )
+    )
+  )
+})