@voltro/kv 0.85.0 → 0.87.0

package/dist/connectionNats.js

@@ -0,0 +1,148 @@
+import { KvError as e } from "./errors.js";
+import { assertNatsSubject as t } from "./connectionNatsSubjects.js";
+import { Effect as n } from "effect";
+//#region src/connectionNats.ts
+var r = new TextEncoder(), i = new TextDecoder(), a = 5e3, o = 1e3, s = async (e, t) => {
+	let n;
+	try {
+		return await Promise.race([e, new Promise((e, r) => {
+			n = setTimeout(() => {
+				r(/* @__PURE__ */ Error("NATS transport deadline elapsed"));
+			}, t);
+		})]);
+	} finally {
+		n !== void 0 && clearTimeout(n);
+	}
+}, c = (e) => {
+	let n = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map(), d = !0, f = !1, p, m = (e) => {
+		for (let t of c) try {
+			t(e);
+		} catch {}
+	}, h = () => {
+		!f && d && (d = !1, m({ kind: "disconnected" }));
+	}, g = e.status()[Symbol.asyncIterator](), _ = (async () => {
+		try {
+			for (;;) {
+				let e = await g.next();
+				if (e.done) break;
+				f || (e.value.type === "disconnect" ? h() : e.value.type === "reconnect" && !d && (d = !0, m({ kind: "reconnected" })));
+			}
+		} finally {
+			h();
+		}
+	})().catch(() => {
+		h();
+	}), v = () => {
+		if (f) throw Error("NATS transport is closed");
+		if (!d) throw Error("NATS transport is disconnected");
+	}, y = async (e) => {
+		let t = u.get(e);
+		t !== void 0 && (t.released = !0, u.delete(e), t.subscription.unsubscribe(), await t.done);
+	};
+	return {
+		publish: async (n, i) => {
+			t(n), v(), e.publish(n, r.encode(i));
+		},
+		flush: async () => {
+			v(), await s(e.flush(), a);
+		},
+		subscribe: async (r) => {
+			t(r), v();
+			let o = u.get(r);
+			if (o !== void 0) return o.ready;
+			let c = e.subscribe(r), d = {
+				subscription: c,
+				released: !1,
+				done: Promise.resolve(),
+				ready: Promise.resolve()
+			};
+			u.set(r, d), d.done = (async () => {
+				try {
+					for await (let e of c) {
+						if (f || d.released) continue;
+						let t = i.decode(e.data);
+						for (let e of n) try {
+							e(r, t);
+						} catch {}
+					}
+				} finally {
+					d.released || h();
+				}
+			})().catch(() => {
+				d.released || h();
+			}), l.add(d.done), d.done.then(() => {
+				l.delete(d.done);
+			}), d.ready = s(e.flush(), a).then(() => {
+				if (v(), d.released) throw Error("NATS subscription is closed");
+			}).catch(async (e) => {
+				throw u.get(r) === d && await y(r), e;
+			}), await d.ready;
+		},
+		unsubscribe: y,
+		onMessage: (e) => {
+			if (f) throw Error("NATS transport is closed");
+			return n.add(e), () => {
+				n.delete(e);
+			};
+		},
+		onTransportEvent: (e) => {
+			if (f) throw Error("NATS transport is closed");
+			return c.add(e), () => {
+				c.delete(e);
+			};
+		},
+		close: () => p ??= (async () => {
+			f = !0, n.clear(), c.clear();
+			for (let e of u.values()) {
+				e.released = !0;
+				try {
+					e.subscription.unsubscribe();
+				} catch {}
+			}
+			u.clear();
+			try {
+				await s(e.drain(), o);
+			} catch {} finally {
+				await e.close(), await g.return?.(), await Promise.all([...l]), await _;
+			}
+		})()
+	};
+}, l = (t) => n.callback((r) => {
+	let i = !1, o, s = (async () => {
+		let e = await (await import("@nats-io/transport-node")).connect({
+			servers: t.url.split(",").map((e) => e.trim()),
+			maxReconnectAttempts: -1,
+			waitOnFirstConnect: !0,
+			reconnectTimeWait: 2e3,
+			timeout: a,
+			...t.tls === "required" ? { tls: {} } : {},
+			...t.token === void 0 ? {} : { token: t.token },
+			...t.user === void 0 ? {} : { user: t.user },
+			...t.pass === void 0 ? {} : { pass: t.pass },
+			reconnectToServer: () => {
+				if (i) throw Error("NATS acquisition cancelled");
+				return null;
+			}
+		});
+		if (i) await e.close();
+		else {
+			try {
+				o = c(e);
+			} catch (t) {
+				throw await e.close(), t;
+			}
+			r(n.succeed(o));
+		}
+	})().catch(() => {
+		i || r(n.fail(new e({
+			operation: "connect",
+			key: "",
+			cause: "NATS driver could not be opened"
+		})));
+	});
+	return n.promise(async () => {
+		i = !0, await s, await o?.close();
+	});
+});
+//#endregion
+export { l as connectNats };

package/dist/connectionNatsConfig.js

@@ -0,0 +1,87 @@
+import { connectionDefinitionsProblem as e, natsConnectionName as t } from "./connectionDefinitions.js";
+import { Config as n, ConfigProvider as r, Effect as i, Option as a } from "effect";
+//#region src/connectionNatsConfig.ts
+var o = (e) => e.toUpperCase().replace(/[^A-Z0-9]+/g, "_"), s = (e) => {
+	if (typeof e.url != "string" || !e.url.trim()) return "A NATS connection requires an endpoint";
+	for (let t of e.url.split(",")) try {
+		let e = new URL(t.trim());
+		if (!["nats:", "tls:"].includes(e.protocol) || !e.hostname || e.pathname && e.pathname !== "/" || e.search || e.hash) return "A NATS connection requires nats:// or tls:// servers";
+		if (e.username || e.password) return "NATS credentials must use token or user/pass declarations, not endpoint userinfo";
+	} catch {
+		return "A NATS connection requires valid servers";
+	}
+	for (let t of [
+		e.token,
+		e.user,
+		e.pass
+	]) if (t !== void 0 && (typeof t != "string" || !t.trim())) return "NATS credentials must be nonempty";
+	if (e.user === void 0 != (e.pass === void 0)) return "NATS user and pass must resolve together";
+	if (e.token !== void 0 && e.user !== void 0) return "NATS token and user/pass authentication are exclusive";
+	if (e.tls !== void 0 && !["auto", "required"].includes(e.tls)) return "Connection tls must be auto or required";
+	if (e.keyPrefix !== void 0 && typeof e.keyPrefix != "string") return "Connection keyPrefix must be a string";
+	if (e.keyPrefix !== void 0 && (/[\s*>]/u.test(e.keyPrefix) || e.keyPrefix.startsWith(".") || e.keyPrefix.includes(".."))) return "A NATS namespace must preserve exact subjects";
+	if (e.allowSharedNamespace !== void 0 && typeof e.allowSharedNamespace != "boolean") return "Connection allowSharedNamespace must be a boolean";
+}, c = (c, l = {}, u) => {
+	let d = u === void 0 ? void 0 : Object.freeze({ tenantId: u.tenantId });
+	return i.gen(function* () {
+		let u = e(l);
+		if (u) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: u })));
+		if (c.includes(":") && !/^nats:[A-Za-z][A-Za-z0-9_-]*$/.test(c)) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: "A NATS consumer requires a nats:name connection reference" })));
+		if (c && !c.includes(":") && !/^[A-Za-z][A-Za-z0-9_-]*$/.test(c)) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: "Malformed NATS connection reference" })));
+		let f = t(c, l), p = l.nats ?? {}, m = Object.keys(p), h = Object.hasOwn(p, f) ? p[f] : void 0;
+		if (h === void 0 && m.length > 0) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: `Unknown NATS connection ${f || "(default)"}. Known names: ${m.sort().join(", ")}` })));
+		let g = `CONNECTIONS_NATS_${o(f)}`, _ = yield* n.String(`${g}_URL`).pipe(n.option), v = yield* n.String(`${g}_TOKEN`).pipe(n.option), y = yield* n.String(`${g}_USER`).pipe(n.option), b = yield* n.String(`${g}_PASS`).pipe(n.option), x = yield* n.String(`${g}_KEY_PREFIX`).pipe(n.option), S = {
+			...a.isSome(_) ? { url: _.value } : {},
+			...a.isSome(v) ? { token: v.value } : {},
+			...a.isSome(y) ? { user: y.value } : {},
+			...a.isSome(b) ? { pass: b.value } : {},
+			...a.isSome(x) ? { keyPrefix: x.value } : {}
+		}, C;
+		if (h !== void 0 && "_tag" in h) {
+			if (!d?.tenantId) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: "A dynamic NATS connection requires tenantId" })));
+			C = {
+				...yield* h.resolve(d),
+				...S
+			};
+		} else if (h !== void 0) {
+			let { url: e, token: t, user: o, pass: s, ...c } = h, l = (e) => e === void 0 ? i.succeed(a.none()) : n.String(e.name).pipe(n.option), u = a.isSome(v) ? v : yield* l(t), d = a.isSome(y) ? y : yield* l(o), f = a.isSome(b) ? b : yield* l(s);
+			for (let [e, c] of [
+				[t, u],
+				[o, d],
+				[s, f]
+			]) if (e !== void 0 && a.isNone(c)) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: `Missing declared NATS credential ${e.name}` })));
+			C = {
+				...c,
+				url: a.isSome(_) ? _.value : yield* n.String(e.name),
+				...a.isSome(u) ? { token: u.value } : {},
+				...a.isSome(d) ? { user: d.value } : {},
+				...a.isSome(f) ? { pass: f.value } : {},
+				...a.isSome(x) ? { keyPrefix: x.value } : {}
+			};
+		} else {
+			let e = o(f), t = (t) => n.String(`${e}_NATS_${t}`).pipe(n.orElse(() => n.String(`NATS_${t}`)), n.option), r = a.isSome(v) ? v : yield* t("TOKEN"), i = a.isSome(y) ? y : yield* t("USER"), s = a.isSome(b) ? b : yield* t("PASS");
+			C = {
+				url: a.isSome(_) ? _.value : yield* n.String(`${e}_NATS_URL`).pipe(n.orElse(() => n.String("NATS_URL"))),
+				...a.isSome(r) ? { token: r.value } : {},
+				...a.isSome(i) ? { user: i.value } : {},
+				...a.isSome(s) ? { pass: s.value } : {},
+				...a.isSome(x) ? { keyPrefix: x.value } : {}
+			};
+		}
+		let w = s(C);
+		if (w) return yield* i.fail(new n.ConfigError(new r.SourceError({ message: w })));
+		let T = [
+			_,
+			v,
+			y,
+			b,
+			x
+		].some(a.isSome);
+		return {
+			...C,
+			source: T ? "override" : h === void 0 ? "environment" : "config"
+		};
+	});
+};
+//#endregion
+export { s as natsConfigProblem, c as natsConnectionConfig };

package/dist/connectionNatsSubjects.js

@@ -0,0 +1,16 @@
+//#region src/connectionNatsSubjects.ts
+var e = (e) => {
+	if (!e || /[\s*>]/u.test(e) || e.split(".").some((e) => !e)) throw Error("Registry NATS channels must be exact nonempty subjects");
+}, t = (e, t = "") => ({
+	publish: (n, r) => e.publish(t + n, r),
+	subscribe: (n) => e.subscribe(t + n),
+	unsubscribe: (n) => e.unsubscribe(t + n),
+	onMessage: (n) => e.onMessage((e, r) => {
+		e.startsWith(t) && n(e.slice(t.length), r);
+	}),
+	onTransportEvent: e.onTransportEvent,
+	flush: e.flush,
+	close: e.close
+});
+//#endregion
+export { e as assertNatsSubject, t as withNatsSubjectPrefix };

package/dist/connectionOwner.js

@@ -0,0 +1,44 @@
+import { KvError as e } from "./errors.js";
+import { Deferred as t, Effect as n, Scope as r } from "effect";
+//#region src/connectionOwner.ts
+var i = (i) => n.gen(function* () {
+	let a = yield* n.scope, o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), c = !1, l = (e) => n.uninterruptible(n.suspend(() => e.closed ? t.await(e.closedSignal) : (e.closed = !0, i.dispose(e).pipe(n.ensuring(n.sync(() => {
+		o.delete(e);
+	}).pipe(n.andThen(t.succeed(e.closedSignal, void 0))))))));
+	return yield* r.addFinalizer(a, n.gen(function* () {
+		c = !0, i.onStopping(), yield* n.forEach([...s], t.await, {
+			concurrency: "unbounded",
+			discard: !0
+		}), yield* n.forEach([...o], (e) => n.gen(function* () {
+			e.retired = !0, e.active > 0 && !e.closed && (yield* (e.drainUntilReleased ? t.await(e.closedSignal) : n.raceFirst(n.sleep(i.rotationGraceMs), t.await(e.closedSignal))).pipe(n.interruptible)), yield* l(e);
+		}), {
+			concurrency: "unbounded",
+			discard: !0
+		}), i.onStopped();
+	})), {
+		get stopped() {
+			return c;
+		},
+		register: (e) => {
+			o.add(e);
+		},
+		close: l,
+		retire: (e) => n.gen(function* () {
+			e.retired = !0, e.active === 0 ? yield* l(e) : e.drainUntilReleased || (yield* n.raceFirst(n.sleep(i.rotationGraceMs), t.await(e.closedSignal)).pipe(n.andThen(l(e)), n.interruptible, n.forkIn(a)));
+		}),
+		release: (e) => n.suspend(() => (e.active--, e.retired && e.active === 0 ? l(e) : n.void)),
+		trackOpen: (r) => n.uninterruptibleMask((i) => n.gen(function* () {
+			if (c) return yield* n.fail(new e({
+				operation: "connect",
+				key: "",
+				cause: "Connection registry is closed"
+			}));
+			let a = yield* t.make();
+			return s.add(a), yield* i(r).pipe(n.ensuring(n.sync(() => {
+				s.delete(a);
+			}).pipe(n.andThen(t.succeed(a, void 0)))));
+		}))
+	};
+});
+//#endregion
+export { i as makeConnectionOwner };