@effect-app/infra 2.92.2 → 2.93.0

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

@@ -126,8 +126,10 @@ export function makeRepoInternal<
                 : s.pipe(S.pick(idKey as any))
             })
           const encodeId = flow(S.encode(i), provideRctx)
-          function findEId(id: Encoded[IdKey]) {
-            return Effect.flatMap(
+          const findEId = Effect.fnUntraced(function*(id: Encoded[IdKey]) {
+            yield* Effect.annotateCurrentSpan({ itemId: id })
+
+            return yield* Effect.flatMap(
               store.find(id),
               (item) =>
                 Effect.gen(function*() {
@@ -135,20 +137,24 @@ export function makeRepoInternal<
                   return item.pipe(Option.map((_) => mapReverse(_, set)))
                 })
             )
-          }
+          })
           // TODO: select the particular field, instead of as struct
-          function findE(id: T[IdKey]) {
-            return pipe(
+          const findE = Effect.fnUntraced(function*(id: T[IdKey]) {
+            yield* Effect.annotateCurrentSpan({ itemId: id })
+
+            return yield* pipe(
               encodeId({ [idKey]: id } as any),
               Effect.orDie,
               Effect.map((_) => (_ as any)[idKey]),
               Effect.flatMap(findEId)
             )
-          }
+          })
 
-          function find(id: T[IdKey]) {
-            return Effect.flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
-          }
+          const find = Effect.fn("find")(function*(id: T[IdKey]) {
+            yield* Effect.annotateCurrentSpan({ itemId: id })
+
+            return yield* Effect.flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
+          })
 
           const saveAllE = (a: Iterable<Encoded>) =>
             Effect
@@ -172,40 +178,38 @@ export function makeRepoInternal<
                 Effect.andThen(saveAllE)
               )
 
-          const saveAndPublish = (items: Iterable<T>, events: Iterable<Evt> = []) => {
-            return Effect
-              .suspend(() => {
-                const it = Chunk.fromIterable(items)
-                return saveAll(it)
-                  .pipe(
-                    Effect.andThen(Effect.sync(() => toNonEmptyArray([...events]))),
-                    // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                    (_) => Effect.flatMapOption(_, pub),
-                    Effect.andThen(changeFeed.publish([Chunk.toArray(it), "save"])),
-                    Effect.asVoid
-                  )
-              })
-              .pipe(Effect.withSpan("saveAndPublish", { captureStackTrace: false }))
-          }
-
-          function removeAndPublish(a: Iterable<T>, events: Iterable<Evt> = []) {
-            return Effect.gen(function*() {
-              const { get, set } = yield* cms
-              const it = [...a]
-              const items = yield* encodeMany(it).pipe(Effect.orDie)
-              // TODO: we should have a batchRemove on store so the adapter can actually batch...
-              for (const e of items) {
-                yield* store.remove(mapToPersistenceModel(e, get))
-                set(e[idKey], undefined)
-              }
-              yield* Effect
-                .sync(() => toNonEmptyArray([...events]))
+          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.
-                .pipe((_) => Effect.flatMapOption(_, pub))
+                (_) => Effect.flatMapOption(_, pub),
+                Effect.andThen(changeFeed.publish([Chunk.toArray(it), "save"])),
+                Effect.asVoid
+              )
+          })
 
-              yield* changeFeed.publish([it, "remove"])
-            })
-          }
+          const removeAndPublish = Effect.fn("removeAndPublish")(function*(a: Iterable<T>, events: Iterable<Evt> = []) {
+            const { get, 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)
+            // TODO: we should have a batchRemove on store so the adapter can actually batch...
+            for (const e of items) {
+              yield* store.remove(mapToPersistenceModel(e, get))
+              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((_) => Effect.flatMapOption(_, pub))
+
+            yield* changeFeed.publish([it, "remove"])
+          })
 
           const parseMany = (items: readonly PM[]) =>
             Effect

package/src/QueueMaker/sbqueue.ts

@@ -1,9 +1,8 @@
-import type {} from "@azure/service-bus"
 import { Tracer } from "effect"
-import { Cause, Effect, flow, Layer, S } from "effect-app"
+import { Cause, Effect, flow, S } from "effect-app"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
-import { LiveSender, LiveServiceBusClient, Sender, ServiceBusReceiverFactory, subscribe } from "../adapters/ServiceBus.js"
+import { Receiver, Sender } from "../adapters/ServiceBus.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
@@ -15,8 +14,6 @@ export function makeServiceBusQueue<
   EvtE,
   DrainEvtE
 >(
-  queueName: string,
-  queueDrainName: string,
   schema: S.Schema<Evt, EvtE>,
   drainSchema: S.Schema<DrainEvt, DrainEvtE>
 ) {
@@ -28,10 +25,10 @@ export function makeServiceBusQueue<
   const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
 
   return Effect.gen(function*() {
-    const s = yield* Sender
-    const receiver = yield* ServiceBusReceiverFactory
-    const silenceAndReportError = reportNonInterruptedFailure({ name: "ServiceBusQueue.drain." + queueDrainName })
-    const reportError = reportNonInterruptedFailureCause({ name: "ServiceBusQueue.drain." + queueDrainName })
+    const sender = yield* Sender
+    const receiver = yield* Receiver
+    const silenceAndReportError = reportNonInterruptedFailure({ name: receiver.name })
+    const reportError = reportNonInterruptedFailureCause({ name: receiver.name })
 
     // TODO: or do async?
     // This will make sure that the host receives the error (MainFiberSet.join), who will then interrupt everything and commence a shutdown and restart of app
@@ -54,7 +51,7 @@ export function makeServiceBusQueue<
                   Effect
                     .flatMap(({ body, meta }) => {
                       let effect = InfraLogger
-                        .logDebug(`[${queueDrainName}] Processing incoming message`)
+                        .logDebug(`[${receiver.name}] Processing incoming message`)
                         .pipe(
                           Effect.annotateLogs({
                             body: pretty(body),
@@ -70,12 +67,12 @@ export function makeServiceBusQueue<
                             setupRequestContextWithCustomSpan(
                               _,
                               meta,
-                              `queue.drain: ${queueDrainName}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
+                              `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
                               {
                                 captureStackTrace: false,
                                 kind: "consumer",
                                 attributes: {
-                                  "queue.name": queueDrainName,
+                                  "queue.name": receiver.name,
                                   "queue.sessionId": sessionId,
                                   "queue.input": body
                                 }
@@ -95,16 +92,16 @@ export function makeServiceBusQueue<
                 )
             }
 
-            return yield* subscribe({
-              processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-              processError: (err) => reportQueueError(Cause.fail(err.error))
-              // Deferred.completeWith(
-              //   deferred,
-              //   reportFatalQueueError(Cause.fail(err.error))
-              //     .pipe(Effect.andThen(Effect.fail(err.error)))
-              // )
-            }, sessionId)
-              .pipe(Effect.provideService(ServiceBusReceiverFactory, receiver))
+            return yield* receiver
+              .subscribe({
+                processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
+                processError: (err) => reportQueueError(Cause.fail(err.error))
+                // Deferred.completeWith(
+                //   deferred,
+                //   reportFatalQueueError(Cause.fail(err.error))
+                //     .pipe(Effect.andThen(Effect.fail(err.error)))
+                // )
+              }, sessionId)
           })
           // .pipe(Effect.andThen(Deferred.await(deferred).pipe(Effect.orDie))),
           .pipe(
@@ -115,25 +112,21 @@ export function makeServiceBusQueue<
         Effect
           .gen(function*() {
             const requestContext = yield* getRequestContext
-            return yield* Effect
-              .promise((abortSignal) =>
-                s.sendMessages(
-                  messages.map((m) => ({
-                    body: JSON.stringify(
-                      S.encodeSync(wireSchema)({
-                        body: m,
-                        meta: requestContext
-                      })
-                    ),
-                    messageId: m.id, /* correllationid: requestId */
-                    contentType: "application/json",
-                    sessionId: "sessionId" in m ? m.sessionId : undefined
-                  })),
-                  { abortSignal }
-                )
-              )
+            return yield* sender.sendMessages(
+              messages.map((m) => ({
+                body: JSON.stringify(
+                  S.encodeSync(wireSchema)({
+                    body: m,
+                    meta: requestContext
+                  })
+                ),
+                messageId: m.id, /* correllationid: requestId */
+                contentType: "application/json",
+                sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
+              }))
+            )
           })
-          .pipe(Effect.withSpan("queue.publish: " + queueName, {
+          .pipe(Effect.withSpan("queue.publish: " + sender.name, {
             captureStackTrace: false,
             kind: "producer",
             attributes: { "message_tags": messages.map((_) => _._tag) }
@@ -141,9 +134,3 @@ export function makeServiceBusQueue<
     } satisfies QueueBase<Evt, DrainEvt>
   })
 }
-
-export function makeServiceBusLayers(url: string, queueName: string, queueDrainName: string) {
-  return Layer.merge(ServiceBusReceiverFactory.Live(queueDrainName), LiveSender(queueName)).pipe(
-    Layer.provide(LiveServiceBusClient(url))
-  )
-}

package/src/adapters/ServiceBus.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
-import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver, type ServiceBusSender } from "@azure/service-bus"
+import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
 import { Cause, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
@@ -18,12 +18,13 @@ function makeClient(url: string) {
   )
 }
 
-const Client = Context.GenericTag<ServiceBusClient>("@services/Client")
-export const LiveServiceBusClient = (url: string) => Layer.scoped(Client)(makeClient(url))
+export class ServiceBusClientTag extends Context.Tag("@services/Client")<ServiceBusClientTag, ServiceBusClient>() {
+  static readonly layer = (url: string) => Layer.scoped(this, makeClient(url))
+}
 
-function makeSender(queueName: string) {
+function makeSender_(queueName: string) {
   return Effect.gen(function*() {
-    const serviceBusClient = yield* Client
+    const serviceBusClient = yield* ServiceBusClientTag
 
     return yield* Effect.acquireRelease(
       Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
@@ -33,112 +34,159 @@ function makeSender(queueName: string) {
     )
   })
 }
-export const Sender = Context.GenericTag<ServiceBusSender>("@services/Sender")
 
-export function LiveSender(queueName: string) {
-  return Layer
-    .scoped(Sender, makeSender(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 { name, sendMessages }
+  })
+
+export class Sender extends Context.TagId("Sender")<Sender, {
+  name: string
+  sendMessages: (
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal"> | undefined
+  ) => Effect.Effect<void, never, never>
+}>() {
+  static readonly layer = (name: string) => this.toLayerScoped(makeSender(name))
 }
 
-function makeReceiver(queueName: string, waitTillEmpty: Effect<void>, sessionId?: string) {
-  return Effect.gen(function*() {
-    const serviceBusClient = yield* Client
+export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Tag(`ServiceBus.Sender.${queueName}`)<
+    Id,
+    Sender
+  >()
 
-    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}`)
-        )
+  return Object.assign(tag, {
+    layer: Layer.scoped(
+      tag,
+      makeSender(queueName).pipe(Effect.map((_) => Sender.of(_)))
     )
   })
 }
 
-export class ServiceBusReceiverFactory extends Context.TagId(
-  "ServiceBusReceiverFactory"
-)<ServiceBusReceiverFactory, {
+const makeReceiver = (name: string) =>
+  Effect.gen(function*() {
+    const serviceBusClient = yield* ServiceBusClientTag
+
+    const makeReceiver = Effect.fnUntraced(
+      function*(queueName: string, waitTillEmpty: 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<void>) => makeReceiver(name, waitTillEmpty)
+
+    const makeSession = (sessionId: string, waitTillEmpty: 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<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, { renderErrorCause: true }))
+                }
+              })
+          )
+        yield* Effect.acquireRelease(
+          Effect
+            .sync(() =>
+              r
+                .subscribe({
+                  processError: (err) =>
+                    runEffect(
+                      hndlr
+                        .processError(err)
+                        .pipe(
+                          Effect.catchAllCause((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!
+                })
+            )
+            .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
+          (subscription) =>
+            Effect.promise(() => subscription.close()).pipe(
+              withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
+            )
+        )
+      })
+    }
+  })
+
+export class Receiver extends Context.TagId("Receiver")<Receiver, {
+  name: string
   make: (waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
   makeSession: (sessionId: string, waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
+  subscribe<RMsg, RErr>(
+    hndlr: MessageHandlers<RMsg, RErr>,
+    sessionId?: string
+  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
 }>() {
-  static readonly Live = (queueName: string) =>
-    this.toLayer(Client.pipe(Effect.andThen((cl) => ({
-      make: (waitTillEmpty: Effect<void>) =>
-        makeReceiver(queueName, waitTillEmpty).pipe(Effect.provideService(Client, cl)),
-      makeSession: (sessionId: string, waitTillEmpty: Effect<void>) =>
-        makeReceiver(queueName, waitTillEmpty, sessionId).pipe(Effect.provideService(Client, cl))
-    }))))
+  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
 }
 
-export function sendMessages(
-  messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-  options?: OperationOptionsBase
-) {
-  return Effect.gen(function*() {
-    const s = yield* Sender
-    return yield* Effect.promise(() => s.sendMessages(messages, options))
-  })
-}
+export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Tag(`ServiceBus.Receiver.${queueName}`)<Id, Receiver>()
 
-export function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-  return Effect.gen(function*() {
-    const rf = yield* ServiceBusReceiverFactory
-    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
-      ? rf.makeSession(
-        sessionId,
-        wait
-      )
-      : rf.make(wait)
-
-    const runEffect = <E>(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, { renderErrorCause: true }))
-            }
-          })
-      )
-    yield* Effect.acquireRelease(
-      Effect
-        .sync(() =>
-          r
-            .subscribe({
-              processError: (err) =>
-                runEffect(
-                  hndlr
-                    .processError(err)
-                    .pipe(Effect.catchAllCause((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!
-            })
-        )
-        .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
-      (subscription) =>
-        Effect.promise(() => subscription.close()).pipe(withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`))
+  return Object.assign(tag, {
+    layer: Layer.effect(
+      tag,
+      makeReceiver(queueName).pipe(Effect.map((_) => Receiver.of(_)))
     )
   })
 }
 
+export const SenderReceiver = (queue: string, queueDrain?: string) =>
+  Layer.mergeAll(Sender.layer(queue), Receiver.layer(queueDrain ?? queue))
+
 export interface MessageHandlers<RMsg, RErr> {
   /**
    * Handler that processes messages from service bus.

package/src/api/routing/middleware/middleware-api.ts

@@ -2,6 +2,7 @@
 import { type AnyWithProps } from "@effect/rpc/Rpc"
 import { Context, type Effect, type NonEmptyArray, type NonEmptyReadonlyArray, S } from "effect-app"
 import { type GetContextConfig, type RPCContextMap } from "effect-app/client"
+import { type TypeTestId } from "../../routing.js"
 import { type MiddlewareMaker, middlewareMaker } from "./generic-middleware.js"
 import { type AnyDynamic, type RpcDynamic, Tag, type TagClassAny } from "./RpcMiddleware.js"
 
@@ -103,7 +104,7 @@ export interface BuildingMiddleware<
     : never
 
   // helps debugging what are the missing requirements (type only)
-  missing: {
+  readonly [TypeTestId]: {
     missingDynamicMiddlewares: Exclude<keyof RequestContextMap, Provided>
     missingContext: MiddlewareR
   }

package/src/api/routing/middleware.ts

@@ -1,5 +1,4 @@
 // codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
-export * from "./middleware/dynamic-middleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"