@foretag/tanstack-db-surrealdb 0.3.0 → 0.3.2

package/dist/index.mjs

@@ -1,109 +1,50 @@
-// src/index.ts
-import { LoroDoc } from "loro-crdt";
-import { Features as Features2, RecordId } from "surrealdb";
+import { queryCollectionOptions } from '@tanstack/query-db-collection';
+import { LoroDoc } from 'loro-crdt';
+import { RecordId, Features, Table, and, eq } from 'surrealdb';
 
-// src/table.ts
-import {
-  and,
-  eq,
-  Features,
-  Table
-} from "surrealdb";
-function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
-  const rawFields = args.fields ?? "*";
-  const fields = rawFields === "*" ? ["*"] : [...rawFields];
-  const cache = /* @__PURE__ */ new Map();
-  let fullyLoaded = false;
-  const pageSize = args.pageSize ?? 100;
-  const initialPageSize = args.initialPageSize ?? Math.min(50, pageSize);
-  let cursor = 0;
-  let progressiveTask = null;
-  const idKey = (id) => typeof id === "string" ? id : id.toString();
-  const upsertCache = (rows) => {
-    for (const row of rows) cache.set(idKey(row.id), row);
-  };
-  const removeFromCache = (id) => {
-    cache.delete(idKey(id));
-  };
-  const listCached = () => Array.from(cache.values());
-  const buildWhere = () => {
+// src/index.ts
+var normalizeFields = (raw) => {
+  if (!raw || raw === "*") return ["*"];
+  return raw;
+};
+var joinOrderBy = (o) => {
+  if (!o) return void 0;
+  return typeof o === "string" ? o : o.join(", ");
+};
+function manageTable(db, useLoro, { name, ...args }) {
+  const fields = normalizeFields(args.fields);
+  const baseWhere = () => {
     if (!useLoro) return args.where;
-    return args.where ? and(args.where, eq("sync_deleted", false)) : eq("sync_deleted", false);
-  };
-  const buildQuery = () => {
-    let q = db.select(new Table(name));
-    const cond = buildWhere();
-    if (cond) q = q.where(cond);
-    return q;
-  };
-  const applyPaging = (q, start, limit) => {
-    if (typeof start === "number" && q.start) q = q.start(start);
-    if (typeof limit === "number" && q.limit) q = q.limit(limit);
-    return q;
-  };
-  const fetchAll = async () => {
-    const rows = await buildQuery().fields(...fields);
-    upsertCache(rows);
-    fullyLoaded = true;
-    return rows;
-  };
-  const fetchPage = async (opts) => {
-    const q = applyPaging(
-      buildQuery(),
-      opts?.start ?? 0,
-      opts?.limit ?? pageSize
-    );
-    const rows = await q.fields(...fields);
-    upsertCache(rows);
-    if (rows.length < (opts?.limit ?? pageSize)) fullyLoaded = true;
-    return rows;
-  };
-  const fetchById = async (id) => {
-    const key = idKey(id);
-    const cached = cache.get(key);
-    if (cached) return cached;
-    const res = await db.select(id);
-    const row = Array.isArray(res) ? res[0] : res;
-    if (!row) return null;
-    if (useLoro && row.sync_deleted)
-      return null;
-    cache.set(key, row);
-    return row;
-  };
-  const loadMore = async (limit = pageSize) => {
-    if (fullyLoaded) return { rows: [], done: true };
-    const rows = await fetchPage({ start: cursor, limit });
-    cursor += rows.length;
-    const done = fullyLoaded || rows.length < limit;
-    args.onProgress?.({
+    const alive = eq("sync_deleted", false);
+    return args.where ? and(args.where, alive) : alive;
+  };
+  const listAll = async () => {
+    const where = baseWhere();
+    const whereSql = where ? " WHERE $where" : "";
+    const sql = `SELECT ${fields.join(", ")} FROM type::table($table)${whereSql};`;
+    const [res] = await db.query(sql, {
       table: name,
-      loaded: cache.size,
-      lastBatch: rows.length,
-      done
+      where
     });
-    return { rows, done };
-  };
-  const startProgressive = () => {
-    if (progressiveTask || fullyLoaded) return;
-    progressiveTask = (async () => {
-      if (cache.size === 0) await loadMore(initialPageSize);
-      while (!fullyLoaded) {
-        const { done } = await loadMore(pageSize);
-        if (done) break;
-      }
-    })().finally(() => {
-      progressiveTask = null;
+    return res ?? [];
+  };
+  const loadSubset = async (subset) => {
+    const b = baseWhere();
+    const w = subset?.where;
+    const where = b && w ? and(b, w) : b ?? w;
+    const whereSql = where ? " WHERE $where" : "";
+    const order = joinOrderBy(subset?.orderBy);
+    const orderSql = order ? ` ORDER BY ${order}` : "";
+    const limitSql = typeof subset?.limit === "number" ? " LIMIT $limit" : "";
+    const startSql = typeof subset?.offset === "number" ? " START $offset" : "";
+    const sql = `SELECT ${fields.join(", ")} FROM type::table($table)${whereSql}${orderSql}${limitSql}${startSql};`;
+    const [res] = await db.query(sql, {
+      table: name,
+      where,
+      limit: subset?.limit,
+      offset: subset?.offset
     });
-  };
-  const listAll = () => fetchAll();
-  const listActive = async () => {
-    if (syncMode === "eager") return fetchAll();
-    if (syncMode === "progressive") {
-      if (cache.size === 0) await loadMore(initialPageSize);
-      startProgressive();
-      return listCached();
-    }
-    return listCached();
+    return res ?? [];
   };
   const create = async (data) => {
     await db.create(new Table(name)).content(data);
@@ -116,24 +57,21 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
     await db.update(id).merge({
       ...data,
       sync_deleted: false,
-      updated_at: /* @__PURE__ */ new Date()
+      updated_at: Date.now()
     });
   };
   const remove = async (id) => {
     await db.delete(id);
-    removeFromCache(id);
   };
   const softDelete = async (id) => {
     if (!useLoro) {
       await db.delete(id);
-      removeFromCache(id);
       return;
     }
     await db.upsert(id).merge({
       sync_deleted: true,
-      updated_at: /* @__PURE__ */ new Date()
+      updated_at: Date.now()
     });
-    removeFromCache(id);
   };
   const subscribe = (cb) => {
     let killed = false;
@@ -141,25 +79,10 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
     const on = (msg) => {
       const { action, value } = msg;
       if (action === "KILLED") return;
-      if (action === "CREATE") {
-        upsertCache([value]);
-        cb({ type: "insert", row: value });
-        return;
-      }
-      if (action === "UPDATE") {
-        if (useLoro && value.sync_deleted) {
-          removeFromCache(value.id);
-          cb({ type: "delete", row: { id: value.id } });
-          return;
-        }
-        upsertCache([value]);
-        cb({ type: "update", row: value });
-        return;
-      }
-      if (action === "DELETE") {
-        removeFromCache(value.id);
+      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 (!db.isFeatureSupported(Features.LiveQueries)) return;
@@ -175,382 +98,169 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
   };
   return {
     listAll,
-    listActive,
-    listCached,
-    fetchPage,
-    fetchById,
-    loadMore,
+    loadSubset,
     create,
     update,
     remove,
     softDelete,
-    subscribe,
-    get isFullyLoaded() {
-      return fullyLoaded;
-    },
-    get cachedCount() {
-      return cache.size;
-    }
+    subscribe
   };
 }
 
 // src/index.ts
-var DEFAULT_INITIAL_PAGE_SIZE = 50;
-var LOCAL_ID_VERIFY_CHUNK = 500;
-var stableStringify = (value) => {
-  const toJson = (v) => {
-    if (v === null) return null;
-    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
-      return v;
-    if (v instanceof Date) return v.toISOString();
-    if (Array.isArray(v)) return v.map(toJson);
-    if (typeof v === "object") {
-      const o = v;
-      const keys = Object.keys(o).sort();
-      const out = {};
-      for (const k of keys) out[k] = toJson(o[k]);
-      return out;
-    }
-    return String(v);
+function toCleanup(res) {
+  if (!res) return () => {
+  };
+  if (typeof res === "function") {
+    return res;
+  }
+  if (typeof res === "object" && res !== null) {
+    const r = res;
+    const cleanup = r["cleanup"];
+    if (typeof cleanup === "function") return cleanup;
+    const unsubscribe = r["unsubscribe"];
+    if (typeof unsubscribe === "function") return unsubscribe;
+    const dispose = r["dispose"];
+    if (typeof dispose === "function") return dispose;
+  }
+  return () => {
   };
-  return JSON.stringify(toJson(value));
-};
-var chunk = (arr, size) => {
-  const out = [];
-  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
-  return out;
-};
+}
 function surrealCollectionOptions({
   id,
   useLoro = false,
   onError,
   db,
-  syncMode,
+  queryClient,
+  queryKey,
+  syncMode = "eager",
   ...config
 }) {
   let loro;
   if (useLoro) loro = { doc: new LoroDoc(), key: id };
+  const table = manageTable(db, useLoro, config.table);
   const keyOf = (rid) => typeof rid === "string" ? rid : rid.toString();
   const getKey = (row) => keyOf(row.id);
   const loroKey = loro?.key ?? id ?? "surreal";
   const loroMap = useLoro ? loro?.doc?.getMap?.(loroKey) ?? null : null;
-  const loroToArray = () => {
-    if (!loroMap) return [];
-    const json = loroMap.toJSON?.() ?? {};
-    return Object.values(json);
-  };
-  const loroPutMany = (rows) => {
-    if (!loroMap || rows.length === 0) return;
-    for (const row of rows) loroMap.set(getKey(row), row);
+  const loroPut = (row) => {
+    if (!loroMap) return;
+    loroMap.set(getKey(row), row);
     loro?.doc?.commit?.();
   };
-  const loroRemoveMany = (ids) => {
-    if (!loroMap || ids.length === 0) return;
-    for (const id2 of ids) loroMap.delete(id2);
+  const loroRemove = (idStr) => {
+    if (!loroMap) return;
+    loroMap.delete(idStr);
     loro?.doc?.commit?.();
   };
-  const loroRemove = (id2) => loroRemoveMany([id2]);
-  const pushQueue = [];
-  const enqueuePush = (op) => {
-    if (!useLoro) return;
-    pushQueue.push(op);
-  };
-  const flushPushQueue = async () => {
-    if (!useLoro) return;
-    const ops = pushQueue.splice(0, pushQueue.length);
-    for (const op of ops) {
-      if (op.kind === "create") {
-        await table.create(op.row);
-      } else if (op.kind === "update") {
-        const rid = new RecordId(
-          config.table.name,
-          op.row.id.toString()
-        );
-        await table.update(rid, op.row);
-      } else {
-        const rid = new RecordId(config.table.name, op.id);
-        await table.softDelete(rid);
-      }
-    }
-  };
-  const newer = (a, b) => (a?.getTime() ?? -1) > (b?.getTime() ?? -1);
-  const fetchServerByLocalIds = async (ids) => {
-    if (ids.length === 0) return [];
-    const tableName = config.table.name;
-    const parts = chunk(ids, LOCAL_ID_VERIFY_CHUNK);
+  const mergeLocalOverServer = (serverRows) => {
+    if (!useLoro || !loroMap) return serverRows;
+    const localJson = loroMap.toJSON?.() ?? {};
+    const localById = new Map(
+      Object.values(localJson).map((r) => [getKey(r), r])
+    );
     const out = [];
-    for (const p of parts) {
-      const [res] = await db.query(
-        "SELECT * FROM type::table($table) WHERE id IN $ids",
-        {
-          table: tableName,
-          ids: p.map((x) => new RecordId(tableName, x))
-        }
-      );
-      if (res) out.push(...res);
-    }
-    return out;
-  };
-  const dedupeById = (rows) => {
-    const m = /* @__PURE__ */ new Map();
-    for (const r of rows) m.set(getKey(r), r);
-    return Array.from(m.values());
-  };
-  let prevById = /* @__PURE__ */ new Map();
-  const buildMap = (rows) => new Map(rows.map((r) => [getKey(r), r]));
-  const same = (a, b) => {
-    if (useLoro) {
-      return (a.sync_deleted ?? false) === (b.sync_deleted ?? false) && (a.updated_at?.getTime() ?? 0) === (b.updated_at?.getTime() ?? 0);
-    }
-    return stableStringify(a) === stableStringify(b);
-  };
-  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 reconcileBoot = (serverRows, write) => {
-    const localRows = 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 toRemove = [];
-    const toPut = [];
-    const applyLocal = (row) => {
-      if (!row) return;
-      if (row.sync_deleted) toRemove.push(getKey(row));
-      else toPut.push(row);
-    };
-    for (const id2 of ids) {
-      const s = serverById.get(id2);
-      const l = localById.get(id2);
-      if (s && l) {
-        const sDeleted = s.sync_deleted ?? false;
-        const lDeleted = l.sync_deleted ?? false;
-        const sUpdated = s.updated_at;
-        const lUpdated = l.updated_at;
-        if (sDeleted && lDeleted) {
-          applyLocal(s);
-          current.push(s);
-        } else if (sDeleted && !lDeleted) {
-          applyLocal(s);
-          current.push(s);
-        } else if (!sDeleted && lDeleted) {
-          if (newer(lUpdated, sUpdated)) {
-            enqueuePush({
-              kind: "delete",
-              id: id2,
-              updated_at: lUpdated ?? /* @__PURE__ */ new Date()
-            });
-            applyLocal(l);
-            current.push(l);
-          } else {
-            applyLocal(s);
-            current.push(s);
-          }
-        } else {
-          if (newer(lUpdated, sUpdated)) {
-            enqueuePush({ kind: "update", 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) {
-        const lDeleted = l.sync_deleted ?? false;
-        const lUpdated = l.updated_at;
-        if (lDeleted) {
-          enqueuePush({
-            kind: "delete",
-            id: id2,
-            updated_at: lUpdated ?? /* @__PURE__ */ new Date()
-          });
-          applyLocal(l);
-          current.push(l);
-        } else {
-          enqueuePush({ kind: "create", row: l });
-          applyLocal(l);
-          current.push(l);
-        }
+    for (const s of serverRows) {
+      const idStr = getKey(s);
+      const l = localById.get(idStr);
+      if (!l) {
+        out.push(s);
+        continue;
       }
+      const lDeleted = (l.sync_deleted ?? false) === true;
+      if (lDeleted) continue;
+      out.push(l);
     }
-    loroRemoveMany(toRemove);
-    loroPutMany(toPut);
-    diffAndEmit(current, write);
+    return out;
   };
-  const table = manageTable(db, useLoro, config.table, syncMode);
-  const now = () => /* @__PURE__ */ new Date();
-  const sync = ({
-    begin,
-    write,
-    commit,
-    markReady
-  }) => {
-    if (!db.isFeatureSupported(Features2.LiveQueries)) {
-      markReady();
-      return () => {
-      };
-    }
-    let offLive = null;
-    let work = Promise.resolve();
-    const enqueueWork = (fn) => {
-      work = work.then(fn).catch((e) => onError?.(e));
-      return work;
-    };
-    const makeTombstone = (id2) => ({
-      id: new RecordId(config.table.name, id2).toString(),
-      updated_at: now(),
-      sync_deleted: true
-    });
-    const start = async () => {
+  const base = queryCollectionOptions({
+    getKey: (row) => getKey(row),
+    queryKey,
+    queryClient,
+    syncMode,
+    queryFn: async ({ meta }) => {
       try {
-        let serverRows;
-        if (syncMode === "eager") {
-          serverRows = await table.listAll();
-        } else if (syncMode === "progressive") {
-          const first = await table.loadMore(
-            config.table.initialPageSize ?? DEFAULT_INITIAL_PAGE_SIZE
-          );
-          serverRows = first.rows;
-        } else {
-          serverRows = await table.listActive();
-        }
-        await enqueueWork(async () => {
-          begin();
-          if (useLoro) {
-            const localIds = loroToArray().map(getKey);
-            const verifiedServerRows = syncMode === "eager" ? serverRows : dedupeById([
-              ...serverRows,
-              ...await fetchServerByLocalIds(
-                localIds
-              )
-            ]);
-            reconcileBoot(verifiedServerRows, write);
-          } else {
-            diffAndEmit(serverRows, write);
-          }
-          commit();
-          markReady();
-        });
-        if (syncMode === "progressive") {
-          void (async () => {
-            while (!table.isFullyLoaded) {
-              const { rows } = await table.loadMore();
-              if (rows.length === 0) break;
-              await enqueueWork(async () => {
-                begin();
-                try {
-                  if (useLoro) loroPutMany(rows);
-                  diffAndEmit(rows, write);
-                } finally {
-                  commit();
-                }
-              });
-            }
-          })().catch((e) => onError?.(e));
-        }
-        await flushPushQueue();
-        offLive = table.subscribe((evt) => {
-          void enqueueWork(async () => {
-            begin();
-            try {
-              if (evt.type === "insert" || evt.type === "update") {
-                const row = evt.row;
-                const deleted = useLoro ? row.sync_deleted ?? false : false;
-                if (deleted) {
-                  if (useLoro) loroRemove(getKey(row));
-                  const prev = prevById.get(getKey(row)) ?? makeTombstone(getKey(row));
-                  write({ type: "delete", value: prev });
-                  prevById.delete(getKey(row));
-                } else {
-                  if (useLoro) loroPutMany([row]);
-                  const had = prevById.has(getKey(row));
-                  write({
-                    type: had ? "update" : "insert",
-                    value: row
-                  });
-                  prevById.set(getKey(row), row);
-                }
-              } else {
-                const rid = getKey(evt.row);
-                if (useLoro) loroRemove(rid);
-                const prev = prevById.get(rid) ?? makeTombstone(rid);
-                write({ type: "delete", value: prev });
-                prevById.delete(rid);
-              }
-            } finally {
-              commit();
-            }
-          });
-        });
+        const subset = syncMode === "on-demand" ? meta["surrealSubset"] : void 0;
+        const rows = syncMode === "eager" ? await table.listAll() : await table.loadSubset(subset);
+        return mergeLocalOverServer(rows);
       } catch (e) {
         onError?.(e);
-        markReady();
+        return [];
       }
-    };
-    void start();
-    return () => {
-      if (offLive) offLive();
-    };
-  };
-  const onInsert = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "insert") continue;
-      const base = { ...m.modified };
-      const row = useLoro ? { ...base, updated_at: now(), sync_deleted: false } : base;
-      if (useLoro) loroPutMany([row]);
-      await table.create(row);
-      resultRows.push(row);
-    }
-    return resultRows;
-  };
-  const onUpdate = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "update") continue;
-      const id2 = m.key;
-      const base = { ...m.modified, id: id2 };
-      const merged = useLoro ? { ...base, updated_at: now() } : base;
-      if (useLoro) loroPutMany([merged]);
-      const rid = new RecordId(config.table.name, keyOf(id2));
-      await table.update(rid, merged);
-      resultRows.push(merged);
-    }
-    return resultRows;
-  };
-  const onDelete = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "delete") continue;
-      const id2 = m.key;
-      if (useLoro) loroRemove(keyOf(id2));
-      await table.softDelete(new RecordId(config.table.name, keyOf(id2)));
+    },
+    onInsert: (async (p) => {
+      const now = () => /* @__PURE__ */ new Date();
+      const resultRows = [];
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "insert") continue;
+        const baseRow = { ...m.modified };
+        const row = useLoro ? {
+          ...baseRow,
+          updated_at: now(),
+          sync_deleted: false
+        } : baseRow;
+        if (useLoro) loroPut(row);
+        await table.create(row);
+        resultRows.push(row);
+      }
+      return resultRows;
+    }),
+    onUpdate: (async (p) => {
+      const now = () => /* @__PURE__ */ new Date();
+      const resultRows = [];
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "update") continue;
+        const idKey = m.key;
+        const baseRow = { ...m.modified, id: idKey };
+        const row = useLoro ? { ...baseRow, updated_at: now() } : baseRow;
+        if (useLoro) loroPut(row);
+        await table.update(
+          new RecordId(config.table.name, keyOf(idKey)),
+          row
+        );
+        resultRows.push(row);
+      }
+      return resultRows;
+    }),
+    onDelete: (async (p) => {
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "delete") continue;
+        const idKey = m.key;
+        if (useLoro) loroRemove(keyOf(idKey));
+        await table.softDelete(
+          new RecordId(config.table.name, keyOf(idKey))
+        );
+      }
+      return [];
+    })
+  });
+  const baseSync = base.sync?.sync;
+  const sync = baseSync ? {
+    sync: (ctx) => {
+      const offBase = baseSync(ctx);
+      if (!db.isFeatureSupported(Features.LiveQueries))
+        return offBase;
+      const offLive = table.subscribe((evt) => {
+        if (useLoro) {
+          if (evt.type === "delete")
+            loroRemove(getKey(evt.row));
+          else loroPut(evt.row);
+        }
+        void queryClient.invalidateQueries({ queryKey, exact: false }).catch((e) => onError?.(e));
+      });
+      const baseCleanup = toCleanup(baseSync(ctx));
+      return () => {
+        offLive();
+        baseCleanup();
+      };
     }
-    return resultRows;
-  };
+  } : void 0;
   return {
-    id,
-    getKey,
-    sync: { sync },
-    onInsert,
-    onDelete,
-    onUpdate
+    ...base,
+    sync: sync ?? base.sync
   };
 }
-export {
-  surrealCollectionOptions
-};
+
+export { surrealCollectionOptions };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map