@voltro/plugin-broadcast 0.84.0 → 0.86.0

package/dist/providers.js

@@ -0,0 +1,166 @@
+import { BroadcastError as e } from "./types.js";
+import { Effect as t } from "effect";
+//#region src/providers.ts
+var n = (t, n, r) => new e({
+	provider: t,
+	message: n,
+	transient: !0,
+	...r === void 0 ? {} : { cause: r }
+}), r = (t, n, r) => new e({
+	provider: t,
+	message: n,
+	transient: !1,
+	...r === void 0 ? {} : { cause: r }
+}), i = () => {
+	let e = /* @__PURE__ */ new Set();
+	return {
+		subscribe: (t) => (e.add(t), () => {
+			e.delete(t);
+		}),
+		emit: (t) => {
+			for (let n of e) try {
+				n(t);
+			} catch {}
+		}
+	};
+}, a = /* @__PURE__ */ new Map(), o = (e) => {
+	let t = a.get(e);
+	return t || (t = { handlers: /* @__PURE__ */ new Map() }, a.set(e, t)), t;
+}, s = (e) => {
+	a.delete(e);
+}, c = (e = `default-${Math.random().toString(36).slice(2)}`) => {
+	let n = /* @__PURE__ */ new Set();
+	return {
+		name: "memory",
+		publish: (n, r) => t.sync(() => {
+			let t = a.get(e)?.handlers.get(n);
+			if (t) for (let e of t) try {
+				e(r);
+			} catch {}
+		}),
+		subscribe: (r, i) => t.sync(() => {
+			let t = o(e), s = t.handlers.get(r) ?? /* @__PURE__ */ new Set(), c = (e) => i(e);
+			s.add(c), t.handlers.set(r, s);
+			let l = () => {
+				n.delete(l), s.delete(c), s.size === 0 && t.handlers.get(r) === s && t.handlers.delete(r), t.handlers.size === 0 && a.get(e) === t && a.delete(e);
+			};
+			return n.add(l), l;
+		}),
+		close: () => t.sync(() => {
+			for (let e of n) e();
+		})
+	};
+}, l = (e) => {
+	let a = null, o = i(), s = !0, c = () => a || (a = (async () => {
+		let t;
+		if (e.client) t = e.client;
+		else {
+			let n;
+			try {
+				n = (await import("ioredis")).default;
+			} catch (e) {
+				throw r("redis", "the 'redis' broadcast provider requires the 'ioredis' optional dependency. Install it to enable it.", e);
+			}
+			t = new n(e.url);
+		}
+		let n = t.duplicate();
+		return t.on("error", () => {}), n.on("error", () => {}), n.on("reconnecting", () => {
+			s && (s = !1, o.emit({
+				kind: "disconnected",
+				detail: "ioredis is re-dialling"
+			}));
+		}), n.on("ready", () => {
+			s || (s = !0, o.emit({ kind: "reconnected" }));
+		}), {
+			pub: t,
+			sub: n
+		};
+	})().catch((e) => {
+		throw a = null, e;
+	}), a);
+	return {
+		name: "redis",
+		onTransportEvent: o.subscribe,
+		publish: (e, r) => t.tryPromise({
+			try: async () => {
+				let { pub: t } = await c();
+				await t.publish(e, r);
+			},
+			catch: (e) => n("redis", `publish failed: ${String(e?.message ?? e)}`, e)
+		}),
+		subscribe: (e, r) => t.tryPromise({
+			try: async () => {
+				let { sub: t } = await c(), n = (t, n) => {
+					t === e && r(n);
+				};
+				return t.on("message", n), await t.subscribe(e), () => {
+					t.off("message", n), t.unsubscribe(e).catch(() => void 0);
+				};
+			},
+			catch: (e) => n("redis", `subscribe failed: ${String(e?.message ?? e)}`, e)
+		}),
+		close: () => t.promise(async () => {
+			if (a) try {
+				let { pub: t, sub: n } = await a;
+				await n.quit(), e.client || await t.quit();
+			} catch {}
+		})
+	};
+}, u = new TextEncoder(), d = new TextDecoder(), f = (e) => {
+	let a = null, o = i(), s = !0, c = (e) => {
+		(async () => {
+			try {
+				for await (let t of e.status()) t.type === "disconnect" && s ? (s = !1, o.emit({
+					kind: "disconnected",
+					detail: "nats disconnected"
+				})) : t.type === "reconnect" && !s && (s = !0, o.emit({ kind: "reconnected" }));
+			} catch {}
+		})();
+	}, l = () => import("@nats-io/transport-node").catch((e) => {
+		throw r("nats", "the 'nats' broadcast provider requires the '@nats-io/transport-node' optional dependency. Install it to enable it.", e);
+	}), f = () => a || (a = (async () => {
+		if (e.connection) return e.connection;
+		let t = await (await l()).connect({
+			servers: e.url,
+			maxReconnectAttempts: -1,
+			waitOnFirstConnect: !0,
+			reconnectTimeWait: 2e3
+		});
+		return c(t), t;
+	})().catch((e) => {
+		throw a = null, e;
+	}), a);
+	return {
+		name: "nats",
+		onTransportEvent: o.subscribe,
+		publish: (e, r) => t.tryPromise({
+			try: async () => {
+				(await f()).publish(e, u.encode(r));
+			},
+			catch: (e) => n("nats", `publish failed: ${String(e?.message ?? e)}`, e)
+		}),
+		subscribe: (e, r) => t.tryPromise({
+			try: async () => {
+				let t = (await f()).subscribe(e), n = !1;
+				return (async () => {
+					for await (let e of t) r(d.decode(e.data));
+					!n && s && (s = !1, o.emit({
+						kind: "disconnected",
+						detail: `the nats subscription to '${e}' ended while the connection was up`
+					}));
+				})(), () => {
+					n = !0, t.unsubscribe();
+				};
+			},
+			catch: (e) => n("nats", `subscribe failed: ${String(e?.message ?? e)}`, e)
+		}),
+		close: () => t.promise(async () => {
+			if (a) try {
+				let t = await a;
+				e.connection || await t.drain();
+			} catch {}
+		})
+	};
+};
+//#endregion
+export { c as memoryProvider, f as natsProvider, l as redisProvider, s as resetMemoryBus };

package/dist/publishQueue.js

@@ -0,0 +1,64 @@
+import { Effect as e } from "effect";
+//#region src/publishQueue.ts
+var t = (t, n, r, i, a = {}, o = () => {}) => {
+	let s = a.maxMessages ?? 1024, c = a.maxBytes ?? 8388608, l = a.timeoutMs ?? 5e3, u = a.shutdownTimeoutMs ?? 1e3;
+	for (let [e, t] of Object.entries({
+		maxMessages: s,
+		maxBytes: c,
+		timeoutMs: l,
+		shutdownTimeoutMs: u
+	})) if (!Number.isSafeInteger(t) || t < 1) throw Error(`broadcast ${e} must be a positive safe integer`);
+	let d = [], f = 0, p = 0, m = !1, h = 0, g = !1, _ = !1, v, y, b = !1, x, S = /* @__PURE__ */ new Set(), C = () => {
+		for (let e of S) e();
+		S.clear();
+	}, w = (e) => {
+		m || i(e), m = !0;
+	}, T = () => {
+		if (g || b || v !== void 0) return;
+		let i = d[f];
+		if (!i && !m) {
+			C();
+			return;
+		}
+		let a = h, s = i?.payload ?? r(a);
+		i && (d[f] = void 0, f++, f * 2 >= d.length && (d = d.slice(f), f = 0)), x = new AbortController(), b = !0;
+		let c = setTimeout(() => {
+			w("publish timed out; peers need a resync");
+		}, l);
+		y = e.runPromise(t.publish(n, s), { signal: x.signal }).then(() => {
+			g || o(), !i && h === a && (m = !1);
+		}, () => {
+			g || (w("publish failed — cross-replica fan-out degraded, local reactivity unaffected; peers need a resync"), v = setTimeout(() => {
+				v = void 0, T();
+			}, 500));
+		}).finally(() => {
+			clearTimeout(c), i && (p -= i.bytes), y = void 0, b = !1, x = void 0, g ? C() : T();
+		});
+	};
+	return {
+		enqueue: (e, t) => {
+			if (_ || g) return;
+			if (h = t, m || d.length - f + +!!b >= s) {
+				w("publish queue full; peers need a resync"), T();
+				return;
+			}
+			let n = e(), r = Buffer.byteLength(n, "utf8");
+			p + r > c ? (w("publish byte budget exceeded; peers need a resync"), T()) : (p += r, d.push({
+				payload: n,
+				bytes: r
+			}), T());
+		},
+		close: async () => {
+			_ = !0, v !== void 0 && (clearTimeout(v), v = void 0), T();
+			let e;
+			(y || d.length > f || m) && await new Promise((t) => {
+				let n = () => {
+					S.delete(n), t();
+				};
+				S.add(n), e = setTimeout(n, u);
+			}), e !== void 0 && clearTimeout(e), g = !0, (y || d.length > f || m) && i("shutdown deadline reached; unsent changes require peer resync"), d = [], f = 0, v !== void 0 && clearTimeout(v), x?.abort(), y && await Promise.race([y, new Promise((e) => setImmediate(e))]), p = 0, C();
+		}
+	};
+};
+//#endregion
+export { t as createPublishQueue };

package/dist/resolve.js

@@ -0,0 +1,53 @@
+import { memoryProvider as e, natsProvider as t, redisProvider as n } from "./providers.js";
+//#region src/resolve.ts
+var r = (e, t) => t[`${e.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_REDIS_URL`], i = (i, a) => {
+	if (i.provider && typeof i.provider == "object") {
+		let e = i.provider;
+		return {
+			provider: e,
+			url: i.url ?? null,
+			crossReplica: e.name !== "memory"
+		};
+	}
+	let o = i.url ?? a.BROADCAST_URL ?? null, s = r(i.connection ?? "broadcast", a), c = (i.provider ?? a.BROADCAST_PROVIDER)?.toLowerCase() ?? (o?.startsWith("nats://") ? "nats" : o?.startsWith("redis://") || o?.startsWith("rediss://") || s || a.REDIS_URL ? "redis" : void 0), l = (i.provider ?? a.BROADCAST_PROVIDER)?.toLowerCase();
+	if (l !== void 0 && l !== "redis" && l !== "nats" && l !== "memory") throw Error(`broadcastPlugin: unknown provider "${l}".\n  Valid: 'redis', 'nats', 'memory'.
+  A name we do not recognise used to fall through to the in-process bus, which boots fine on one replica and drops cross-replica traffic on the second.`);
+	if (o !== null && o !== "" && !/^(redis|rediss|nats):\/\//.test(o)) throw Error(`broadcastPlugin: url "${o}" names no provider we support.\n  Expected a redis://, rediss:// or nats:// url.`);
+	switch (c) {
+		case "redis": {
+			let t = o ?? s ?? a.REDIS_URL;
+			if (!t) {
+				if (l === "redis") throw Error("broadcastPlugin: provider \"redis\" was requested but no url resolves.\n  Set BROADCAST_URL, BROADCAST_REDIS_URL or REDIS_URL, or pass `url`.\n  Falling back to the in-process bus here would answer a stated requirement with a silent downgrade.");
+				return {
+					provider: e(),
+					url: null,
+					crossReplica: !1
+				};
+			}
+			return {
+				provider: n({ url: t }),
+				url: t,
+				crossReplica: !0
+			};
+		}
+		case "nats": {
+			let n = o ?? a.NATS_URL;
+			return n ? {
+				provider: t({ url: n }),
+				url: n,
+				crossReplica: !0
+			} : {
+				provider: e(),
+				url: null,
+				crossReplica: !1
+			};
+		}
+		default: return {
+			provider: e(),
+			url: null,
+			crossReplica: !1
+		};
+	}
+};
+//#endregion
+export { i as resolveBroadcastProvider };

package/dist/types.js

@@ -0,0 +1,11 @@
+import { DEFAULT_BROADCAST_NAMESPACE as e, channelFor as t } from "./namespace.js";
+import { Schema as n } from "effect";
+//#region src/types.ts
+var r = class extends n.TaggedError()("BroadcastError", {
+	provider: n.String,
+	message: n.String,
+	transient: n.Boolean,
+	cause: n.optional(n.Unknown)
+}) {}, i = t(e, "changes");
+//#endregion
+export { i as BROADCAST_CHANNEL, r as BroadcastError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-broadcast",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Cross-replica reactivity — a pub/sub message bus (Redis / NATS / memory) that fans out app-mutation ChangeEvents to every replica behind a load balancer. ADDITIVE to inline emit: local reactivity survives a broker outage; cross-replica degrades gracefully. Closes the single-instance gap for every non-postgres dialect (postgres keeps native LISTEN/NOTIFY).",
   "keywords": [
     "voltro",
@@ -33,15 +33,15 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.84.0",
-    "@voltro/protocol": "0.84.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/protocol": "0.86.0"
   },
   "optionalDependencies": {
     "@nats-io/transport-node": "^3.4.0",
     "ioredis": "^5.11.1"
   },
   "peerDependencies": {
-    "effect": "^3.22.2"
+    "effect": "4.0.1"
   },
   "publishConfig": {
     "access": "public"