@liveblocks/server 1.5.0-rc1 → 1.5.0-rc2

package/dist/index.cjs

@@ -1640,21 +1640,17 @@ var Storage = class {
     }
   }
   async createChildAsListItem(op2, node) {
-    let fix;
     const intent2 = _nullishCoalesce(op2.intent, () => ( "insert"));
     if (intent2 === "insert") {
-      const insertedParentKey = await this.insertIntoList(op2.id, node);
-      if (insertedParentKey !== node.parentKey) {
-        op2 = { ...op2, parentKey: insertedParentKey };
-        fix = {
-          type: _core.OpCode.SET_PARENT_KEY,
-          id: op2.id,
-          parentKey: insertedParentKey
-        };
-        return accept(op2, fix);
-      }
-      return accept(op2);
+      return this.acceptAndFix(
+        op2,
+        node,
+        await this.insertIntoList(op2.id, node)
+      );
+    } else if (intent2 === "push") {
+      return this.acceptAndFix(op2, node, await this.appendToList(op2.id, node));
     } else if (intent2 === "set") {
+      let fix;
       const deletedId = op2.deletedId !== void 0 && op2.deletedId !== op2.id && _optionalChain([this, 'access', _47 => _47.loadedDriver, 'access', _48 => _48.get_node, 'call', _49 => _49(op2.deletedId), 'optionalAccess', _50 => _50.parentId]) === node.parentId ? op2.deletedId : void 0;
       if (deletedId !== void 0) {
         await this.loadedDriver.delete_node(deletedId);
@@ -1671,28 +1667,24 @@ var Storage = class {
       }
       await this.loadedDriver.set_child(op2.id, node, true);
       return accept(op2, fix);
-    } else if (intent2 === "push") {
-      const lastPos = this.loadedDriver.get_last_sibling(node.parentId);
-      const guessedKey = _core.asPos.call(void 0, node.parentKey);
-      const pushedKey = lastPos === void 0 || guessedKey > lastPos ? guessedKey : _core.makePosition.call(void 0, lastPos);
-      await this.loadedDriver.set_child(op2.id, {
-        ...node,
-        parentKey: pushedKey
-      });
-      if (pushedKey !== node.parentKey) {
-        op2 = { ...op2, parentKey: pushedKey };
-        fix = {
-          type: _core.OpCode.SET_PARENT_KEY,
-          id: op2.id,
-          parentKey: pushedKey
-        };
-        return accept(op2, fix);
-      }
-      return accept(op2);
     } else {
       return _core.assertNever.call(void 0, intent2, "Invalid intent");
     }
   }
+  /**
+   * Accept a freshly placed list item. If the server chose a different
+   * position in the end (conflict resolution), broadcast only the corrected Op
+   * to all clients and send a "fix" op back to the originating client.
+   */
+  acceptAndFix(op2, node, finalKey) {
+    if (finalKey !== node.parentKey) {
+      return accept(
+        { ...op2, parentKey: finalKey },
+        { type: _core.OpCode.SET_PARENT_KEY, id: op2.id, parentKey: finalKey }
+      );
+    }
+    return accept(op2);
+  }
   async applyDeleteObjectKeyOp(op2) {
     await this.loadedDriver.delete_child_key(op2.id, op2.key);
     return accept(op2);
@@ -1738,6 +1730,26 @@ var Storage = class {
     await this.loadedDriver.set_child(id, node);
     return node.parentKey;
   }
+  /**
+   * Server-authoritative append: places the node strictly after every existing
+   * sibling under its list parent. If the client's preferred key already sorts
+   * after the current last sibling it's kept as-is (guaranteed free, since
+   * it's beyond the max); otherwise the node is placed right after the last
+   * sibling. Because Ops are processed serially, the chosen key is always
+   * free, so concurrent pushes never collide.
+   *
+   * Returns the final key that was used for the insertion.
+   */
+  async appendToList(id, node) {
+    const lastPos = this.loadedDriver.get_last_sibling(node.parentId);
+    const preferredPos = _core.asPos.call(void 0, node.parentKey);
+    const finalKey = lastPos === void 0 || preferredPos > lastPos ? preferredPos : _core.makePosition.call(void 0, lastPos);
+    await this.loadedDriver.set_child(
+      id,
+      finalKey !== node.parentKey ? { ...node, parentKey: finalKey } : node
+    );
+    return finalKey;
+  }
   /**
    * Tries to move a node to the given position under the same parent. If
    * a conflicting sibling node already exist at this position, it will use