@effect-app/infra 4.0.0-beta.281 → 4.0.0-beta.283

package/src/QueueMaker/memQueue.ts

@@ -1,136 +0,0 @@
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import { QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Cause from "effect/Cause"
-import * as Fiber from "effect/Fiber"
-import { flow } from "effect/Function"
-import * as Q from "effect/Queue"
-import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.ts"
-import { MemQueue } from "../memQueue.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.ts"
-
-export const makeMemQueue = Effect.fnUntraced(function*<
-  Evt extends { id: S.StringId; _tag: string },
-  DrainEvt extends { id: S.StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  queueName: string,
-  queueDrainName: string,
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const mem = yield* MemQueue
-  const q = yield* mem.getOrCreateQueue(queueName)
-  const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
-
-  const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
-  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
-  const encodePublish = S.encodeEffect(wireSchemaJson)
-  const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
-
-  const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
-
-  const queue = {
-    publish: Effect.fn(`publish ${queueName}`, {
-      kind: "producer",
-      attributes: {
-        "messaging.system": "memory",
-        "messaging.operation.name": "publish",
-        "messaging.destination.name": queueName
-      }
-    })(function*(
-      ...messages: NonEmptyReadonlyArray<Evt>
-    ) {
-      yield* Effect.annotateCurrentSpan({
-        "messaging.batch.message_count": messages.length,
-        "messaging.message.types": messages.map((_) => _._tag)
-      })
-      const requestContext = yield* getRequestContext
-      // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-      yield* Effect.forEach(
-        messages,
-        (m) =>
-          encodePublish({ body: m, meta: requestContext }).pipe(
-            Effect.orDie,
-            Effect.flatMap((_) => Q.offer(q, _))
-          ),
-        { discard: true }
-      )
-    }),
-    drain: <DrainE, DrainR>(
-      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-      sessionId?: string
-    ) => {
-      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-      const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
-      const processMessage = Effect.fnUntraced(function*(msg: string) {
-        // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-        const { body, meta } = yield* parseDrain(msg).pipe(Effect.orDie)
-        let effect = InfraLogger
-          .logDebug(`[${queueDrainName}] Processing incoming message`)
-          .pipe(
-            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-            Effect.andThen(handleEvent(body)),
-            silenceAndReportError,
-            (_) => {
-              const args = messagingSpanArgs({
-                operation: "process",
-                system: "memory",
-                destination: queueDrainName,
-                messageId: body.id,
-                conversationId: sessionId,
-                extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
-              }, "consumer")
-              return setupRequestContextWithCustomSpan(
-                _,
-                meta,
-                args.name,
-                {
-                  captureStackTrace: false,
-                  kind: args.kind,
-                  attributes: args.attributes
-                }
-              )
-            }
-          )
-        if (meta.span) {
-          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-        }
-        return yield* effect
-      })
-      return Effect.fn(`receive ${queueDrainName}`, {
-        kind: "consumer",
-        attributes: {
-          "messaging.system": "memory",
-          "messaging.operation.name": "receive",
-          "messaging.destination.name": queueDrainName,
-          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
-        }
-      })(function*() {
-        const x = yield* Q.take(qDrain)
-        const exit = yield* processMessage(x).pipe(
-          Effect.uninterruptible,
-          Effect.forkChild,
-          Effect.flatMap(Fiber.join)
-        )
-        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
-          // normally a failed item would be returned to the queue and retried up to X times.
-          yield* Q.offer(qDrain, x).pipe(
-            // TODO: retry count tracking and max retries.
-            Effect.delay("5 seconds"),
-            Effect.tapCause(reportError),
-            Effect.forkDetach
-          )
-        }
-      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
-    }
-  }
-  return queue
-})

package/src/QueueMaker/sbqueue.ts

@@ -1,125 +0,0 @@
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import { QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import type { StringId } from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Cause from "effect/Cause"
-import { flow } from "effect/Function"
-import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { Receiver, Sender } from "../ServiceBus.ts"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.ts"
-
-export function makeServiceBusQueue<
-  Evt extends { id: StringId; _tag: string },
-  DrainEvt extends { id: StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const wireSchema = S.Struct({
-    body: schema,
-    meta: QueueMeta
-  })
-  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
-  const encodePublish = S.encodeEffect(wireSchemaJson)
-  const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
-  const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
-
-  return Effect.gen(function*() {
-    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
-    // const deferred = yield* Deferred.make<never, ServiceBusError | Error>()
-
-    const queue = {
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const processMessage = Effect.fnUntraced(function*(messageBody: unknown) {
-          const { body, meta } = yield* parseDrain(messageBody).pipe(Effect.orDie)
-          let effect = InfraLogger
-            .logDebug(`[${receiver.name}] Processing incoming message`)
-            .pipe(
-              Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-              Effect.andThen(handleEvent(body)),
-              Effect.orDie,
-              // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-              silenceAndReportError,
-              (_) => {
-                const args = messagingSpanArgs({
-                  operation: "process",
-                  system: "servicebus",
-                  destination: receiver.name,
-                  messageId: body.id,
-                  conversationId: sessionId,
-                  extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
-                }, "consumer")
-                return setupRequestContextWithCustomSpan(
-                  _,
-                  meta,
-                  args.name,
-                  {
-                    captureStackTrace: false,
-                    kind: args.kind,
-                    attributes: args.attributes
-                  }
-                )
-              }
-            )
-          if (meta.span) {
-            effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-          }
-          // we reportError here, so that we report the error only, and keep flowing
-          const exit = yield* Effect.tapCause(effect, reportError)
-          return yield* exit
-        })
-
-        return receiver
-          .subscribe({
-            processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-            processError: (err) => reportQueueError(Cause.fail(err.error))
-          }, sessionId)
-          .pipe(Effect.andThen(Effect.never))
-      },
-
-      publish: Effect.fn(`publish ${sender.name}`, {
-        kind: "producer",
-        attributes: {
-          "messaging.system": "servicebus",
-          "messaging.operation.name": "publish",
-          "messaging.destination.name": sender.name
-        }
-      })(function*(...messages: NonEmptyReadonlyArray<Evt>) {
-        yield* Effect.annotateCurrentSpan({
-          "messaging.batch.message_count": messages.length,
-          "messaging.message.types": messages.map((_) => _._tag)
-        })
-        const requestContext = yield* getRequestContext
-        const msgs = yield* Effect.forEach(messages, (m) =>
-          encodePublish({ body: m, meta: requestContext }).pipe(
-            Effect.orDie,
-            Effect.map((body) => ({
-              body,
-              messageId: m.id, /* correllationid: requestId */
-              contentType: "application/json",
-              sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
-            }))
-          ))
-        yield* sender.sendMessages(msgs)
-      })
-    }
-    return queue
-  })
-}

package/src/RequestFiberSet.ts

@@ -1,110 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import * as Option from "effect-app/Option"
-import * as Fiber from "effect/Fiber"
-import * as FiberSet from "effect/FiberSet"
-import type * as Tracer from "effect/Tracer"
-import { InfraLogger } from "./logger.ts"
-import { reportRequestError, reportUnknownRequestError } from "./reportError.ts"
-
-const getRootParentSpan = Effect.gen(function*() {
-  let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(
-    Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
-  )
-  if (!span) return span
-  while (span._tag === "Span" && Option.isSome(span.parent)) {
-    span = span.parent.value
-  }
-  return span
-})
-
-export const setRootParentSpan = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  getRootParentSpan.pipe(Effect.andThen((span) => span ? Effect.withParentSpan(self, span) : self))
-
-const make = Effect.gen(function*() {
-  const set = yield* FiberSet.make<any, any>()
-  const add = (...fibers: Fiber.Fiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
-  const addAll = (fibers: readonly Fiber.Fiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
-  const join = FiberSet.size(set).pipe(
-    Effect.andThen((count) => InfraLogger.logInfo(`Joining ${count} current fibers on the RequestFiberSet`)),
-    Effect.andThen(FiberSet.join(set))
-  )
-  const run = FiberSet.run(set)
-  const register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    self.pipe(Effect.forkChild, Effect.tap(add), Effect.andThen(Fiber.join))
-
-  // const waitUntilEmpty = Effect.gen(function*() {
-  //   const currentSize = yield* FiberSet.size(set)
-  //   if (currentSize === 0) {
-  //     return
-  //   }
-  //   yield* Effect.logInfo("Waiting RequestFiberSet to be empty: " + currentSize)
-  //   while ((yield* FiberSet.size(set)) > 0) yield* Effect.sleep("250 millis")
-  //   yield* Effect.logDebug("RequestFiberSet is empty")
-  // })
-  // TODO: loop and interrupt all fibers in the set continuously?
-  const interrupt = Fiber.interruptAll(set)
-
-  /**
-   * Forks the effect into a new fiber attached to the RequestFiberSet scope. Because the
-   * new fiber isn't attached to the parent, when the fiber executing the
-   * returned effect terminates, the forked fiber will continue running.
-   * The fiber will be interrupted when the RequestFiberSet scope is closed.
-   *
-   * Reports errors.
-   */
-  function forkDaemonReport<R, E, A>(self: Effect.Effect<A, E, R>) {
-    return self.pipe(
-      reportRequestError,
-      Effect.uninterruptible,
-      run
-    )
-  }
-
-  /**
-   * Forks the effect into a new fiber attached to the RequestFiberSet scope. Because the
-   * new fiber isn't attached to the parent, when the fiber executing the
-   * returned effect terminates, the forked fiber will continue running.
-   * The fiber will be interrupted when the RequestFiberSet scope is closed.
-   *
-   * Reports unexpected errors.
-   */
-  function forkDaemonReportUnexpected<R, E, A>(self: Effect.Effect<A, E, R>) {
-    return self
-      .pipe(
-        reportUnknownRequestError,
-        Effect.uninterruptible,
-        run
-      )
-  }
-
-  return {
-    interrupt,
-    join,
-    run,
-    add,
-    addAll,
-    register,
-    forkDaemonReport,
-    forkDaemonReportUnexpected
-  }
-})
-
-/**
- * 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 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.pipe(Effect.andThen((_) => _.register(self)))
-  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) => this.pipe(Effect.andThen((_) => _.run(self)))
-  static readonly forkDaemonReport = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
-  static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.pipe(Effect.andThen((_) => _.forkDaemonReportUnexpected(self)))
-}

package/src/ServiceBus.ts

@@ -1,219 +0,0 @@
-/* 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 * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import * as Cause from "effect/Cause"
-import * as Exit from "effect/Exit"
-import * as FiberSet from "effect/FiberSet"
-import type * as Scope from "effect/Scope"
-import { InfraLogger } from "./logger.ts"
-
-const logged = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  Effect.logInfo(name).pipe(
-    Effect.andThen(self),
-    Effect.tap(Effect.logInfo(name + " done")),
-    Effect.withLogSpan(name)
-  )
-
-function makeClient(url: string) {
-  return Effect.acquireRelease(
-    Effect.sync(() => new ServiceBusClient(url)).pipe(logged("ServiceBus.client.create")),
-    (client) => Effect.promise(() => client.close()).pipe(logged("ServiceBus.client.close"))
-  )
-}
-
-export class ServiceBusClientTag
-  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
-{
-  static readonly layer = (url: string) => this.toLayer(this.make(url))
-}
-
-const makeSender_ = Effect.fnUntraced(function*(queueName: string) {
-  const serviceBusClient = yield* ServiceBusClientTag
-
-  return yield* Effect.acquireRelease(
-    Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
-      logged(`ServiceBus.sender.create ${queueName}`)
-    ),
-    (sender) => Effect.promise(() => sender.close()).pipe(logged(`ServiceBus.sender.close ${queueName}`))
-  )
-})
-
-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 }))
-  })
-
-  return { name, sendMessages }
-})
-
-export class Sender extends Context.Opaque<Sender, {
-  name: string
-  sendMessages: (
-    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-    options?: Omit<OperationOptionsBase, "abortSignal">
-  ) => 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 = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
-
-  return Object.assign(tag, {
-    layer: Layer.effect(
-      tag,
-      Sender.make(queueName).pipe(Effect.map(Sender.of))
-    )
-  })
-}
-
-const makeReceiver = Effect.fnUntraced(function*(name: string) {
-  const serviceBusClient = yield* ServiceBusClientTag
-
-  const makeReceiver = Effect.fnUntraced(
-    function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
-      const annotate = sessionId !== undefined
-        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
-        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
-      return yield* Effect.acquireRelease(
-        (sessionId
-          ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-          : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-          .pipe(logged(`ServiceBus.receiver.create ${queueName}`), annotate),
-        (r) =>
-          waitTillEmpty.pipe(
-            logged(`ServiceBus.receiver.waitTillEmpty ${queueName}`),
-            Effect.andThen(
-              Effect.promise(() => r.close()).pipe(
-                logged(`ServiceBus.receiver.close ${queueName}`)
-              )
-            ),
-            logged(`ServiceBus.receiver.release ${queueName}`),
-            annotate
-          )
-      )
-    }
-  )
-
-  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 annotate = sessionId !== undefined
-        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
-        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
-      yield* Effect.acquireRelease(
-        Effect
-          .sync(() => {
-            const s = r
-              .subscribe({
-                processError: (err) =>
-                  runEffect(
-                    hndlr
-                      .processError(err)
-                      .pipe(
-                        Effect.catchCause((cause) => Effect.logError("ServiceBus Error", cause)),
-                        annotate
-                      )
-                  ),
-                processMessage: (msg) => runEffect(hndlr.processMessage(msg).pipe(annotate))
-                // DO NOT CATCH ERRORS here as they should return to the queue!
-              })
-            return { close: Effect.promise(() => s.close()) }
-          })
-          .pipe(logged("ServiceBus.subscription.create"), annotate),
-        (subscription) =>
-          subscription.close.pipe(
-            logged("ServiceBus.subscription.close"),
-            annotate
-          )
-      ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
-    })
-  }
-})
-
-export class Receiver extends Context.Opaque<Receiver, {
-  name: string
-  make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  makeSession: (
-    sessionId: string,
-    waitTillEmpty: Effect.Effect<void>
-  ) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  subscribe<RMsg, RErr>(
-    hndlr: MessageHandlers<RMsg, RErr>,
-    sessionId?: string
-  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
-}>()("Receiver") {
-  static readonly make = makeReceiver
-  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
-}
-
-export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
-
-  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.
-   *
-   * @param message - A message received from Service Bus.
-   */
-  processMessage(message: ServiceBusReceivedMessage): Effect.Effect<void, never, RMsg>
-  /**
-   * Handler that processes errors that occur during receiving.
-   * @param args - The error and additional context to indicate where
-   * the error originated.
-   */
-  processError(args: ProcessErrorArgs): Effect.Effect<void, never, RErr>
-}

package/src/memQueue.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Queue from "effect/Queue"
-
-const make = Effect
-  .gen(function*() {
-    const store = yield* Effect.sync(() => new Map<string, Queue.Queue<string>>())
-
-    return {
-      getOrCreateQueue: Effect.fnUntraced(function*(k: string) {
-        const q = store.get(k)
-        if (q) return q
-        const newQ = yield* Queue.unbounded<string>()
-        store.set(k, newQ)
-        return newQ
-      })
-    }
-  })
-
-export class MemQueue extends Context.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
-  static readonly Live = this.toLayer(this.make)
-}