@foretag/tanstack-db-surrealdb 0.1.0

package/README.md

@@ -0,0 +1,137 @@
+# TanstackDB SurrealDB Collections
+
+> Note: Please note this Software is Pre-release pending testing and not yet recommended for production use.
+
+Add Offline / Local First Caching & Syncing to your SurrealDB app with TanstackDB and Loro (CRDTs).
+
+- Local / Offline first applications with TanstackDB and Loro
+- High performance with Low resource consumption
+- Works with Web, Desktop or Native (WASM based)
+- Support for React, Svelte, Vue and any Framework!
+
+## Installation
+
+### NPM
+```sh
+# NPM
+npm install @foretag/tanstack-db-surrealdb
+# Bun
+bun install @foretag/tanstack-db-surrealdb
+```
+
+### JSR
+```sh
+# NPM
+npx jsr add @foretag/tanstack-db-surrealdb
+# Bun
+bunx jsr add @foretag/tanstack-db-surrealdb
+```
+
+## Usage
+```ts
+// db.ts
+import { Surreal } from 'surrealdb';
+
+export const db = new Surreal();
+await db.connect('ws://localhost:8000/rpc');
+await db.use({ ns: 'ns', db: 'db' });
+
+// collections/products.ts
+import { expr, eq } from 'surrealdb';
+import { db } from '../db';
+import { createCollection } from '@tanstack/db';
+import { surrealCollectionOptions } from '@foretag/tanstack-db-surrealdb';
+
+// Collection Type, could also be generated
+type Product = {
+	id: string;
+	name: string;
+	price: number;
+};
+
+export const products = createCollection(
+	surrealCollection<Product>({
+		id: 'products',
+		useLoro: true, // Optional if you need CRDTs
+		getKey: (collection) => collection.id,
+		table: {
+			db,
+			name: 'products',
+			where: expr(eq('store', '123'))
+		},
+	});
+)
+```
+
+## Vite / Next.JS
+
+### Vite
+```sh
+bun install vite-plugin-wasm vite-plugin-top-level-await -D
+```
+
+`vite.config.ts`
+
+```ts
+// Plugins
+import wasm from 'vite-plugin-wasm';
+import topLevelAwait from 'vite-plugin-top-level-await';
+
+export default defineConfig({
+  plugins: [...otherConfigures, wasm(), topLevelAwait()],
+});
+```
+
+### NextJS
+`next.config.js`
+
+```ts
+module.exports = {
+	webpack: function (config) {
+		config.experiments = {
+			layers: true,
+			asyncWebAssembly: true,
+		};
+		return config;
+	},
+};
+```
+
+## CRDTs
+
+If you need to use CRDTs for your application consider adding the following fields to the specific tables and set `useLoro: true` for the respective table. Please note these fields are opinionated, therefore fixed and required:
+
+```sql
+DEFINE FIELD OVERWRITE sync_deleted ON <table>
+	TYPE bool
+	DEFAULT false
+	COMMENT 'Tombstone for CRDTs';
+
+DEFINE FIELD OVERWRITE updated_at ON <table>
+	TYPE datetime
+	VALUE time::now();
+```
+
+> While using SurrealDB as a Web Database, please remember to allow `SELECT` & `UPDATE` permissions for the `sync_deleted` and `updated_at` fields for the respective access.
+
+## FAQ
+
+<details>
+	<summary><strong>When do I need CRDTs?</strong></summary>
+	<p>In most cases Tanstack DB is sufficient to handle CRUD operations. However, if you need to implement a distributed system that is offline first, CRDTs are the way to go. Think: Google Docs, Figma Pages, Notion Blocks etc. We recommend you check out <a href='https://www.loro.dev/' target='_blank'>Loro</a> for a deeper understanding.</p>
+</details>
+
+<details>
+	<summary><strong>How do I achieve type safety?</strong></summary>
+	<p>Using Codegen tools that generate types from your SurrealDB Schema, this means you don't have to manually maintain types for each Collection.</p>
+</details>
+
+<details>
+	<summary><strong>Can I use GraphQL alongside this Library?</strong></summary>
+	<p>GraphQL workflow is in the works as SurrealDB's own implementation of the GraphQL protocol matures, we'll be able to provide a seamless integration. Since this library only targets TanstackDB, you can also use GraphQL for direct querying through Tanstack Query.</p>
+</details>
+
+<details>
+	<summary><strong>Can I reduce the package sizes?</strong></summary>
+	<p>They can be reduced, but these steps are very unique based on use-case. Loro ships a WASM binary thats 3-4 MB in size, it's one of the tradeoffs of using this approach. The maintainers up-stream are working on reducing the size of the WASM binary.</p>
+</details>

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { CollectionConfig } from '@tanstack/db';
+import { Container } from 'loro-crdt';
+import { Surreal, Expr } from 'surrealdb';
+
+type Id = string;
+type SurrealObject<T> = T & {
+    id: Id;
+};
+type SyncedRow = SurrealObject<{
+    sync_deleted: boolean;
+    updated_at: Date;
+}>;
+type TableOptions = {
+    db: Surreal;
+    name: string;
+    where?: Expr;
+};
+type SurrealCollectionConfig<T extends SyncedRow> = {
+    id?: string;
+    getKey: (row: T) => Id;
+    table: TableOptions;
+    useLoro?: boolean;
+    onError?: (e: unknown) => void;
+};
+
+declare function surrealCollectionOptions<T extends SyncedRow, S extends Record<string, Container> = {
+    [k: string]: never;
+}>({ id, getKey, useLoro, onError, ...config }: SurrealCollectionConfig<T>): CollectionConfig<T>;
+
+export { surrealCollectionOptions };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { CollectionConfig } from '@tanstack/db';
+import { Container } from 'loro-crdt';
+import { Surreal, Expr } from 'surrealdb';
+
+type Id = string;
+type SurrealObject<T> = T & {
+    id: Id;
+};
+type SyncedRow = SurrealObject<{
+    sync_deleted: boolean;
+    updated_at: Date;
+}>;
+type TableOptions = {
+    db: Surreal;
+    name: string;
+    where?: Expr;
+};
+type SurrealCollectionConfig<T extends SyncedRow> = {
+    id?: string;
+    getKey: (row: T) => Id;
+    table: TableOptions;
+    useLoro?: boolean;
+    onError?: (e: unknown) => void;
+};
+
+declare function surrealCollectionOptions<T extends SyncedRow, S extends Record<string, Container> = {
+    [k: string]: never;
+}>({ id, getKey, useLoro, onError, ...config }: SurrealCollectionConfig<T>): CollectionConfig<T>;
+
+export { surrealCollectionOptions };

package/dist/index.js

@@ -0,0 +1,349 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  surrealCollectionOptions: () => surrealCollectionOptions
+});
+module.exports = __toCommonJS(index_exports);
+var import_loro_crdt = require("loro-crdt");
+var import_surrealdb2 = require("surrealdb");
+
+// src/table.ts
+var import_surrealdb = require("surrealdb");
+function manageTable({
+  db,
+  name,
+  where
+}) {
+  const listAll = async () => {
+    if (!where) {
+      const res = await db.select(new import_surrealdb.Table(name)) ?? [];
+      return Array.isArray(res) ? res : [res];
+    }
+    return await db.select(new import_surrealdb.Table(name)).where(where);
+  };
+  const listActive = async () => {
+    return await db.select(new import_surrealdb.Table(name)).where((0, import_surrealdb.and)(where, (0, import_surrealdb.eq)("sync_deleted", false)));
+  };
+  const upsert = async (id, data) => {
+    await db.upsert(id).merge({
+      ...data,
+      sync_deleted: false,
+      updated_at: Date.now()
+    });
+  };
+  const remove = async (id) => {
+    await db.delete(id);
+  };
+  const softDelete = async (id) => {
+    await db.upsert(id).merge({
+      sync_deleted: true,
+      updated_at: Date.now()
+    });
+  };
+  const subscribe = (cb) => {
+    let killed = false;
+    let live;
+    const on = ({ action, value }) => {
+      if (action === "KILLED") return;
+      if (action === "CREATE") cb({ type: "insert", row: value });
+      else if (action === "UPDATE")
+        cb({ type: "update", row: value });
+      else if (action === "DELETE")
+        cb({ type: "delete", row: { id: value.id } });
+    };
+    const start = async () => {
+      if (!where) {
+        live = await db.live(new import_surrealdb.Table(name));
+        live.subscribe(on);
+      } else {
+        const ctx = {
+          def() {
+            return "";
+          }
+        };
+        const [id] = await db.query(
+          `LIVE SELECT * FROM ${name} WHERE ${where.toSQL(ctx)}`
+        ).collect();
+        live = await db.liveOf(new import_surrealdb.Uuid(id));
+        live.subscribe(on);
+      }
+    };
+    void start();
+    return () => {
+      if (killed) return;
+      killed = true;
+      if (live) void live.kill();
+    };
+  };
+  return {
+    listAll,
+    listActive,
+    upsert,
+    remove,
+    softDelete,
+    subscribe
+  };
+}
+
+// src/index.ts
+function surrealCollectionOptions({
+  id,
+  getKey,
+  useLoro = false,
+  onError,
+  ...config
+}) {
+  var _a, _b;
+  let loro;
+  if (useLoro) loro = { doc: new import_loro_crdt.LoroDoc(), key: id };
+  const loroKey = (loro == null ? void 0 : loro.key) ?? id ?? "surreal";
+  const loroMap = useLoro ? ((_b = (_a = loro == null ? void 0 : loro.doc) == null ? void 0 : _a.getMap) == null ? void 0 : _b.call(_a, loroKey)) ?? null : null;
+  const loroToArray = () => {
+    var _a2;
+    if (!loroMap) return [];
+    const json = ((_a2 = loroMap.toJSON) == null ? void 0 : _a2.call(loroMap)) ?? {};
+    return Object.values(json);
+  };
+  const loroPut = (row) => {
+    var _a2, _b2;
+    if (!loroMap) return;
+    loroMap.set(String(getKey(row)), row);
+    (_b2 = (_a2 = loro == null ? void 0 : loro.doc) == null ? void 0 : _a2.commit) == null ? void 0 : _b2.call(_a2);
+  };
+  const loroRemove = (id2) => {
+    var _a2, _b2;
+    if (!loroMap) return;
+    loroMap.delete(String(id2));
+    (_b2 = (_a2 = loro == null ? void 0 : loro.doc) == null ? void 0 : _a2.commit) == null ? void 0 : _b2.call(_a2);
+  };
+  const flushPushQueue = async () => {
+    const ops = pushQueue.splice(0, pushQueue.length);
+    for (const op of ops) {
+      if (op.kind === "upsert") {
+        const rid = new import_surrealdb2.RecordId(config.table.name, op.row.id);
+        await table.upsert(rid, op.row);
+      } else {
+        const rid = new import_surrealdb2.RecordId(config.table.name, op.id);
+        await table.softDelete(rid);
+      }
+    }
+  };
+  const pushQueue = [];
+  const enqueuePush = (op) => pushQueue.push(op);
+  const newer = (a, b) => ((a == null ? void 0 : a.getTime()) ?? -1) > ((b == null ? void 0 : b.getTime()) ?? -1);
+  const reconcileBoot = (serverRows, write) => {
+    const localRows = useLoro ? loroToArray() : [];
+    const serverById = new Map(
+      serverRows.map((r) => [getKey(r), r])
+    );
+    const localById = new Map(localRows.map((r) => [getKey(r), r]));
+    const ids = /* @__PURE__ */ new Set([...serverById.keys(), ...localById.keys()]);
+    const current = [];
+    const applyLocal = (row) => {
+      if (!useLoro || !row) return;
+      if (row.sync_deleted) loroRemove(row.id);
+      else loroPut(row);
+    };
+    for (const id2 of ids) {
+      const s = serverById.get(id2);
+      const l = localById.get(id2);
+      if (s && l) {
+        if (s.sync_deleted && l.sync_deleted) {
+          applyLocal(s);
+          current.push(s);
+        } else if (s.sync_deleted && !l.sync_deleted) {
+          applyLocal(s);
+          current.push(s);
+        } else if (!s.sync_deleted && l.sync_deleted) {
+          if (newer(l.updated_at, s.updated_at)) {
+            enqueuePush({
+              kind: "delete",
+              id: id2,
+              updated_at: l.updated_at
+            });
+            applyLocal(l);
+            current.push(l);
+          } else {
+            applyLocal(s);
+            current.push(s);
+          }
+        } else {
+          if (newer(l.updated_at, s.updated_at)) {
+            enqueuePush({ kind: "upsert", row: l });
+            applyLocal(l);
+            current.push(l);
+          } else {
+            applyLocal(s);
+            current.push(s);
+          }
+        }
+      } else if (s && !l) {
+        applyLocal(s);
+        current.push(s);
+      } else if (!s && l) {
+        if (l.sync_deleted) {
+          enqueuePush({
+            kind: "delete",
+            id: id2,
+            updated_at: l.updated_at
+          });
+          applyLocal(l);
+          current.push(l);
+        } else {
+          enqueuePush({ kind: "upsert", row: l });
+          applyLocal(l);
+          current.push(l);
+        }
+      }
+    }
+    diffAndEmit(current, write);
+  };
+  let prevById = /* @__PURE__ */ new Map();
+  const buildMap = (rows) => new Map(rows.map((r) => [getKey(r), r]));
+  const same = (a, b) => a.sync_deleted === b.sync_deleted && a.updated_at.getTime() === b.updated_at.getTime() && JSON.stringify({
+    ...a,
+    updated_at: void 0,
+    sync_deleted: void 0
+  }) === JSON.stringify({
+    ...b,
+    updated_at: void 0,
+    sync_deleted: void 0
+  });
+  const diffAndEmit = (currentRows, write) => {
+    const currById = buildMap(currentRows);
+    for (const [id2, row] of currById) {
+      const prev = prevById.get(id2);
+      if (!prev) {
+        write({ type: "insert", value: row });
+      } else if (!same(prev, row)) {
+        write({ type: "update", value: row });
+      }
+    }
+    for (const [id2, prev] of prevById) {
+      if (!currById.has(id2)) {
+        write({ type: "delete", value: prev });
+      }
+    }
+    prevById = currById;
+  };
+  const table = manageTable(config.table);
+  const sync = ({
+    begin,
+    write,
+    commit,
+    markReady
+  }) => {
+    let offLive = null;
+    const makeTombstone = (id2) => ({ id: id2, updated_at: /* @__PURE__ */ new Date(), sync_deleted: true });
+    const start = async () => {
+      try {
+        const serverRows = await table.listAll();
+        begin();
+        if (useLoro) reconcileBoot(serverRows, write);
+        else diffAndEmit(serverRows, write);
+        commit();
+        markReady();
+        await flushPushQueue();
+        offLive = table.subscribe((evt) => {
+          begin();
+          try {
+            if (evt.type === "insert" || evt.type === "update") {
+              const row = evt.row;
+              if (row.sync_deleted) {
+                if (useLoro) loroRemove(row.id);
+                const prev = prevById.get(row.id) ?? makeTombstone(row.id);
+                write({ type: "delete", value: prev });
+                prevById.delete(row.id);
+              } else {
+                if (useLoro) loroPut(row);
+                const had = prevById.has(row.id);
+                write({
+                  type: had ? "update" : "insert",
+                  value: row
+                });
+                prevById.set(row.id, row);
+              }
+            } else if (evt.type === "delete") {
+              const id2 = getKey(evt.row);
+              if (useLoro) loroRemove(id2);
+              const prev = prevById.get(id2) ?? makeTombstone(id2);
+              write({ type: "delete", value: prev });
+              prevById.delete(id2);
+            }
+          } finally {
+            commit();
+          }
+        });
+      } catch (e) {
+        onError == null ? void 0 : onError(e);
+        markReady();
+      }
+    };
+    void start();
+    return () => {
+      if (offLive) offLive();
+    };
+  };
+  const now = () => Date.now();
+  const onInsert = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "insert") continue;
+      const row = {
+        ...m.modified,
+        updated_at: now(),
+        deleted: false
+      };
+      if (useLoro) loroPut(row);
+      const rid = new import_surrealdb2.RecordId(config.table.name, row.id);
+      await table.upsert(rid, row);
+    }
+  };
+  const onUpdate = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "update") continue;
+      const id2 = m.key;
+      const merged = { ...m.modified, id: id2, updated_at: now() };
+      if (useLoro) loroPut(merged);
+      const rid = new import_surrealdb2.RecordId(config.table.name, id2);
+      await table.upsert(rid, merged);
+    }
+  };
+  const onDelete = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "delete") continue;
+      const id2 = m.key;
+      if (useLoro) loroRemove(id2);
+      await table.softDelete(new import_surrealdb2.RecordId(config.table.name, id2));
+    }
+  };
+  return {
+    id,
+    getKey,
+    sync: { sync },
+    onInsert,
+    onDelete,
+    onUpdate
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  surrealCollectionOptions
+});

package/dist/index.mjs

@@ -0,0 +1,330 @@
+// src/index.ts
+import { LoroDoc } from "loro-crdt";
+import { RecordId } from "surrealdb";
+
+// src/table.ts
+import {
+  and,
+  eq,
+  Table,
+  Uuid
+} from "surrealdb";
+function manageTable({
+  db,
+  name,
+  where
+}) {
+  const listAll = async () => {
+    if (!where) {
+      const res = await db.select(new Table(name)) ?? [];
+      return Array.isArray(res) ? res : [res];
+    }
+    return await db.select(new Table(name)).where(where);
+  };
+  const listActive = async () => {
+    return await db.select(new Table(name)).where(and(where, eq("sync_deleted", false)));
+  };
+  const upsert = async (id, data) => {
+    await db.upsert(id).merge({
+      ...data,
+      sync_deleted: false,
+      updated_at: Date.now()
+    });
+  };
+  const remove = async (id) => {
+    await db.delete(id);
+  };
+  const softDelete = async (id) => {
+    await db.upsert(id).merge({
+      sync_deleted: true,
+      updated_at: Date.now()
+    });
+  };
+  const subscribe = (cb) => {
+    let killed = false;
+    let live;
+    const on = ({ action, value }) => {
+      if (action === "KILLED") return;
+      if (action === "CREATE") cb({ type: "insert", row: value });
+      else if (action === "UPDATE")
+        cb({ type: "update", row: value });
+      else if (action === "DELETE")
+        cb({ type: "delete", row: { id: value.id } });
+    };
+    const start = async () => {
+      if (!where) {
+        live = await db.live(new Table(name));
+        live.subscribe(on);
+      } else {
+        const ctx = {
+          def() {
+            return "";
+          }
+        };
+        const [id] = await db.query(
+          `LIVE SELECT * FROM ${name} WHERE ${where.toSQL(ctx)}`
+        ).collect();
+        live = await db.liveOf(new Uuid(id));
+        live.subscribe(on);
+      }
+    };
+    void start();
+    return () => {
+      if (killed) return;
+      killed = true;
+      if (live) void live.kill();
+    };
+  };
+  return {
+    listAll,
+    listActive,
+    upsert,
+    remove,
+    softDelete,
+    subscribe
+  };
+}
+
+// src/index.ts
+function surrealCollectionOptions({
+  id,
+  getKey,
+  useLoro = false,
+  onError,
+  ...config
+}) {
+  var _a, _b;
+  let loro;
+  if (useLoro) loro = { doc: new LoroDoc(), key: id };
+  const loroKey = (loro == null ? void 0 : loro.key) ?? id ?? "surreal";
+  const loroMap = useLoro ? ((_b = (_a = loro == null ? void 0 : loro.doc) == null ? void 0 : _a.getMap) == null ? void 0 : _b.call(_a, loroKey)) ?? null : null;
+  const loroToArray = () => {
+    var _a2;
+    if (!loroMap) return [];
+    const json = ((_a2 = loroMap.toJSON) == null ? void 0 : _a2.call(loroMap)) ?? {};
+    return Object.values(json);
+  };
+  const loroPut = (row) => {
+    var _a2, _b2;
+    if (!loroMap) return;
+    loroMap.set(String(getKey(row)), row);
+    (_b2 = (_a2 = loro == null ? void 0 : loro.doc) == null ? void 0 : _a2.commit) == null ? void 0 : _b2.call(_a2);
+  };
+  const loroRemove = (id2) => {
+    var _a2, _b2;
+    if (!loroMap) return;
+    loroMap.delete(String(id2));
+    (_b2 = (_a2 = loro == null ? void 0 : loro.doc) == null ? void 0 : _a2.commit) == null ? void 0 : _b2.call(_a2);
+  };
+  const flushPushQueue = async () => {
+    const ops = pushQueue.splice(0, pushQueue.length);
+    for (const op of ops) {
+      if (op.kind === "upsert") {
+        const rid = new RecordId(config.table.name, op.row.id);
+        await table.upsert(rid, op.row);
+      } else {
+        const rid = new RecordId(config.table.name, op.id);
+        await table.softDelete(rid);
+      }
+    }
+  };
+  const pushQueue = [];
+  const enqueuePush = (op) => pushQueue.push(op);
+  const newer = (a, b) => ((a == null ? void 0 : a.getTime()) ?? -1) > ((b == null ? void 0 : b.getTime()) ?? -1);
+  const reconcileBoot = (serverRows, write) => {
+    const localRows = useLoro ? loroToArray() : [];
+    const serverById = new Map(
+      serverRows.map((r) => [getKey(r), r])
+    );
+    const localById = new Map(localRows.map((r) => [getKey(r), r]));
+    const ids = /* @__PURE__ */ new Set([...serverById.keys(), ...localById.keys()]);
+    const current = [];
+    const applyLocal = (row) => {
+      if (!useLoro || !row) return;
+      if (row.sync_deleted) loroRemove(row.id);
+      else loroPut(row);
+    };
+    for (const id2 of ids) {
+      const s = serverById.get(id2);
+      const l = localById.get(id2);
+      if (s && l) {
+        if (s.sync_deleted && l.sync_deleted) {
+          applyLocal(s);
+          current.push(s);
+        } else if (s.sync_deleted && !l.sync_deleted) {
+          applyLocal(s);
+          current.push(s);
+        } else if (!s.sync_deleted && l.sync_deleted) {
+          if (newer(l.updated_at, s.updated_at)) {
+            enqueuePush({
+              kind: "delete",
+              id: id2,
+              updated_at: l.updated_at
+            });
+            applyLocal(l);
+            current.push(l);
+          } else {
+            applyLocal(s);
+            current.push(s);
+          }
+        } else {
+          if (newer(l.updated_at, s.updated_at)) {
+            enqueuePush({ kind: "upsert", row: l });
+            applyLocal(l);
+            current.push(l);
+          } else {
+            applyLocal(s);
+            current.push(s);
+          }
+        }
+      } else if (s && !l) {
+        applyLocal(s);
+        current.push(s);
+      } else if (!s && l) {
+        if (l.sync_deleted) {
+          enqueuePush({
+            kind: "delete",
+            id: id2,
+            updated_at: l.updated_at
+          });
+          applyLocal(l);
+          current.push(l);
+        } else {
+          enqueuePush({ kind: "upsert", row: l });
+          applyLocal(l);
+          current.push(l);
+        }
+      }
+    }
+    diffAndEmit(current, write);
+  };
+  let prevById = /* @__PURE__ */ new Map();
+  const buildMap = (rows) => new Map(rows.map((r) => [getKey(r), r]));
+  const same = (a, b) => a.sync_deleted === b.sync_deleted && a.updated_at.getTime() === b.updated_at.getTime() && JSON.stringify({
+    ...a,
+    updated_at: void 0,
+    sync_deleted: void 0
+  }) === JSON.stringify({
+    ...b,
+    updated_at: void 0,
+    sync_deleted: void 0
+  });
+  const diffAndEmit = (currentRows, write) => {
+    const currById = buildMap(currentRows);
+    for (const [id2, row] of currById) {
+      const prev = prevById.get(id2);
+      if (!prev) {
+        write({ type: "insert", value: row });
+      } else if (!same(prev, row)) {
+        write({ type: "update", value: row });
+      }
+    }
+    for (const [id2, prev] of prevById) {
+      if (!currById.has(id2)) {
+        write({ type: "delete", value: prev });
+      }
+    }
+    prevById = currById;
+  };
+  const table = manageTable(config.table);
+  const sync = ({
+    begin,
+    write,
+    commit,
+    markReady
+  }) => {
+    let offLive = null;
+    const makeTombstone = (id2) => ({ id: id2, updated_at: /* @__PURE__ */ new Date(), sync_deleted: true });
+    const start = async () => {
+      try {
+        const serverRows = await table.listAll();
+        begin();
+        if (useLoro) reconcileBoot(serverRows, write);
+        else diffAndEmit(serverRows, write);
+        commit();
+        markReady();
+        await flushPushQueue();
+        offLive = table.subscribe((evt) => {
+          begin();
+          try {
+            if (evt.type === "insert" || evt.type === "update") {
+              const row = evt.row;
+              if (row.sync_deleted) {
+                if (useLoro) loroRemove(row.id);
+                const prev = prevById.get(row.id) ?? makeTombstone(row.id);
+                write({ type: "delete", value: prev });
+                prevById.delete(row.id);
+              } else {
+                if (useLoro) loroPut(row);
+                const had = prevById.has(row.id);
+                write({
+                  type: had ? "update" : "insert",
+                  value: row
+                });
+                prevById.set(row.id, row);
+              }
+            } else if (evt.type === "delete") {
+              const id2 = getKey(evt.row);
+              if (useLoro) loroRemove(id2);
+              const prev = prevById.get(id2) ?? makeTombstone(id2);
+              write({ type: "delete", value: prev });
+              prevById.delete(id2);
+            }
+          } finally {
+            commit();
+          }
+        });
+      } catch (e) {
+        onError == null ? void 0 : onError(e);
+        markReady();
+      }
+    };
+    void start();
+    return () => {
+      if (offLive) offLive();
+    };
+  };
+  const now = () => Date.now();
+  const onInsert = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "insert") continue;
+      const row = {
+        ...m.modified,
+        updated_at: now(),
+        deleted: false
+      };
+      if (useLoro) loroPut(row);
+      const rid = new RecordId(config.table.name, row.id);
+      await table.upsert(rid, row);
+    }
+  };
+  const onUpdate = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "update") continue;
+      const id2 = m.key;
+      const merged = { ...m.modified, id: id2, updated_at: now() };
+      if (useLoro) loroPut(merged);
+      const rid = new RecordId(config.table.name, id2);
+      await table.upsert(rid, merged);
+    }
+  };
+  const onDelete = async (p) => {
+    for (const m of p.transaction.mutations) {
+      if (m.type !== "delete") continue;
+      const id2 = m.key;
+      if (useLoro) loroRemove(id2);
+      await table.softDelete(new RecordId(config.table.name, id2));
+    }
+  };
+  return {
+    id,
+    getKey,
+    sync: { sync },
+    onInsert,
+    onDelete,
+    onUpdate
+  };
+}
+export {
+  surrealCollectionOptions
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@foretag/tanstack-db-surrealdb",
+	"description": "Add Offline / Local First Caching & Syncing to your SurrealDB app with TanstackDB and Loro (CRDTs)",
+	"version": "0.1.0",
+	"files": [
+		"dist"
+	],
+	"module": "./dist/index.mjs",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/index.d.mts",
+				"default": "./dist/index.mjs"
+			},
+			"require": {
+				"types": "./dist/index.d.ts",
+				"default": "./dist/index.js"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"keywords": [
+		"surrealdb",
+		"tanstackdb",
+		"crdts",
+		"sync",
+		"local-first"
+	],
+	"author": {
+		"name": "Chiru Boggavarapu",
+		"email": "chiru@foretag.co"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ForetagInc/tanstack-db-surrealdb"
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --dts --format esm,cjs"
+	},
+	"dependencies": {
+		"@tanstack/db": "^0.4.3",
+		"loro-crdt": "^1.8.1",
+		"surrealdb": "2.0.0-alpha.8"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.2.5",
+		"bunup": "^0.14.11",
+		"tsup": "^8.5.0"
+	}
+}