@effect-app/infra 2.92.3 → 2.94.0

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

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Context, Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope } from "effect-app"
 
-import { type HttpRouter } from "effect-app/http"
+import { type HttpLayerRouter } from "effect-app/http"
 import { type Tag } from "effect/Context"
 import { type YieldWrap } from "effect/Utils"
 import { type ContextTagWithDefault, type GetContext, type LayerUtils, mergeContexts } from "./layerUtils.js"
@@ -50,12 +50,14 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // actual type in that position, I just wanna set the overall structure
   [K in keyof TDeps]: TDeps[K] extends //
   // E = never => the context provided cannot trigger errors
-  // TODO: remove HttpRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope?
-  //  _R extends HttpRouter.HttpRouter.Provided => the context provided can only have what HttpRouter.Provided provides as requirements
+  // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope?
+  //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
   (
     ContextTagWithDefault.Base<Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
-  ) ? [_R] extends [HttpRouter.HttpRouter.Provided] ? TDeps[K]
-    : `HttpRouter.HttpRouter.Provided is the only requirement ${TDeps[K]["Service"]["_tag"]}'s returned effect can have`
+  ) ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
+    : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
+      "_tag"
+    ]}'s returned effect can have`
     : TDeps[K] extends (
       ContextTagWithDefault.Base<
         & (() => Generator<
@@ -68,8 +70,8 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
     ) // [_YW] extends [never] if no yield* is used and just some context is returned
       ? [_YW] extends [never] ? TDeps[K]
       : [_YW] extends [YieldWrap<Effect<infer _2, never, infer _R>>]
-        ? [_R] extends [HttpRouter.HttpRouter.Provided] ? TDeps[K]
-        : `HttpRouter.HttpRouter.Provided is the only requirement ${TDeps[K]["Service"][
+        ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
+        : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
           "_tag"
         ]}'s returned effect can have`
       : "WTF are you yielding man?"

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"