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

package/src/routing.ts

@@ -2,9 +2,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Array from "effect-app/Array"
 import type { NonEmptyReadonlyArray } from "effect-app/Array"
 import { getMeta } from "effect-app/client"
 import * as Config from "effect-app/Config"
+import * as DataDependencies from "effect-app/DataDependencies"
 import * as Effect from "effect-app/Effect"
 import { type HttpHeaders } from "effect-app/http"
 import * as Layer from "effect-app/Layer"
@@ -454,10 +456,19 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                   // clients can invalidate queries even when the stream fails.
                   const keysRef = Ref.makeUnsafe<ReadonlyArray<Invalidation.InvalidationKey>>([])
                   const invalidationSet = Invalidation.makeInvalidationSet(keysRef)
+                  const readsRef = Ref.makeUnsafe<DataDependencies.DataDependencies>([])
+                  const writesRef = Ref.makeUnsafe<DataDependencies.DataDependencies>([])
+                  const dependencyRecorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+                  const metadata = (keys: ReadonlyArray<Invalidation.InvalidationKey>) =>
+                    Effect.map(
+                      dependencyRecorder.drain,
+                      (dataDependencies) => Invalidation.makeMetaData(keys, dataDependencies)
+                    )
                   return Stream.concat(
                     (result as Stream.Stream<any, any, any>).pipe(
                       Stream.map((item: any) => ({ _tag: "value" as const, value: item })),
                       Stream.provideService(Invalidation.InvalidationSet, invalidationSet),
+                      Stream.provideService(DataDependencies.DataDependencyRecorder, dependencyRecorder),
                       // V3: after each value chunk, drain accumulated keys and emit a "metadata"
                       // chunk if any keys were collected since the last drain. This lets clients
                       // invalidate queries mid-stream without waiting for the "done" chunk.
@@ -465,13 +476,19 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                         Stream
                           .fromEffect(
                             Ref.getAndSet(keysRef, []).pipe(
-                              Effect.map((keys) =>
-                                keys.length > 0
-                                  ? [
-                                    valueChunk,
-                                    { _tag: "metadata" as const, metadata: { invalidateQueries: keys } }
-                                  ]
-                                  : [valueChunk]
+                              Effect.flatMap((keys) =>
+                                metadata(keys).pipe(
+                                  Effect.map((meta) =>
+                                    Array.isReadonlyArrayNonEmpty(keys)
+                                      || Array.isReadonlyArrayNonEmpty(meta.dataDependencies.reads)
+                                      || Array.isReadonlyArrayNonEmpty(meta.dataDependencies.writes)
+                                      ? [
+                                        valueChunk,
+                                        { _tag: "metadata" as const, metadata: meta }
+                                      ]
+                                      : [valueChunk]
+                                  )
+                                )
                               )
                             )
                           )
@@ -482,11 +499,15 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                         Stream.fromEffect(
                           Ref.get(keysRef).pipe(
                             Effect.flatMap((keys) =>
-                              Effect.fail({
-                                _tag: "error" as const,
-                                error: err,
-                                metadata: { invalidateQueries: keys }
-                              })
+                              metadata(keys).pipe(
+                                Effect.flatMap((meta) =>
+                                  Effect.fail({
+                                    _tag: "error" as const,
+                                    error: err,
+                                    metadata: meta
+                                  })
+                                )
+                              )
                             )
                           )
                         )
@@ -494,7 +515,11 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                     ),
                     Stream.fromEffect(
                       Ref.get(keysRef).pipe(
-                        Effect.map((keys) => ({ _tag: "done" as const, metadata: { invalidateQueries: keys } }))
+                        Effect.flatMap((keys) =>
+                          metadata(keys).pipe(
+                            Effect.map((meta) => ({ _tag: "done" as const, metadata: meta }))
+                          )
+                        )
                       )
                     )
                   )
@@ -511,6 +536,13 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                   })
                   .pipe(Effect.andThen(result as Effect.Effect<unknown, unknown, unknown>))
 
+                const readsRef = Ref.makeUnsafe<DataDependencies.DataDependencies>([])
+                const writesRef = Ref.makeUnsafe<DataDependencies.DataDependencies>([])
+                const dependencyRecorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+                effect = effect.pipe(
+                  Effect.provideService(DataDependencies.DataDependencyRecorder, dependencyRecorder)
+                )
+
                 // Commands: provide a request-scoped `InvalidationSet` and wrap both
                 // success (`CommandResponseWithMetaData`) and handler-thrown failure
                 // (`CommandFailureWithMetaData`) so the client receives accumulated
@@ -525,21 +557,42 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                     Effect.provideService(Invalidation.InvalidationSet, invalidationSet),
                     Effect.flatMap((value) =>
                       Ref.get(keysRef).pipe(
-                        Effect.map((keys) => ({ payload: value, metadata: { invalidateQueries: keys } }) as any)
+                        Effect.flatMap((keys) =>
+                          dependencyRecorder.get.pipe(
+                            Effect.map((dataDependencies) =>
+                              ({
+                                payload: value,
+                                metadata: Invalidation.makeMetaData(keys, dataDependencies)
+                              }) as any
+                            )
+                          )
+                        )
                       )
                     ),
                     Effect.catch((err: any) =>
                       Ref.get(keysRef).pipe(
                         Effect.flatMap((keys) =>
-                          Effect.fail({
-                            _tag: "CommandFailureWithMetaData" as const,
-                            error: err,
-                            metadata: { invalidateQueries: keys }
-                          })
+                          dependencyRecorder.get.pipe(
+                            Effect.flatMap((dataDependencies) =>
+                              Effect.fail({
+                                _tag: "CommandFailureWithMetaData" as const,
+                                error: err,
+                                metadata: Invalidation.makeMetaData(keys, dataDependencies)
+                              })
+                            )
+                          )
                         )
                       )
                     )
                   )
+                } else {
+                  effect = effect.pipe(
+                    Effect.flatMap((value) =>
+                      dependencyRecorder.get.pipe(
+                        Effect.map((dataDependencies) => ({ payload: value, metadata: { dataDependencies } }) as any)
+                      )
+                    )
+                  )
                 }
 
                 return applyRequestTypeInterruptibility(resource.type, effect)
@@ -584,7 +637,7 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                     })
                   : Rpc.make(resource._tag, {
                     payload: resource,
-                    success: resource.success,
+                    success: isStream ? resource.success : Invalidation.QueryResponseWithMetaData(resource.success),
                     error: resource.error,
                     stream: isStream
                   }))

package/test/repository-ext.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, it } from "@effect/vitest"
+import * as DataDependencies from "effect-app/DataDependencies"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
 import { makeRepo } from "effect-app/Model/Repository"
 import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
 import * as S from "effect-app/Schema"
 import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
+import * as Ref from "effect/Ref"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 
 class BatchItem extends S.Class<BatchItem>("BatchItem")({
@@ -59,4 +61,29 @@ describe("repository ext save/remove batching", () => {
         setupRequestContextFromCurrent(),
         Effect.provide(TestStoreLive)
       ))
+
+  it.effect("records repository read and write dependencies", () =>
+    Effect
+      .gen(function*() {
+        const readsRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+        const writesRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+        const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+
+        yield* Effect
+          .gen(function*() {
+            const repo = yield* makeRepo("DependencyItem", BatchItem, {})
+            yield* repo.save(new BatchItem({ id: "1", label: "one" }))
+            yield* repo.all
+            yield* repo.find("1")
+            yield* repo.removeById("1")
+          })
+          .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder))
+
+        expect(yield* Ref.get(readsRef)).toEqual([DataDependencies.repo("DependencyItem")])
+        expect(yield* Ref.get(writesRef)).toEqual([DataDependencies.repo("DependencyItem")])
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
 })

package/test/rpc-e2e-invalidation.test.ts

@@ -14,12 +14,15 @@
  */
 import { NodeHttpServer } from "@effect/platform-node"
 import { expect, it } from "@effect/vitest"
-import { ApiClientFactory, InvalidationKeysFromServer, makeInvalidationKeysService, makeRpcClient } from "effect-app/client"
+import { ApiClientFactory, DataDependencies, InvalidationKeysFromServer, InvalidStateError, makeInvalidationKeysService, makeRpcClient, OptimisticConcurrencyException } from "effect-app/client"
+import * as Context from "effect-app/Context"
 import { HttpRouter, HttpServer } from "effect-app/http"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeRepo, RepositoryRegistryLive } from "effect-app/Model"
 import { Invalidation, MiddlewareMaker } from "effect-app/rpc"
 import * as S from "effect-app/Schema"
 import { TaggedErrorClass } from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Layer from "effect/Layer"
@@ -31,6 +34,7 @@ import { RpcSerialization } from "effect/unstable/rpc"
 import { createServer } from "http"
 import { makeRouter } from "../src/routing.js"
 import { DefaultGenericMiddlewaresLive } from "../src/routing/middleware.js"
+import { MemoryStoreLive } from "../src/Store/Memory.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, SomeElseMiddleware, SomeElseMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 
 // ---------------------------------------------------------------------------
@@ -99,14 +103,82 @@ class StreamWithKey extends Req.Command<StreamWithKey>()("StreamWithKey", {}, {
   success: S.Number
 }) {}
 
-const InvRsc = { DoNothing, DoWithDynamicKey, DoWithBothKeys, DoAndFail, StreamWithKey }
+class StreamWithRepoWrite extends Req.Command<StreamWithRepoWrite>()("StreamWithRepoWrite", {}, {
+  stream: true,
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class RepoItem extends S.Class<RepoItem>("RepoItem")({
+  id: S.String,
+  label: S.String
+}) {}
+
+class GetRepoCount extends Req.Query<GetRepoCount>()("GetRepoCount", {}, {
+  allowAnonymous: true,
+  success: S.Number
+}) {}
+
+class SaveRepoItem extends Req.Command<SaveRepoItem>()("SaveRepoItem", {
+  id: S.String,
+  label: S.String
+}, {
+  allowAnonymous: true,
+  error: S.Union([InvalidStateError, OptimisticConcurrencyException]),
+  success: S.Void
+}) {}
+
+class RepoItems extends Context.Service<RepoItems>()("RepoItems", {
+  make: makeRepo("RepoItem", RepoItem, {})
+}) {
+  static Default = Layer.effect(this, this.make).pipe(
+    Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive))
+  )
+}
+
+// A second, unrelated repo — its writes must NOT invalidate a query that only read `RepoItem`.
+class OtherItem extends S.Class<OtherItem>("OtherItem")({
+  id: S.String,
+  label: S.String
+}) {}
+
+class SaveOtherItem extends Req.Command<SaveOtherItem>()("SaveOtherItem", {
+  id: S.String,
+  label: S.String
+}, {
+  allowAnonymous: true,
+  success: S.Void
+}) {}
+
+class OtherItems extends Context.Service<OtherItems>()("OtherItems", {
+  make: makeRepo("OtherItem", OtherItem, {})
+}) {
+  static Default = Layer.effect(this, this.make).pipe(
+    Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive))
+  )
+}
+
+const InvRsc = {
+  DoNothing,
+  DoWithDynamicKey,
+  DoWithBothKeys,
+  DoAndFail,
+  StreamWithKey,
+  StreamWithRepoWrite,
+  GetRepoCount,
+  SaveRepoItem,
+  SaveOtherItem
+}
 
 // ---------------------------------------------------------------------------
 // Controllers / router
 // ---------------------------------------------------------------------------
 
 const router = Router(InvRsc)({
+  dependencies: [RepoItems.Default, OtherItems.Default],
   *effect(match) {
+    const repo = yield* RepoItems
+    const otherRepo = yield* OtherItems
     return match({
       DoNothing: () => Effect.void,
       DoWithDynamicKey: Effect.fnUntraced(function*() {
@@ -125,7 +197,18 @@ const router = Router(InvRsc)({
       StreamWithKey: () =>
         Stream.fromIterable([1, 2, 3]).pipe(
           Stream.tap(() => Invalidation.InvalidationSet.use((_) => _.add(StreamKey)))
-        )
+        ),
+      StreamWithRepoWrite: () =>
+        Stream.fromIterable([1, 2, 3]).pipe(
+          Stream.tap((n) =>
+            repo.save(new RepoItem({ id: String(n), label: "x" })).pipe(Effect.orDie, setupRequestContextFromCurrent())
+          )
+        ),
+      GetRepoCount: () => repo.all.pipe(Effect.map((_) => _.length), Effect.orDie, setupRequestContextFromCurrent()),
+      SaveRepoItem: ({ id, label }) =>
+        repo.save(new RepoItem({ id, label })).pipe(Effect.orDie, setupRequestContextFromCurrent()),
+      SaveOtherItem: ({ id, label }) =>
+        otherRepo.save(new OtherItem({ id, label })).pipe(Effect.orDie, setupRequestContextFromCurrent())
     })
   }
 })
@@ -171,6 +254,15 @@ const withCapture = <A, E, R>(eff: Effect.Effect<A, E, R>) =>
     return { result, keys: yield* Ref.get(ref) }
   })
 
+const withDependencyCapture = <A, E, R>(eff: Effect.Effect<A, E, R>) =>
+  Effect.gen(function*() {
+    const readsRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+    const writesRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+    const svc = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+    const result = yield* eff.pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, svc), Effect.exit)
+    return { result, dependencies: yield* svc.get }
+  })
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -254,3 +346,75 @@ it.live(
   }, Effect.provide(TestLayer)),
   { timeout: 10_000 }
 )
+
+it.live(
+  "stream: per-chunk repo writes are drained and forwarded to the client recorder",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+    const readsRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+    const writesRef = yield* Ref.make<DataDependencies.DataDependencies>([])
+    const svc = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef)
+    const values = yield* Stream.runCollect(client.StreamWithRepoWrite.handler()).pipe(
+      Effect.provideService(DataDependencies.DataDependencyRecorder, svc)
+    )
+    const writes = yield* Ref.get(writesRef)
+    expect(values).toStrictEqual([1, 2, 3])
+    // Each emitted value writes to RepoItem; routing drains the writes per chunk and the client
+    // accumulates them — the recorder dedupes, so a single RepoItem entry is recorded.
+    expect(writes).toStrictEqual([DataDependencies.repo("RepoItem")])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "repository dependencies flow through query and command metadata",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+
+    const query = yield* withDependencyCapture(client.GetRepoCount.handler())
+    expect(Exit.isSuccess(query.result) && query.result.value).toBe(0)
+    expect(query.dependencies.reads).toStrictEqual([DataDependencies.repo("RepoItem")])
+    expect(query.dependencies.writes).toStrictEqual([])
+
+    const command = yield* withDependencyCapture(client.SaveRepoItem.handler({ id: "1", label: "one" }))
+    expect(Exit.isSuccess(command.result)).toBe(true)
+    expect(command.dependencies.reads).toStrictEqual([])
+    expect(command.dependencies.writes).toStrictEqual([DataDependencies.repo("RepoItem")])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)
+
+it.live(
+  "query invalidation: a command's writes invalidate exactly the queries whose reads intersect",
+  Effect.fnUntraced(function*() {
+    const client = yield* ApiClientFactory.makeFor(Layer.empty)(InvRsc)
+
+    // Client-side query registry: queryKey -> read dependencies forwarded by the server. Mirrors
+    // @effect-app/vue's `dependencyMetadata`; the derivation predicate (`intersects`) is the exact
+    // one the vue mutate engine uses to pick invalidation targets from a command's writes.
+    const queryReads = new Map<string, DataDependencies.DataDependencies>()
+    const invalidatedBy = (writes: DataDependencies.DataDependencies) =>
+      [...queryReads]
+        .filter(([, reads]) => DataDependencies.intersects(reads, writes))
+        .map(([key]) => key)
+
+    // Run the query through the real client; register its forwarded reads under its key.
+    const query = yield* withDependencyCapture(client.GetRepoCount.handler())
+    expect(Exit.isSuccess(query.result)).toBe(true)
+    queryReads.set("GetRepoCount", query.dependencies.reads)
+    // Before any command, nothing is invalidated.
+    expect(invalidatedBy([])).toStrictEqual([])
+
+    // A command writing the SAME repo the query read => the query is selected for invalidation.
+    const save = yield* withDependencyCapture(client.SaveRepoItem.handler({ id: "1", label: "one" }))
+    expect(Exit.isSuccess(save.result)).toBe(true)
+    expect(invalidatedBy(save.dependencies.writes)).toStrictEqual(["GetRepoCount"])
+
+    // A command writing an UNRELATED repo => the query is NOT invalidated (negative control).
+    const saveOther = yield* withDependencyCapture(client.SaveOtherItem.handler({ id: "2", label: "two" }))
+    expect(Exit.isSuccess(saveOther.result)).toBe(true)
+    expect(saveOther.dependencies.writes).toStrictEqual([DataDependencies.repo("OtherItem")])
+    expect(invalidatedBy(saveOther.dependencies.writes)).toStrictEqual([])
+  }, Effect.provide(TestLayer)),
+  { timeout: 10_000 }
+)

package/src/QueueMaker/SQLQueue.ts

@@ -1,186 +0,0 @@
-import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors"
-import { subMinutes } from "date-fns"
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import * as Option from "effect-app/Option"
-import { type QueueBase, QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import { type NonEmptyString255 } from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Fiber from "effect/Fiber"
-import * as Tracer from "effect/Tracer"
-import { SqlClient } from "effect/unstable/sql"
-import { InfraLogger } from "../logger.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { SQLModel } from "../SQL.ts"
-
-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
-export const makeSQLQueue = Effect.fnUntraced(function*<
-  Evt extends { id: S.StringId; _tag: string },
-  DrainEvt extends { id: S.StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  queueName: NonEmptyString255,
-  queueDrainName: NonEmptyString255,
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const base = {
-    id: SQLModel.Generated(QueueId),
-    meta: SQLModel.JsonFromString(QueueMeta),
-    name: S.NonEmptyString255,
-    createdAt: SQLModel.DateTimeInsert,
-    updatedAt: SQLModel.DateTimeUpdate,
-    // TODO: at+owner
-    processingAt: SQLModel.FieldOption(S.Date),
-    finishedAt: SQLModel.FieldOption(S.Date),
-    etag: S.String // TODO: use a SQLModel thing that auto updates it?
-    // TODO: record locking.. / optimistic locking
-    // rowVersion: SQLModel.DateTimeFromNumberWithNow
-  }
-  class Queue extends SQLModel.Class<Queue>("Queue")({
-    body: SQLModel.JsonFromString(schema),
-    ...base
-  }) {}
-  class Drain extends SQLModel.Class<Drain>("Drain")({
-    body: SQLModel.JsonFromString(drainSchema),
-    ...base
-  }) {}
-  const sql = yield* SqlClient.SqlClient
-
-  const queueRepo = yield* SQLModel.makeRepository(Queue, {
-    tableName: "queue",
-    spanPrefix: "QueueRepo",
-    idColumn: "id",
-    versionColumn: "etag"
-  })
-
-  const drainRepo = yield* SQLModel.makeRepository(Drain, {
-    tableName: "queue",
-    spanPrefix: "DrainRepo",
-    idColumn: "id",
-    versionColumn: "etag"
-  })
-
-  const decodeDrain = S.decodeEffectConcurrently(Drain)
-
-  const drain = Effect.gen(function*() {
-    const limit = subMinutes(new Date(), 15)
-    return yield* sql<typeof Drain.Encoded>`SELECT *
-    FROM queue
-    WHERE name = ${queueDrainName} AND finishedAt IS NULL AND (processingAt IS NULL OR processingAt < ${limit.getTime()})
-    LIMIT 1`
-  })
-
-  const q = {
-    offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-      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) {
-        const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
-        if (first) {
-          const dec = yield* decodeDrain(first)
-          const { createdAt, updatedAt, ...rest } = dec
-          return yield* drainRepo.update(
-            Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
-          )
-        }
-        if (first) return first
-        yield* Effect.sleep(250)
-      }
-    }),
-    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: Effect.fn(`publish ${queueName}`, {
-      kind: "producer",
-      attributes: {
-        "messaging.system": "sql",
-        "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
-      yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
-    }),
-    drain: <DrainE, DrainR>(
-      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-      sessionId?: string
-    ) => {
-      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-      const processMessage = Effect.fnUntraced(function*({ body, meta }: Drain) {
-        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: "sql",
-                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": "sql",
-          "messaging.operation.name": "receive",
-          "messaging.destination.name": queueDrainName,
-          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
-        }
-      })(function*() {
-        const x = yield* q.take
-        yield* processMessage(x).pipe(
-          Effect.uninterruptible,
-          Effect.forkChild,
-          Effect.flatMap(Fiber.join),
-          Effect.tap(q.finish(x))
-        )
-      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
-    }
-  }
-  return queue as QueueBase<Evt, DrainEvt>
-})