@voltro/sql-postgres 0.1.0

package/dist/index.js

@@ -0,0 +1,530 @@
+import { PgClient as e, PgClient as t } from "@effect/sql-pg";
+import { Cause as n, Config as r, Effect as i, Exit as a, Fiber as o, Layer as s, ManagedRuntime as c, Option as l, Redacted as u, Schedule as d, Stream as f } from "effect";
+import p from "pg";
+import { EventEmitter as m } from "node:events";
+import { createLogger as h } from "@voltro/logger";
+import { SqlClient as g, TransactionConnection as _ } from "@effect/sql/SqlClient";
+import { attachEagerLoads as v, compileEagerJson as y, compilePredicate as b, compileRawFragment as x, compileSelect as S, encodeRowForSchema as C, hasEagerLoads as w, requireTable as T } from "@voltro/database";
+//#region src/sqlLayer.ts
+var E = (e) => e ? { rejectUnauthorized: !1 } : !1, D = /^[A-Za-z_][A-Za-z0-9_]*$/, O = (t) => {
+	if (t.schema === void 0) return e.layerConfig({
+		host: r.succeed(t.host),
+		port: r.succeed(t.port),
+		username: r.succeed(t.username),
+		password: r.succeed(u.make(t.password)),
+		database: r.succeed(t.database),
+		...t.maxConnections === void 0 ? {} : { maxConnections: r.succeed(t.maxConnections) },
+		...t.ssl === void 0 ? {} : { ssl: r.succeed(E(t.ssl)) }
+	});
+	if (!D.test(t.schema)) throw Error(`DB_SCHEMA '${t.schema}' is not a valid postgres identifier (expected ${D}).`);
+	let n = t.schema, a = i.acquireRelease(i.sync(() => new p.Pool({
+		host: t.host,
+		port: t.port,
+		user: t.username,
+		password: t.password,
+		database: t.database,
+		...t.maxConnections === void 0 ? {} : { max: t.maxConnections },
+		...t.ssl === void 0 ? {} : { ssl: E(t.ssl) },
+		options: `-c search_path="${n}"`
+	})), (e) => i.promise(() => e.end()));
+	return e.layerFromPool({ acquire: a });
+}, k = (e) => {
+	let t = e.get("sslmode");
+	if (t !== null) {
+		if (t === "require") return !0;
+		if (t === "disable") return !1;
+		throw Error(`DB_URL '?sslmode=${t}' is not supported by the postgres dialect — use 'require' (TLS without certificate verification) or 'disable' (plaintext).`);
+	}
+	let n = e.get("ssl");
+	if (n !== null) {
+		if (n === "true" || n === "1") return !0;
+		if (n === "false" || n === "0") return !1;
+		throw Error(`DB_URL '?ssl=${n}' is not supported by the postgres dialect — use 'true'/'1' or 'false'/'0'.`);
+	}
+}, A = (e) => {
+	let t = e.schema === void 0 ? {} : { schema: e.schema };
+	if (e.url) {
+		let n = new URL(e.url), r = e.ssl ?? k(n.searchParams);
+		return {
+			host: n.hostname || "localhost",
+			port: n.port ? Number(n.port) : 5432,
+			username: decodeURIComponent(n.username || "app"),
+			password: decodeURIComponent(n.password || "app"),
+			database: n.pathname.replace(/^\//, "") || "app",
+			...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections },
+			...r === void 0 ? {} : { ssl: r },
+			...t
+		};
+	}
+	return {
+		host: e.host ?? "localhost",
+		port: e.port ?? 5432,
+		username: e.username ?? "app",
+		password: e.password ?? "app",
+		database: e.database ?? "app",
+		...e.maxConnections === void 0 ? {} : { maxConnections: e.maxConnections },
+		...e.ssl === void 0 ? {} : { ssl: e.ssl },
+		...t
+	};
+}, j = (e) => O(A(e)), M = /* @__PURE__ */ new Set(["40001", "40P01"]), N = (e) => {
+	let t = e;
+	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
+		let e = t.code;
+		if (typeof e == "string") return e;
+		t = t.cause;
+	}
+}, P = (e) => {
+	let t = N(e);
+	return t !== void 0 && M.has(t);
+}, F = (e) => P(e) ? "retry" : "noRetry", I = ["json"], L = h({ scope: "voltro:postgres" }), R = async (e) => {
+	let t = e.tracerLayer ? s.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, n = c.make(t), r = await n.runPromise(g), i = e.changeStrategy ?? "inline", a = new z(r, n, i, e.cdcChannel ?? "framework_changes");
+	return i === "cdc" && await a.startCdcConsumer(), a;
+}, z = class {
+	sql;
+	runtime;
+	changeStrategy;
+	cdcChannel;
+	emitter = new m();
+	cdcFiber = null;
+	inflightTxns = 0;
+	constructor(e, t, n, r) {
+		this.sql = e, this.runtime = t, this.changeStrategy = n, this.cdcChannel = r;
+	}
+	withNamespace(e) {
+		return e === null ? this : new V(this, e);
+	}
+	async runInNamespace(e, t) {
+		this.inflightTxns++;
+		let n = this.sql, r = this.sql.withTransaction(i.flatMap(i.serviceOption(_), (r) => {
+			if (l.isNone(r)) return i.fail(/* @__PURE__ */ Error("PostgresDataStore.runInNamespace: TransactionConnection missing."));
+			let a = r.value, o = i.provideService(n`SET LOCAL search_path TO ${n(e)}`, _, a), s = new B(this, a);
+			return i.flatMap(o, () => i.tryPromise({
+				try: () => t(s).then((e) => ({
+					result: e,
+					view: s
+				})),
+				catch: (e) => e
+			}));
+		})).pipe(i.withSpan("store.namespace", { attributes: {
+			"db.system": "postgresql",
+			"db.operation": "namespace.transaction"
+		} }));
+		try {
+			let e = await this.runtime.runPromise(r);
+			return e.view.commitEvents(), e.result;
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	__postgresReplicationFriend = { runEffect: (e) => this.runtime.runPromise(e) };
+	async executeQuery(e, t) {
+		let n = S(e, this.sql), r = t ? i.provideService(n, _, t) : n;
+		return this.runtime.runPromise(r);
+	}
+	async executeInsert(e, t, n, r) {
+		let a = this.sql, o = a`INSERT INTO ${a(e)} ${a.insert(C(t, e, I))} RETURNING *`, s = n ? i.provideService(o, _, n) : o, c = (await this.runtime.runPromise(s))[0];
+		if (!c) throw Error(`PostgresDataStore.insert: no row returned for table '${e}'`);
+		return this.changeStrategy === "inline" && this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: c
+		}, r), c;
+	}
+	async executeUpdate(e, t, n, r, a) {
+		let o = this.sql, s = o`UPDATE ${o(e)} SET ${o.update(C(n, e, I))} WHERE ${o("id")} = ${t} RETURNING *`, c = r ? i.provideService(s, _, r) : s, l = (await this.runtime.runPromise(c))[0];
+		return l ? (this.changeStrategy === "inline" && this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: l
+		}, a), l) : null;
+	}
+	async executeUpsert(e, t, n, r, a) {
+		let o = this.sql;
+		if (typeof n.update == "function") {
+			let s = n.update, c = n.conflictColumns.map((e) => o`${o(e)} = ${t[e]}`), u = (n) => {
+				let r = o`SELECT * FROM ${o(e)} WHERE ${o.and(c)} LIMIT 1 FOR UPDATE`;
+				return this.runtime.runPromise(i.flatMap(i.provideService(r, _, n), (r) => i.promise(() => r[0] ? this.executeUpdate(e, r[0].id, s(r[0]), n, a).then((e) => e) : this.executeInsert(e, t, n, a))));
+			};
+			if (r) return u(r);
+			this.inflightTxns++;
+			try {
+				let e = i.suspend(() => this.sql.withTransaction(i.flatMap(i.serviceOption(_), (e) => l.isNone(e) ? i.fail(/* @__PURE__ */ Error("PostgresDataStore.upsert: TransactionConnection missing.")) : i.promise(() => u(e.value))))), t = d.exponential("10 millis").pipe(d.compose(d.recurs(3)), d.whileInput(P));
+				return await this.runtime.runPromise(e.pipe(i.retry(t)));
+			} finally {
+				this.inflightTxns--;
+			}
+		}
+		let s = n.conflictColumns.map((e) => o`${o(e)}`), c = Object.keys(t).filter((e) => t[e] !== void 0), u = n.update === void 0 ? c.filter((e) => e !== "id" && !n.conflictColumns.includes(e)) : n.update, f = u.length > 0 ? o.csv(u.map((e) => o`${o(e)} = EXCLUDED.${o(e)}`)) : o`${o(n.conflictColumns[0])} = EXCLUDED.${o(n.conflictColumns[0])}`, p = o`INSERT INTO ${o(e)} ${o.insert(C(t, e, I))} ON CONFLICT (${o.csv(s)}) DO UPDATE SET ${f} RETURNING *`, m = r ? i.provideService(p, _, r) : p, h = (await this.runtime.runPromise(m))[0];
+		if (!h) throw Error(`PostgresDataStore.upsert: no row returned for table '${e}'`);
+		if (this.changeStrategy === "inline") {
+			let n = t.id !== void 0 && t.id === h.id ? "insert" : "update";
+			this.routeEvent({
+				table: e,
+				op: n,
+				old: null,
+				new: h
+			}, a);
+		}
+		return h;
+	}
+	async executeInsertIgnore(e, t, n, r, a) {
+		let o = this.sql, s = n.conflictColumns.map((e) => o`${o(e)}`), c = o`INSERT INTO ${o(e)} ${o.insert(C(t, e, I))} ON CONFLICT (${o.csv(s)}) DO NOTHING RETURNING *`, l = r ? i.provideService(c, _, r) : c, u = (await this.runtime.runPromise(l))[0];
+		if (u) return this.changeStrategy === "inline" && this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: u
+		}, a), u;
+		let d = n.conflictColumns.map((e) => o`${o(e)} = ${t[e]}`), f = o`SELECT * FROM ${o(e)} WHERE ${o.and(d)} LIMIT 1`, p = r ? i.provideService(f, _, r) : f, m = await this.runtime.runPromise(p);
+		if (!m[0]) throw Error("PostgresDataStore.insertIgnore: row conflicted but lookup found nothing");
+		return m[0];
+	}
+	async executeInsertMany(e, t, n, r) {
+		if (t.length === 0) return [];
+		let a = this.sql, o = a`INSERT INTO ${a(e)} ${a.insert(t.map((t) => C(t, e, I)))} RETURNING *`, s = n ? i.provideService(o, _, n) : o, c = await this.runtime.runPromise(s);
+		if (this.changeStrategy === "inline") for (let t of c) this.routeEvent({
+			table: e,
+			op: "insert",
+			old: null,
+			new: t
+		}, r);
+		return c;
+	}
+	async executePatchJson(e, t, n, r, a, o) {
+		let s = this.sql, c = n.split("."), l = c[0], u = c.slice(1), d = JSON.stringify(r ?? null), f = u.length === 0 ? s`${s(l)} = COALESCE(${s(l)}, '{}'::jsonb) || ${d}::jsonb` : s`${s(l)} = jsonb_set(COALESCE(${s(l)}, '{}'::jsonb), ${`{${u.join(",")}}`}, ${d}::jsonb, true)`, p = s`UPDATE ${s(e)} SET ${f} WHERE ${s("id")} = ${t} RETURNING *`, m = a ? i.provideService(p, _, a) : p, h = (await this.runtime.runPromise(m))[0];
+		return h ? (this.changeStrategy === "inline" && this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: h
+		}, o), h) : null;
+	}
+	async executeDelete(e, t, n, r) {
+		let a = this.sql, o = a`DELETE FROM ${a(e)} WHERE ${a("id")} = ${t} RETURNING *`, s = n ? i.provideService(o, _, n) : o, c = (await this.runtime.runPromise(s))[0];
+		return c ? (this.changeStrategy === "inline" && this.routeEvent({
+			table: e,
+			op: "delete",
+			old: c,
+			new: null
+		}, r), !0) : !1;
+	}
+	routeEvent(e, t) {
+		t === null ? this.emitter.emit("change", e) : t.push(e);
+	}
+	query(e) {
+		return this.runWithEager(e, null);
+	}
+	raw(e, t) {
+		let n = x(e, this.sql);
+		return this.runtime.runPromise(n);
+	}
+	async runWithEager(e, t) {
+		if (!w(e)) return this.executeQuery(e, t);
+		let n = y(e, this.sql, "postgres");
+		if (n !== null) try {
+			let e = t ? i.provideService(n.fragment, _, t) : n.fragment, r = await this.runtime.runPromise(e);
+			return n.decode(r);
+		} catch (e) {
+			L.warn("postgres JSON-agg eager-load failed; falling back to walker", { err: e });
+		}
+		return v(await this.executeQuery(e, t), e.eager, e.sourceTable ?? T(e.table), (e) => this.executeQuery(e, t));
+	}
+	getInternalRunWithEager() {
+		return (e, t) => this.runWithEager(e, t);
+	}
+	insert(e, t) {
+		return this.executeInsert(e, t, null, null);
+	}
+	insertMany(e, t) {
+		return this.executeInsertMany(e, t, null, null);
+	}
+	patchJson(e, t, n, r) {
+		return this.executePatchJson(e, t, n, r, null, null);
+	}
+	update(e, t, n) {
+		return this.executeUpdate(e, t, n, null, null);
+	}
+	delete(e, t) {
+		return this.executeDelete(e, t, null, null);
+	}
+	async updateMany(e, t, n) {
+		return this.executeUpdateMany(e, t, n, null, null);
+	}
+	async deleteMany(e, t) {
+		return this.executeDeleteMany(e, t, null, null);
+	}
+	async executeUpdateMany(e, t, n, r, a) {
+		let o = this.sql, s = b(n.where, o), c = o`UPDATE ${o(e)} SET ${o.update(C(t, e, I))} WHERE ${s} RETURNING *`, l = r ? i.provideService(c, _, r) : c, u = await this.runtime.runPromise(l);
+		if (this.changeStrategy === "inline") for (let t of u) this.routeEvent({
+			table: e,
+			op: "update",
+			old: null,
+			new: t
+		}, a);
+		return u.length;
+	}
+	async executeDeleteMany(e, t, n, r) {
+		let a = this.sql, o = b(t.where, a), s = a`DELETE FROM ${a(e)} WHERE ${o} RETURNING *`, c = n ? i.provideService(s, _, n) : s, l = await this.runtime.runPromise(c);
+		if (this.changeStrategy === "inline") for (let t of l) this.routeEvent({
+			table: e,
+			op: "delete",
+			old: t,
+			new: null
+		}, r);
+		return l.length;
+	}
+	upsert(e, t, n) {
+		return this.executeUpsert(e, t, n, null, null);
+	}
+	insertIgnore(e, t, n) {
+		return this.executeInsertIgnore(e, t, n, null, null);
+	}
+	emitChange(e) {
+		this.emitter.emit("change", e);
+	}
+	getInternalExecuteQuery() {
+		return this.executeQuery.bind(this);
+	}
+	getInternalExecuteInsert() {
+		return this.executeInsert.bind(this);
+	}
+	getInternalExecuteInsertMany() {
+		return this.executeInsertMany.bind(this);
+	}
+	getInternalExecutePatchJson() {
+		return this.executePatchJson.bind(this);
+	}
+	getInternalExecuteUpdate() {
+		return this.executeUpdate.bind(this);
+	}
+	getInternalExecuteDelete() {
+		return this.executeDelete.bind(this);
+	}
+	getInternalExecuteUpdateMany() {
+		return this.executeUpdateMany.bind(this);
+	}
+	getInternalExecuteDeleteMany() {
+		return this.executeDeleteMany.bind(this);
+	}
+	getInternalExecuteUpsert() {
+		return this.executeUpsert.bind(this);
+	}
+	getInternalExecuteInsertIgnore() {
+		return this.executeInsertIgnore.bind(this);
+	}
+	async transactional(e) {
+		this.inflightTxns++;
+		let t = 0, r = i.suspend(() => {
+			let n = ++t;
+			return this.sql.withTransaction(i.flatMap(i.serviceOption(_), (t) => {
+				if (l.isNone(t)) return i.fail(/* @__PURE__ */ Error("PostgresDataStore.transactional: TransactionConnection unexpectedly missing inside withTransaction."));
+				let r = new B(this, t.value);
+				return i.tryPromise({
+					try: () => e(r).then((e) => ({
+						result: e,
+						view: r,
+						attempt: n
+					})),
+					catch: (e) => e
+				});
+			}));
+		}), o = d.exponential("10 millis").pipe(d.compose(d.recurs(3)), d.whileInput(P)), s = r.pipe(i.retry(o), i.withSpan("store.transactional", { attributes: {
+			"db.system": "postgresql",
+			"db.operation": "transaction"
+		} }));
+		try {
+			let e = await this.runtime.runPromiseExit(s);
+			if (a.isSuccess(e)) return e.value.view.commitEvents(), e.value.result;
+			throw n.squash(e.cause);
+		} finally {
+			this.inflightTxns--;
+		}
+	}
+	onChange(e) {
+		return this.emitter.on("change", e), () => {
+			this.emitter.off("change", e);
+		};
+	}
+	get changeScope() {
+		return this.changeStrategy === "cdc" ? "fleet" : "local";
+	}
+	injectExternalChange(e) {
+		this.emitter.emit("change", {
+			...e,
+			origin: "injected"
+		});
+	}
+	run(e) {
+		return this.runtime.runPromise(e);
+	}
+	async close(e = 5e3) {
+		if (this.inflightTxns > 0) {
+			let t = Date.now() + e;
+			for (; this.inflightTxns > 0 && Date.now() < t;) await new Promise((e) => setTimeout(e, 25));
+			this.inflightTxns > 0 && L.warn("close: grace period expired with in-flight transactions — forcing dispose", {
+				gracePeriodMs: e,
+				inflight: this.inflightTxns
+			});
+		}
+		this.cdcFiber &&= (await this.runtime.runPromise(o.interrupt(this.cdcFiber)), null), await this.runtime.dispose();
+	}
+	async ping() {
+		await this.runtime.runPromise(this.sql`SELECT 1`);
+	}
+	async startCdcConsumer() {
+		let e = (await this.runtime.runPromise(t.PgClient)).listen(this.cdcChannel), n = (e) => {
+			try {
+				let t = JSON.parse(e);
+				this.injectExternalChange(t);
+			} catch (e) {
+				L.warn("cdc: bad payload", { channel: this.cdcChannel }, e);
+			}
+		};
+		this.cdcFiber = this.runtime.runFork(e.pipe(f.runForEach((e) => i.sync(() => n(e)))));
+	}
+}, B = class {
+	parent;
+	txn;
+	events = [];
+	committed = !1;
+	constructor(e, t) {
+		this.parent = e, this.txn = t;
+	}
+	query(e) {
+		return this.parent.getInternalRunWithEager()(e, this.txn);
+	}
+	insert(e, t) {
+		return this.parent.getInternalExecuteInsert()(e, t, this.txn, this.events);
+	}
+	insertMany(e, t) {
+		return this.parent.getInternalExecuteInsertMany()(e, t, this.txn, this.events);
+	}
+	patchJson(e, t, n, r) {
+		return this.parent.getInternalExecutePatchJson()(e, t, n, r, this.txn, this.events);
+	}
+	update(e, t, n) {
+		return this.parent.getInternalExecuteUpdate()(e, t, n, this.txn, this.events);
+	}
+	delete(e, t) {
+		return this.parent.getInternalExecuteDelete()(e, t, this.txn, this.events);
+	}
+	updateMany(e, t, n) {
+		return this.parent.getInternalExecuteUpdateMany()(e, t, n, this.txn, this.events);
+	}
+	deleteMany(e, t) {
+		return this.parent.getInternalExecuteDeleteMany()(e, t, this.txn, this.events);
+	}
+	upsert(e, t, n) {
+		return this.parent.getInternalExecuteUpsert()(e, t, n, this.txn, this.events);
+	}
+	insertIgnore(e, t, n) {
+		return this.parent.getInternalExecuteInsertIgnore()(e, t, n, this.txn, this.events);
+	}
+	transactional(e) {
+		return Promise.reject(/* @__PURE__ */ Error("PostgresDataStore.transactional: nested transactions are not supported. Mutations should execute a single top-level transaction."));
+	}
+	onChange(e) {
+		throw Error("PostgresTransactionalView.onChange: subscribing from inside a transaction is not supported. Subscribe on the parent store outside `transactional()`.");
+	}
+	injectExternalChange(e) {
+		throw Error("PostgresTransactionalView.injectExternalChange: injecting external changes from inside a transaction is not supported. Inject on the parent store outside `transactional()`.");
+	}
+	commitEvents() {
+		if (!this.committed) {
+			this.committed = !0;
+			for (let e of this.events) this.parent.emitChange(e);
+			this.events.length = 0;
+		}
+	}
+}, V = class {
+	parent;
+	namespace;
+	constructor(e, t) {
+		this.parent = e, this.namespace = t;
+	}
+	query(e) {
+		return this.parent.runInNamespace(this.namespace, (t) => t.query(e));
+	}
+	insert(e, t) {
+		return this.parent.runInNamespace(this.namespace, (n) => n.insert(e, t));
+	}
+	insertMany(e, t) {
+		return this.parent.runInNamespace(this.namespace, (n) => n.insertMany(e, t));
+	}
+	patchJson(e, t, n, r) {
+		return this.parent.runInNamespace(this.namespace, (i) => i.patchJson(e, t, n, r));
+	}
+	update(e, t, n) {
+		return this.parent.runInNamespace(this.namespace, (r) => r.update(e, t, n));
+	}
+	delete(e, t) {
+		return this.parent.runInNamespace(this.namespace, (n) => n.delete(e, t));
+	}
+	updateMany(e, t, n) {
+		return this.parent.runInNamespace(this.namespace, (r) => r.updateMany(e, t, n));
+	}
+	deleteMany(e, t) {
+		return this.parent.runInNamespace(this.namespace, (n) => n.deleteMany(e, t));
+	}
+	upsert(e, t, n) {
+		return this.parent.runInNamespace(this.namespace, (r) => r.upsert(e, t, n));
+	}
+	insertIgnore(e, t, n) {
+		return this.parent.runInNamespace(this.namespace, (r) => r.insertIgnore(e, t, n));
+	}
+	transactional(e) {
+		return this.parent.runInNamespace(this.namespace, e);
+	}
+	withNamespace(e) {
+		return this.parent.withNamespace(e);
+	}
+	onChange(e) {
+		return this.parent.onChange(e);
+	}
+	injectExternalChange(e) {
+		this.parent.injectExternalChange(e);
+	}
+	raw(e, t) {
+		return this.parent.runInNamespace(this.namespace, (n) => {
+			let r = n.raw;
+			return r === void 0 ? Promise.reject(/* @__PURE__ */ Error("PostgresNamespaceView.raw: underlying store has no raw()")) : r(e, t);
+		});
+	}
+}, H = (e) => e.__postgresReplicationFriend ?? null, U = (e, t) => {
+	let [n, r] = e.split("/"), [i, a] = t.split("/");
+	if (!n || !r || !i || !a) throw Error(`postgres LSN compare: invalid format (${e} vs ${t})`);
+	let o = parseInt(n, 16), s = parseInt(r, 16), c = parseInt(i, 16);
+	return o === c ? s - parseInt(a, 16) : o - c;
+}, W = () => ({
+	async capturePrimaryPosition(e) {
+		let t = H(e);
+		if (t === null) throw Error("postgresReplicationAdapter: primary is not a PostgresDataStore (missing __postgresReplicationFriend). Pass the postgres store directly.");
+		return t.runEffect(i.gen(function* () {
+			let e = (yield* (yield* g)`SELECT pg_current_wal_lsn()::text AS lsn`)[0]?.lsn;
+			return typeof e == "string" ? e : yield* i.die("postgres did not return a WAL LSN");
+		}));
+	},
+	async probeReplicaPosition(e) {
+		let t = H(e);
+		if (t === null) throw Error("postgresReplicationAdapter: replica is not a PostgresDataStore.");
+		return t.runEffect(i.gen(function* () {
+			let e = (yield* (yield* g)`
+          SELECT COALESCE(pg_last_wal_replay_lsn()::text, pg_current_wal_lsn()::text) AS lsn
+        `)[0]?.lsn;
+			return typeof e == "string" ? e : yield* i.die("postgres did not return a replay LSN");
+		}));
+	},
+	compare(e, t) {
+		return U(t, e) >= 0 ? "caught-up" : "behind";
+	}
+}), G = {
+	id: "postgres",
+	makeSqlLayer: (e) => j(e),
+	makeStore: (e) => R(e),
+	compileContains: (e, t, n) => n`${e} ILIKE ${`%${t.replace(/[\\%_]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
+	retryFilter: F
+};
+//#endregion
+export { e as PgClient, A as connectionFromConfig, R as makePostgresDataStore, O as makePostgresSqlLayer, j as makePostgresSqlLayerFromConfig, G as postgresDialect, W as postgresReplicationAdapter, F as postgresRetryFilter };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@voltro/sql-postgres",
+  "version": "0.1.0",
+  "description": "PostgreSQL dialect adapter for Voltro's cross-dialect DataStore (LISTEN/NOTIFY reactivity, logical-replication CDC).",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@effect/sql": "^0.51.1",
+    "@effect/sql-pg": "^0.52.1",
+    "@voltro/database": "0.1.0",
+    "@voltro/logger": "0.1.0",
+    "pg": "^8.22.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}