@symbo.ls/sdk 2.31.37 → 2.32.1

package/dist/esm/utils/CollabClient.js

@@ -9166,7 +9166,7 @@ var require_dexie = __commonJS({
           });
         }
       }
-      var DEXIE_VERSION = "4.2.0";
+      var DEXIE_VERSION = "4.2.1";
       var maxString = String.fromCharCode(65535);
       var minKey = -Infinity;
       var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -9291,6 +9291,73 @@ var require_dexie = __commonJS({
           return res;
         });
       }
+      var PropModification2 = (function() {
+        function PropModification3(spec) {
+          this["@@propmod"] = spec;
+        }
+        PropModification3.prototype.execute = function(value2) {
+          var _a2;
+          var spec = this["@@propmod"];
+          if (spec.add !== void 0) {
+            var term = spec.add;
+            if (isArray2(term)) {
+              return __spreadArray(__spreadArray([], isArray2(value2) ? value2 : [], true), term, true).sort();
+            }
+            if (typeof term === "number")
+              return (Number(value2) || 0) + term;
+            if (typeof term === "bigint") {
+              try {
+                return BigInt(value2) + term;
+              } catch (_b) {
+                return BigInt(0) + term;
+              }
+            }
+            throw new TypeError("Invalid term ".concat(term));
+          }
+          if (spec.remove !== void 0) {
+            var subtrahend_1 = spec.remove;
+            if (isArray2(subtrahend_1)) {
+              return isArray2(value2) ? value2.filter(function(item) {
+                return !subtrahend_1.includes(item);
+              }).sort() : [];
+            }
+            if (typeof subtrahend_1 === "number")
+              return Number(value2) - subtrahend_1;
+            if (typeof subtrahend_1 === "bigint") {
+              try {
+                return BigInt(value2) - subtrahend_1;
+              } catch (_c) {
+                return BigInt(0) - subtrahend_1;
+              }
+            }
+            throw new TypeError("Invalid subtrahend ".concat(subtrahend_1));
+          }
+          var prefixToReplace = (_a2 = spec.replacePrefix) === null || _a2 === void 0 ? void 0 : _a2[0];
+          if (prefixToReplace && typeof value2 === "string" && value2.startsWith(prefixToReplace)) {
+            return spec.replacePrefix[1] + value2.substring(prefixToReplace.length);
+          }
+          return value2;
+        };
+        return PropModification3;
+      })();
+      function applyUpdateSpec(obj, changes) {
+        var keyPaths = keys2(changes);
+        var numKeys = keyPaths.length;
+        var anythingModified = false;
+        for (var i = 0; i < numKeys; ++i) {
+          var keyPath = keyPaths[i];
+          var value2 = changes[keyPath];
+          var origValue = getByKeyPath(obj, keyPath);
+          if (value2 instanceof PropModification2) {
+            setByKeyPath(obj, keyPath, value2.execute(origValue));
+            anythingModified = true;
+          } else if (origValue !== value2) {
+            setByKeyPath(obj, keyPath, value2);
+            anythingModified = true;
+          }
+        }
+        return anythingModified;
+      }
       var Table = (function() {
         function Table2() {
         }
@@ -9486,6 +9553,28 @@ var require_dexie = __commonJS({
             return lastResult;
           });
         };
+        Table2.prototype.upsert = function(key, modifications) {
+          var _this = this;
+          var keyPath = this.schema.primKey.keyPath;
+          return this._trans("readwrite", function(trans) {
+            return _this.core.get({ trans, key }).then(function(existing) {
+              var obj = existing !== null && existing !== void 0 ? existing : {};
+              applyUpdateSpec(obj, modifications);
+              if (keyPath)
+                setByKeyPath(obj, keyPath, key);
+              return _this.core.mutate({
+                trans,
+                type: "put",
+                values: [obj],
+                keys: [key],
+                upsert: true,
+                updates: { keys: [key], changeSpecs: [modifications] }
+              }).then(function(res) {
+                return res.numFailures ? DexiePromise.reject(res.failures[0]) : !!existing;
+              });
+            });
+          });
+        };
         Table2.prototype.update = function(keyOrObject, modifications) {
           if (typeof keyOrObject === "object" && !isArray2(keyOrObject)) {
             var key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
@@ -9848,55 +9937,6 @@ var require_dexie = __commonJS({
           }
         });
       }
-      var PropModification2 = (function() {
-        function PropModification3(spec) {
-          this["@@propmod"] = spec;
-        }
-        PropModification3.prototype.execute = function(value2) {
-          var _a2;
-          var spec = this["@@propmod"];
-          if (spec.add !== void 0) {
-            var term = spec.add;
-            if (isArray2(term)) {
-              return __spreadArray(__spreadArray([], isArray2(value2) ? value2 : [], true), term, true).sort();
-            }
-            if (typeof term === "number")
-              return (Number(value2) || 0) + term;
-            if (typeof term === "bigint") {
-              try {
-                return BigInt(value2) + term;
-              } catch (_b) {
-                return BigInt(0) + term;
-              }
-            }
-            throw new TypeError("Invalid term ".concat(term));
-          }
-          if (spec.remove !== void 0) {
-            var subtrahend_1 = spec.remove;
-            if (isArray2(subtrahend_1)) {
-              return isArray2(value2) ? value2.filter(function(item) {
-                return !subtrahend_1.includes(item);
-              }).sort() : [];
-            }
-            if (typeof subtrahend_1 === "number")
-              return Number(value2) - subtrahend_1;
-            if (typeof subtrahend_1 === "bigint") {
-              try {
-                return BigInt(value2) - subtrahend_1;
-              } catch (_c) {
-                return BigInt(0) - subtrahend_1;
-              }
-            }
-            throw new TypeError("Invalid subtrahend ".concat(subtrahend_1));
-          }
-          var prefixToReplace = (_a2 = spec.replacePrefix) === null || _a2 === void 0 ? void 0 : _a2[0];
-          if (prefixToReplace && typeof value2 === "string" && value2.startsWith(prefixToReplace)) {
-            return spec.replacePrefix[1] + value2.substring(prefixToReplace.length);
-          }
-          return value2;
-        };
-        return PropModification3;
-      })();
       var Collection = (function() {
         function Collection2() {
         }
@@ -10176,23 +10216,8 @@ var require_dexie = __commonJS({
             if (typeof changes === "function") {
               modifyer = changes;
             } else {
-              var keyPaths = keys2(changes);
-              var numKeys = keyPaths.length;
               modifyer = function(item) {
-                var anythingModified = false;
-                for (var i = 0; i < numKeys; ++i) {
-                  var keyPath = keyPaths[i];
-                  var val = changes[keyPath];
-                  var origVal = getByKeyPath(item, keyPath);
-                  if (val instanceof PropModification2) {
-                    setByKeyPath(item, keyPath, val.execute(origVal));
-                    anythingModified = true;
-                  } else if (origVal !== val) {
-                    setByKeyPath(item, keyPath, val);
-                    anythingModified = true;
-                  }
-                }
-                return anythingModified;
+                return applyUpdateSpec(item, changes);
               };
             }
             var coreTable = ctx.table.core;
@@ -12196,8 +12221,8 @@ var require_dexie = __commonJS({
                 state.vcFired = true;
                 db.on("versionchange").fire(ev);
               });
-              idbdb.onclose = wrap(function(ev) {
-                db.on("close").fire(ev);
+              idbdb.onclose = wrap(function() {
+                db.close({ disableAutoOpen: false });
               });
               if (wasCreated)
                 _onDatabaseCreated(db._deps, dbName);

package/dist/esm/utils/ordering.js

@@ -0,0 +1,258 @@
+// src/utils/ordering.js
+function isObjectLike(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function normalizePath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (typeof path === "string") {
+    return [path];
+  }
+  return [];
+}
+function getParentPathsFromTuples(tuples = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const parents = [];
+  const META_KEYS = /* @__PURE__ */ new Set([
+    "style",
+    "class",
+    "text",
+    "html",
+    "content",
+    "data",
+    "attr",
+    "state",
+    "scope",
+    "props",
+    "define",
+    "on",
+    "extend",
+    "extends",
+    "childExtend",
+    "childExtends",
+    "childProps",
+    "children",
+    "component",
+    "context",
+    "tag",
+    "key",
+    "__order",
+    "if"
+  ]);
+  for (let i = 0; i < tuples.length; i++) {
+    const tuple = tuples[i];
+    if (!Array.isArray(tuple) || tuple.length < 2) {
+      continue;
+    }
+    const path = normalizePath(tuple[1]);
+    if (!path.length) {
+      continue;
+    }
+    if (path[0] === "schema") {
+      continue;
+    }
+    const immediateParent = path.slice(0, -1);
+    if (immediateParent.length) {
+      const key = JSON.stringify(immediateParent);
+      if (!seen.has(key)) {
+        seen.add(key);
+        parents.push(immediateParent);
+      }
+    }
+    const last = path[path.length - 1];
+    if (META_KEYS.has(last) && path.length >= 2) {
+      const containerParent = path.slice(0, -2);
+      if (containerParent.length) {
+        const key2 = JSON.stringify(containerParent);
+        if (!seen.has(key2)) {
+          seen.add(key2);
+          parents.push(containerParent);
+        }
+      }
+    }
+    for (let j = 0; j < path.length; j++) {
+      const seg = path[j];
+      if (!META_KEYS.has(seg)) {
+        continue;
+      }
+      const containerParent2 = path.slice(0, j);
+      if (!containerParent2.length) {
+        continue;
+      }
+      const key3 = JSON.stringify(containerParent2);
+      if (!seen.has(key3)) {
+        seen.add(key3);
+        parents.push(containerParent2);
+      }
+    }
+  }
+  return parents;
+}
+function computeOrdersFromState(root, parentPaths = []) {
+  if (!root || typeof root.getByPath !== "function") {
+    return [];
+  }
+  const orders = [];
+  const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+  for (let i = 0; i < parentPaths.length; i++) {
+    const parentPath = parentPaths[i];
+    const obj = (() => {
+      try {
+        return root.getByPath(parentPath);
+      } catch {
+        return null;
+      }
+    })();
+    if (!isObjectLike(obj)) {
+      continue;
+    }
+    const keys = Object.keys(obj).filter((k) => !EXCLUDE_KEYS.has(k));
+    orders.push({ path: parentPath, keys });
+  }
+  return orders;
+}
+function normaliseSchemaCode(code) {
+  if (typeof code !== "string" || !code.length) {
+    return "";
+  }
+  return code.replaceAll("/////n", "\n").replaceAll("/////tilde", "`");
+}
+function parseExportedObject(code) {
+  const src = normaliseSchemaCode(code);
+  if (!src) {
+    return null;
+  }
+  const body = src.replace(/^\s*export\s+default\s*/u, "return ");
+  try {
+    return new Function(body)();
+  } catch {
+    return null;
+  }
+}
+function extractTopLevelKeysFromCode(code) {
+  const obj = parseExportedObject(code);
+  if (!obj || typeof obj !== "object") {
+    return [];
+  }
+  return Object.keys(obj);
+}
+function computeOrdersForTuples(root, tuples = []) {
+  const pendingChildrenByContainer = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path] = t;
+    const p = normalizePath(path);
+    if (!Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] === "schema") {
+      continue;
+    }
+    const [typeName, containerKey, childKey] = p;
+    const containerPath = [typeName, containerKey];
+    const key = JSON.stringify(containerPath);
+    if (!pendingChildrenByContainer.has(key)) {
+      pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
+    }
+    if (action === "update" || action === "set") {
+      pendingChildrenByContainer.get(key).add(childKey);
+    }
+  }
+  const preferredOrderMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const p = normalizePath(path);
+    if (action !== "update" || !Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] !== "schema") {
+      continue;
+    }
+    const [, type, key] = p;
+    const containerPath = [type, key];
+    const uses = value && Array.isArray(value.uses) ? value.uses : null;
+    const code = value && value.code;
+    const obj = (() => {
+      try {
+        return root && typeof root.getByPath === "function" ? root.getByPath(containerPath) : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!obj) {
+      continue;
+    }
+    const present = new Set(Object.keys(obj));
+    const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+    const codeKeys = extractTopLevelKeysFromCode(code);
+    let resolved = [];
+    const pendingKey = JSON.stringify(containerPath);
+    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || /* @__PURE__ */ new Set();
+    const eligible = /* @__PURE__ */ new Set([...present, ...pendingChildren]);
+    if (Array.isArray(codeKeys) && codeKeys.length) {
+      resolved = codeKeys.filter((k) => eligible.has(k) && !EXCLUDE_KEYS.has(k));
+    }
+    if (Array.isArray(uses) && uses.length) {
+      for (let u = 0; u < uses.length; u++) {
+        const keyName = uses[u];
+        if (eligible.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
+          resolved.push(keyName);
+        }
+      }
+    }
+    if (pendingChildren.size) {
+      for (const child of pendingChildren) {
+        if (!EXCLUDE_KEYS.has(child) && !resolved.includes(child)) {
+          resolved.push(child);
+        }
+      }
+    }
+    if (resolved.length) {
+      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved });
+    }
+  }
+  const parents = getParentPathsFromTuples(tuples);
+  const orders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferredOrderMap.forEach((v) => {
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      orders.push(v);
+    }
+  });
+  const fallbackOrders = computeOrdersFromState(root, parents);
+  for (let i = 0; i < fallbackOrders.length; i++) {
+    const v = fallbackOrders[i];
+    const k = JSON.stringify(v.path);
+    if (seen.has(k)) {
+      continue;
+    }
+    const pending = pendingChildrenByContainer.get(k);
+    if (pending && pending.size) {
+      const existing = new Set(v.keys);
+      for (const child of pending) {
+        if (existing.has(child)) {
+          continue;
+        }
+        v.keys.push(child);
+      }
+    }
+    seen.add(k);
+    orders.push(v);
+  }
+  return orders;
+}
+export {
+  computeOrdersForTuples,
+  computeOrdersFromState,
+  getParentPathsFromTuples
+};

package/dist/node/services/CollabService.js

@@ -4,6 +4,8 @@ import { RootStateManager } from "../state/RootStateManager.js";
 import { rootBus } from "../state/rootEventBus.js";
 import { validateParams } from "../utils/validation.js";
 import { deepStringifyFunctions } from "@domql/utils";
+import { diffJson } from "../utils/jsonDiff.js";
+import { computeOrdersForTuples } from "../utils/ordering.js";
 class CollabService extends BaseService {
   constructor(config) {
     super(config);
@@ -103,53 +105,49 @@ class CollabService extends BaseService {
     if (this._client) {
       await this.disconnect();
     }
-    try {
-      this._client = new CollabClient({
-        jwt,
-        projectId,
-        branch,
-        live: Boolean(pro)
-      });
-      await new Promise((resolve) => {
-        var _a2, _b2;
-        if ((_a2 = this._client.socket) == null ? void 0 : _a2.connected) {
-          resolve();
-        } else {
-          (_b2 = this._client.socket) == null ? void 0 : _b2.once("connect", resolve);
-        }
-      });
-      (_b = this._client.socket) == null ? void 0 : _b.on("ops", ({ changes }) => {
-        console.log(`ops event`);
-        this._stateManager.applyChanges(changes, { fromSocket: true });
-      });
-      (_c = this._client.socket) == null ? void 0 : _c.on("commit", ({ version }) => {
-        if (version) {
-          this._stateManager.setVersion(version);
-        }
-        rootBus.emit("checkpoint:done", { version, origin: "auto" });
-      });
-      (_d = this._client.socket) == null ? void 0 : _d.on("clients", this._handleClientsEvent.bind(this));
-      (_e = this._client.socket) == null ? void 0 : _e.on(
-        "bundle:done",
-        this._handleBundleDoneEvent.bind(this)
-      );
-      (_f = this._client.socket) == null ? void 0 : _f.on(
-        "bundle:error",
-        this._handleBundleErrorEvent.bind(this)
-      );
-      if (this._pendingOps.length) {
-        console.log(
-          `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
-        );
-        this._pendingOps.forEach(({ tuples }) => {
-          this.socket.emit("ops", { changes: tuples, ts: Date.now() });
-        });
-        this._pendingOps.length = 0;
+    this._client = new CollabClient({
+      jwt,
+      projectId,
+      branch,
+      live: Boolean(pro)
+    });
+    await new Promise((resolve) => {
+      var _a2, _b2;
+      if ((_a2 = this._client.socket) == null ? void 0 : _a2.connected) {
+        resolve();
+      } else {
+        (_b2 = this._client.socket) == null ? void 0 : _b2.once("connect", resolve);
       }
-      this._connected = true;
-    } catch (err) {
-      throw err;
+    });
+    (_b = this._client.socket) == null ? void 0 : _b.on("ops", ({ changes }) => {
+      console.log(`ops event`);
+      this._stateManager.applyChanges(changes, { fromSocket: true });
+    });
+    (_c = this._client.socket) == null ? void 0 : _c.on("commit", ({ version }) => {
+      if (version) {
+        this._stateManager.setVersion(version);
+      }
+      rootBus.emit("checkpoint:done", { version, origin: "auto" });
+    });
+    (_d = this._client.socket) == null ? void 0 : _d.on("clients", this._handleClientsEvent.bind(this));
+    (_e = this._client.socket) == null ? void 0 : _e.on(
+      "bundle:done",
+      this._handleBundleDoneEvent.bind(this)
+    );
+    (_f = this._client.socket) == null ? void 0 : _f.on(
+      "bundle:error",
+      this._handleBundleErrorEvent.bind(this)
+    );
+    if (this._pendingOps.length) {
+      console.log(
+        `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
+      );
+      this._pendingOps.forEach(({ changes, orders }) => {
+        this.socket.emit("ops", { changes, orders, ts: Date.now() });
+      });
+      this._pendingOps.length = 0;
     }
+    this._connected = true;
   }
   disconnect() {
     var _a;
@@ -187,24 +185,128 @@ class CollabService extends BaseService {
   }
   /* ---------- data helpers ---------- */
   updateData(tuples, options = {}) {
-    var _a;
+    var _a, _b;
     this._ensureStateManager();
     const { isUndo = false, isRedo = false } = options;
     if (!isUndo && !isRedo && !this._isUndoRedo) {
       this._trackForUndo(tuples, options);
     }
+    const processedTuples = (() => {
+      var _a2;
+      try {
+        const root = (_a2 = this._stateManager) == null ? void 0 : _a2.root;
+        const isPlainObject = (o) => o && typeof o === "object" && !Array.isArray(o);
+        const getByPath = (state2, path) => {
+          if (!state2 || typeof state2.getByPath !== "function") {
+            return null;
+          }
+          try {
+            return state2.getByPath(path);
+          } catch {
+            return null;
+          }
+        };
+        const expandTuple = (t) => {
+          const [action, path, value] = t || [];
+          const isSchemaPath = Array.isArray(path) && path[0] === "schema";
+          if (action === "delete" || isSchemaPath) {
+            return [t];
+          }
+          const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2) && isPlainObject(value);
+          if (!canConsiderExpansion) {
+            return [t];
+          }
+          const prev = getByPath(root, path) || {};
+          const next = value || {};
+          if (!isPlainObject(prev) || !isPlainObject(next)) {
+            return [t];
+          }
+          const ops = diffJson(prev, next, []);
+          if (!ops.length) {
+            return [];
+          }
+          const arr = [];
+          for (let j = 0; j < ops.length; j++) {
+            const op = ops[j];
+            const fullPath = [...path, ...op.path];
+            const last = fullPath[fullPath.length - 1];
+            if (op.action === "set") {
+              arr.push(["update", fullPath, op.value]);
+            } else if (op.action === "del") {
+              if (last !== "__order") {
+                arr.push(["delete", fullPath]);
+              }
+            }
+          }
+          return arr;
+        };
+        const minimizeTuples = (inputTuples) => {
+          const out = [];
+          for (let i = 0; i < inputTuples.length; i++) {
+            const expanded = expandTuple(inputTuples[i]);
+            for (let k = 0; k < expanded.length; k++) {
+              const tuple = expanded[k];
+              const isDelete = Array.isArray(tuple) && tuple[0] === "delete";
+              const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === "__order";
+              if (!isOrderKey) {
+                out.push(tuple);
+              }
+            }
+          }
+          console.log(`Minimized tuples`, out);
+          return out;
+        };
+        console.log(`Processing tuples`, tuples);
+        return minimizeTuples(tuples);
+      } catch (err) {
+        console.warn(
+          "[CollabService] Minimal diff expansion failed \u2013 using original tuples",
+          err
+        );
+        return tuples;
+      }
+    })();
     if (options.append && options.append.length) {
-      tuples.push(...options.append);
+      processedTuples.push(...options.append);
     }
     this._stateManager.applyChanges(tuples, { ...options });
-    tuples = deepStringifyFunctions(tuples, []);
+    const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const el = state == null ? void 0 : state.__element;
+    const orders = computeOrdersForTuples(state, processedTuples);
+    const stringifiedGranularTuples = (el == null ? void 0 : el.call) ? el.call(
+      "deepStringifyFunctions",
+      processedTuples,
+      Array.isArray(processedTuples) ? [] : {}
+    ) : deepStringifyFunctions(
+      processedTuples,
+      Array.isArray(processedTuples) ? [] : {}
+    );
+    const stringifiedTuples = (el == null ? void 0 : el.call) ? el.call(
+      "deepStringifyFunctions",
+      tuples,
+      Array.isArray(tuples) ? [] : {}
+    ) : deepStringifyFunctions(
+      tuples,
+      Array.isArray(tuples) ? [] : {}
+    );
     if (!this.isConnected()) {
       console.warn("[CollabService] Not connected, queuing real-time update");
-      this._pendingOps.push({ tuples, options });
+      this._pendingOps.push({ changes: stringifiedTuples, granularChanges: stringifiedGranularTuples, orders, options });
       return;
     }
-    if ((_a = this.socket) == null ? void 0 : _a.connected) {
-      this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+    if ((_b = this.socket) == null ? void 0 : _b.connected) {
+      console.log("[CollabService] Sending operations to the backend", {
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        ts: Date.now()
+      });
+      this.socket.emit("ops", {
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        ts: Date.now()
+      });
     }
     return { success: true };
   }