@super-line/collections-pglite 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  pgliteCollections: () => pgliteCollections
+});
+module.exports = __toCommonJS(index_exports);
+var import_pglite = require("@electric-sql/pglite");
+var import_live = require("@electric-sql/pglite/live");
+var import_pglite_sync = require("@electric-sql/pglite-sync");
+var import_postgres = __toESM(require("postgres"), 1);
+var import_core = require("@super-line/core");
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var SEP = String.fromCharCode(1);
+var encodePk = (n, id) => n + SEP + id;
+var decodePk = (pk) => {
+  const i = pk.indexOf(SEP);
+  return i === -1 ? { n: pk, id: "" } : { n: pk.slice(0, i), id: pk.slice(i + 1) };
+};
+async function pgliteCollections(opts) {
+  const table = opts.table ?? "collection_rows";
+  if (!IDENT.test(table)) throw new Error(`Invalid table name: ${table}`);
+  const ddl = `CREATE TABLE IF NOT EXISTS "${table}" (pk text PRIMARY KEY, collection text NOT NULL, id text NOT NULL, data jsonb NOT NULL, origin text)`;
+  const sql = (0, import_postgres.default)(opts.pgUrl, { prepare: false, onnotice: () => {
+  } });
+  const runDdl = async (stmt) => {
+    try {
+      await sql.unsafe(stmt);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "42P07" && code !== "23505" && code !== "42710") throw err;
+    }
+  };
+  await runDdl(ddl);
+  const asJson = (v) => sql.json(v);
+  const ownsDb = !opts.db;
+  const db = opts.db ?? await import_pglite.PGlite.create({ extensions: { live: import_live.live, sync: (0, import_pglite_sync.electricSync)() } });
+  await db.exec(ddl);
+  const changeCbs = /* @__PURE__ */ new Set();
+  const liveSub = await db.live.changes(`SELECT pk, data, origin FROM "${table}"`, [], "pk", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "INSERT" && ch.__op__ !== "UPDATE" && ch.__op__ !== "DELETE") continue;
+      const { n, id } = decodePk(ch.pk);
+      const origin = ch.origin ?? "";
+      if (ch.__op__ === "DELETE") {
+        for (const cb of changeCbs) cb({ n, k: "delete", id, origin });
+      } else {
+        const k = ch.__op__ === "INSERT" ? "insert" : "update";
+        for (const cb of changeCbs) cb({ n, k, id, next: ch.data, origin });
+      }
+    }
+  });
+  const shape = opts.electricUrl && db.sync ? await db.sync.syncShapeToTable({ shape: { url: opts.electricUrl, params: { table } }, table, primaryKey: ["pk"], shapeKey: null }) : void 0;
+  return {
+    clustering: "self",
+    async apply(ops, origin) {
+      await sql.begin(async (tx) => {
+        for (const op of ops) {
+          const pk = encodePk(op.n, op.id);
+          if (op.op === "insert") {
+            const res = await tx`INSERT INTO ${tx(table)} (pk, collection, id, data, origin)
+              VALUES (${pk}, ${op.n}, ${op.id}, ${asJson(op.row)}, ${origin}) ON CONFLICT (pk) DO NOTHING`;
+            if (res.count === 0) throw new import_core.SuperLineError("CONFLICT", `Row already exists: ${op.n}/${op.id}`);
+          } else if (op.op === "update") {
+            const res = await tx`UPDATE ${tx(table)} SET data = ${asJson(op.row)}, origin = ${origin} WHERE pk = ${pk}`;
+            if (res.count === 0) throw new import_core.SuperLineError("NOT_FOUND", `No row: ${op.n}/${op.id}`);
+          } else {
+            await tx`DELETE FROM ${tx(table)} WHERE pk = ${pk}`;
+          }
+        }
+      });
+      return [];
+    },
+    async snapshot(n, query) {
+      const rows = await sql`SELECT data::text AS data FROM ${sql(table)} WHERE collection = ${n}`;
+      return (0, import_core.applyQuery)(
+        rows.map((r) => JSON.parse(r.data)),
+        query
+      );
+    },
+    async read(n, id) {
+      const rows = await sql`SELECT data::text AS data FROM ${sql(table)} WHERE pk = ${encodePk(n, id)}`;
+      return rows[0] ? JSON.parse(rows[0].data) : void 0;
+    },
+    onChange(cb) {
+      changeCbs.add(cb);
+      return () => changeCbs.delete(cb);
+    },
+    async close() {
+      try {
+        await liveSub.unsubscribe();
+        shape?.unsubscribe();
+        if (ownsDb) await db.close();
+      } finally {
+        await sql.end();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pgliteCollections
+});

package/dist/index.d.cts

@@ -0,0 +1,25 @@
+import { PGliteWithLive } from '@electric-sql/pglite/live';
+import { CollectionStore } from '@super-line/core';
+
+/** Options for {@link pgliteCollections}. */
+interface PgliteCollectionsOptions {
+    /** Connection string for the central Postgres — source of truth for writes + strong reads (real Postgres or a PGLiteSocketServer). */
+    pgUrl: string;
+    /** Electric shape endpoint streaming the central table into this node's local replica. Omit to feed the replica manually (tests). */
+    electricUrl?: string;
+    /** Table holding every collection's rows on both central + replica; defaults to `collection_rows`. */
+    table?: string;
+    /** Advanced/testing: supply the local PGlite replica (needs the `live` extension; add `sync`/`electricSync` for real Electric). */
+    db?: PGliteWithLive;
+}
+/**
+ * The self-clustering CollectionStore (ADR-0006, `clustering: 'self'`) — the collection analogue of
+ * {@link "@super-line/store-pglite"}. Writes + strong reads hit a central Postgres; each node mirrors the row
+ * table into an in-memory PGlite replica via **Electric** (one-way) and turns its `live.changes` feed into
+ * {@link CollectionStore.onChange}, which core fans to LOCAL subscribers only. Postgres+Electric is the only
+ * fan-out infra — no super-line adapter. A write round-trips central PG → Electric → every node's feed; the
+ * `origin` column carries attribution through the round-trip. All collections share one table, keyed by the pk.
+ */
+declare function pgliteCollections(opts: PgliteCollectionsOptions): Promise<CollectionStore>;
+
+export { type PgliteCollectionsOptions, pgliteCollections };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { PGliteWithLive } from '@electric-sql/pglite/live';
+import { CollectionStore } from '@super-line/core';
+
+/** Options for {@link pgliteCollections}. */
+interface PgliteCollectionsOptions {
+    /** Connection string for the central Postgres — source of truth for writes + strong reads (real Postgres or a PGLiteSocketServer). */
+    pgUrl: string;
+    /** Electric shape endpoint streaming the central table into this node's local replica. Omit to feed the replica manually (tests). */
+    electricUrl?: string;
+    /** Table holding every collection's rows on both central + replica; defaults to `collection_rows`. */
+    table?: string;
+    /** Advanced/testing: supply the local PGlite replica (needs the `live` extension; add `sync`/`electricSync` for real Electric). */
+    db?: PGliteWithLive;
+}
+/**
+ * The self-clustering CollectionStore (ADR-0006, `clustering: 'self'`) — the collection analogue of
+ * {@link "@super-line/store-pglite"}. Writes + strong reads hit a central Postgres; each node mirrors the row
+ * table into an in-memory PGlite replica via **Electric** (one-way) and turns its `live.changes` feed into
+ * {@link CollectionStore.onChange}, which core fans to LOCAL subscribers only. Postgres+Electric is the only
+ * fan-out infra — no super-line adapter. A write round-trips central PG → Electric → every node's feed; the
+ * `origin` column carries attribution through the round-trip. All collections share one table, keyed by the pk.
+ */
+declare function pgliteCollections(opts: PgliteCollectionsOptions): Promise<CollectionStore>;
+
+export { type PgliteCollectionsOptions, pgliteCollections };

package/dist/index.js

@@ -0,0 +1,96 @@
+// src/index.ts
+import { PGlite } from "@electric-sql/pglite";
+import { live } from "@electric-sql/pglite/live";
+import { electricSync } from "@electric-sql/pglite-sync";
+import postgres from "postgres";
+import { SuperLineError, applyQuery } from "@super-line/core";
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var SEP = String.fromCharCode(1);
+var encodePk = (n, id) => n + SEP + id;
+var decodePk = (pk) => {
+  const i = pk.indexOf(SEP);
+  return i === -1 ? { n: pk, id: "" } : { n: pk.slice(0, i), id: pk.slice(i + 1) };
+};
+async function pgliteCollections(opts) {
+  const table = opts.table ?? "collection_rows";
+  if (!IDENT.test(table)) throw new Error(`Invalid table name: ${table}`);
+  const ddl = `CREATE TABLE IF NOT EXISTS "${table}" (pk text PRIMARY KEY, collection text NOT NULL, id text NOT NULL, data jsonb NOT NULL, origin text)`;
+  const sql = postgres(opts.pgUrl, { prepare: false, onnotice: () => {
+  } });
+  const runDdl = async (stmt) => {
+    try {
+      await sql.unsafe(stmt);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "42P07" && code !== "23505" && code !== "42710") throw err;
+    }
+  };
+  await runDdl(ddl);
+  const asJson = (v) => sql.json(v);
+  const ownsDb = !opts.db;
+  const db = opts.db ?? await PGlite.create({ extensions: { live, sync: electricSync() } });
+  await db.exec(ddl);
+  const changeCbs = /* @__PURE__ */ new Set();
+  const liveSub = await db.live.changes(`SELECT pk, data, origin FROM "${table}"`, [], "pk", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "INSERT" && ch.__op__ !== "UPDATE" && ch.__op__ !== "DELETE") continue;
+      const { n, id } = decodePk(ch.pk);
+      const origin = ch.origin ?? "";
+      if (ch.__op__ === "DELETE") {
+        for (const cb of changeCbs) cb({ n, k: "delete", id, origin });
+      } else {
+        const k = ch.__op__ === "INSERT" ? "insert" : "update";
+        for (const cb of changeCbs) cb({ n, k, id, next: ch.data, origin });
+      }
+    }
+  });
+  const shape = opts.electricUrl && db.sync ? await db.sync.syncShapeToTable({ shape: { url: opts.electricUrl, params: { table } }, table, primaryKey: ["pk"], shapeKey: null }) : void 0;
+  return {
+    clustering: "self",
+    async apply(ops, origin) {
+      await sql.begin(async (tx) => {
+        for (const op of ops) {
+          const pk = encodePk(op.n, op.id);
+          if (op.op === "insert") {
+            const res = await tx`INSERT INTO ${tx(table)} (pk, collection, id, data, origin)
+              VALUES (${pk}, ${op.n}, ${op.id}, ${asJson(op.row)}, ${origin}) ON CONFLICT (pk) DO NOTHING`;
+            if (res.count === 0) throw new SuperLineError("CONFLICT", `Row already exists: ${op.n}/${op.id}`);
+          } else if (op.op === "update") {
+            const res = await tx`UPDATE ${tx(table)} SET data = ${asJson(op.row)}, origin = ${origin} WHERE pk = ${pk}`;
+            if (res.count === 0) throw new SuperLineError("NOT_FOUND", `No row: ${op.n}/${op.id}`);
+          } else {
+            await tx`DELETE FROM ${tx(table)} WHERE pk = ${pk}`;
+          }
+        }
+      });
+      return [];
+    },
+    async snapshot(n, query) {
+      const rows = await sql`SELECT data::text AS data FROM ${sql(table)} WHERE collection = ${n}`;
+      return applyQuery(
+        rows.map((r) => JSON.parse(r.data)),
+        query
+      );
+    },
+    async read(n, id) {
+      const rows = await sql`SELECT data::text AS data FROM ${sql(table)} WHERE pk = ${encodePk(n, id)}`;
+      return rows[0] ? JSON.parse(rows[0].data) : void 0;
+    },
+    onChange(cb) {
+      changeCbs.add(cb);
+      return () => changeCbs.delete(cb);
+    },
+    async close() {
+      try {
+        await liveSub.unsubscribe();
+        shape?.unsubscribe();
+        if (ownsDb) await db.close();
+      } finally {
+        await sql.end();
+      }
+    }
+  };
+}
+export {
+  pgliteCollections
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@super-line/collections-pglite",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Self-clustering CollectionStore for super-line — central Postgres + per-node Electric-synced PGlite replica (live.changes). Postgres is the only fan-out infra; no adapter.",
+  "license": "MIT",
+  "author": "Mert",
+  "keywords": [
+    "super-line",
+    "collections",
+    "pglite",
+    "postgres",
+    "electric",
+    "sync",
+    "self",
+    "rows"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mertdogar/super-line.git",
+    "directory": "packages/collections-pglite"
+  },
+  "homepage": "https://mertdogar.github.io/super-line/",
+  "bugs": "https://github.com/mertdogar/super-line/issues",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@electric-sql/pglite": "^0.5.3",
+    "@electric-sql/pglite-sync": "^0.6.3",
+    "postgres": "^3.4.9",
+    "@super-line/core": "^0.10.1"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite-socket": "^0.2.6"
+  },
+  "scripts": {
+    "build": "tsup"
+  }
+}