@voltro/plugin-queue 0.84.0 → 0.86.0

package/dist/runner.js

@@ -0,0 +1,109 @@
+import { recordQueueConsumed as e, recordQueueDeadLettered as t, recordQueueRetry as n } from "./queueMetrics.js";
+import { runInQueueMessageSpan as r } from "./queueTracing.js";
+import { Result as i, Schema as a } from "effect";
+//#region src/runner.ts
+var o = (e) => new Promise((t) => setTimeout(t, e)), s = async (s) => {
+	let { provider: c, log: l } = s, u = { current: !1 }, d = /* @__PURE__ */ new Set(), f = async (u) => {
+		let d = u.groupId ?? `${s.appName}.${u.topic}`, f = u.dlqTopic ?? `${u.topic}.dlq`, p = u.maxAttempts ?? 3, m = a.decodeUnknownResult(u.schema), h = async (e, n, r) => {
+			t(u.topic, `${e}: ${n}`), l.warn("queue: dead-lettered", {
+				topic: u.topic,
+				dlqTopic: f,
+				reason: e,
+				partition: r.partition,
+				offset: r.offset
+			}), await c.produce(f, [{
+				...r.key === null ? {} : { key: r.key },
+				value: r.value ?? "",
+				headers: {
+					...r.headers,
+					"x-voltro-dlq-reason": e,
+					"x-voltro-dlq-detail": n.slice(0, 500),
+					"x-voltro-dlq-source-topic": r.topic,
+					"x-voltro-dlq-source-partition": String(r.partition),
+					"x-voltro-dlq-source-offset": r.offset
+				}
+			}]);
+		}, g = await c.consume({
+			topic: u.topic,
+			groupId: d,
+			...u.fromBeginning === void 0 ? {} : { fromBeginning: u.fromBeginning },
+			onMessage: async (t, a) => {
+				await r({
+					system: c.name,
+					topic: u.topic,
+					groupId: d,
+					partition: t.partition,
+					offset: t.offset,
+					traceparent: t.headers.traceparent
+				}, async () => {
+					let r;
+					try {
+						r = t.value === null ? null : JSON.parse(t.value);
+					} catch (e) {
+						return await h("decode-failed", `invalid JSON: ${e instanceof Error ? e.message : String(e)}`, t), "dead-lettered";
+					}
+					let c = m(r);
+					if (i.isFailure(c)) return await h("decode-failed", String(c.failure), t), "dead-lettered";
+					for (let r = 1; r <= p; r++) {
+						if (a.isStale()) return "stale";
+						try {
+							return await u.handler(c.success, {
+								topic: t.topic,
+								partition: t.partition,
+								offset: t.offset,
+								key: t.key,
+								headers: t.headers,
+								attempt: r,
+								...t.headers.traceparent === void 0 ? {} : { traceparent: t.headers.traceparent },
+								get store() {
+									let e = s.store();
+									if (e === null) throw Error("queue: store not bound yet — the retry loop absorbs a message arriving before boot finished");
+									return e;
+								}
+							}), e(u.topic), "ok";
+						} catch (e) {
+							let i = e instanceof Error ? e.message : String(e);
+							if (r >= p) return await h("handler-failed", i, t), "dead-lettered";
+							n(u.topic), l.warn("queue: handler failed, retrying", {
+								topic: u.topic,
+								attempt: r,
+								maxAttempts: p,
+								detail: i
+							}), await a.heartbeat().catch(() => {}), await o((s.retryBaseMs ?? 1e3) * 2 ** (r - 1));
+						}
+					}
+					return "stale";
+				}, (e) => ({ "voltro.queue.outcome": e }));
+			}
+		});
+		return l.info("queue: consumer started", {
+			topic: u.topic,
+			groupId: d,
+			dlqTopic: f
+		}), g;
+	}, p = s.consumers.map((e) => {
+		let t = { handle: null }, n = () => {
+			f(e).then((e) => {
+				u.current ? e.stop() : t.handle = e;
+			}).catch((t) => {
+				if (u.current) return;
+				l.warn("queue: consumer start failed — retrying in 5s", {
+					topic: e.topic,
+					detail: t instanceof Error ? t.message : String(t)
+				});
+				let r = setTimeout(() => {
+					d.delete(r), n();
+				}, 5e3);
+				d.add(r);
+			});
+		};
+		return n(), t;
+	});
+	return { stop: async () => {
+		u.current = !0;
+		for (let e of d) clearTimeout(e);
+		d.clear(), await Promise.all(p.map((e) => e.handle?.stop() ?? Promise.resolve()));
+	} };
+};
+//#endregion
+export { s as startQueueConsumers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-queue",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Queue interop — consume and produce against an existing Kafka: Schema-decoded consumers via defineQueueConsumer (*.consumer.ts; at-least-once, serial per partition, retry + dead-letter), batched producing via QueueService or transactionally through the outbox (queueOutboxHandler), and a kafkaSink for plugin-cdc-out.",
   "keywords": [
     "voltro",
@@ -33,13 +33,13 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.84.0",
-    "@voltro/protocol": "0.84.0",
-    "@voltro/runtime": "0.84.0",
+    "@voltro/database": "0.86.0",
+    "@voltro/protocol": "0.86.0",
+    "@voltro/runtime": "0.86.0",
     "kafkajs": "^2.2.4"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"