@raisindb/client 0.2.5 → 0.3.0

package/dist/index.js

@@ -1622,17 +1622,40 @@ var NodeOperations = class {
   // Tree Operations
   // ========================================================================
   /**
-   * List children of a parent node
+   * List children of a parent node, in editorial (drag-and-drop) order.
    *
    * @param parentPath - Path of the parent node
    * @returns Array of child nodes
    */
   async listChildren(parentPath) {
+    const { items } = await this.listChildrenPage(parentPath);
+    return items;
+  }
+  /**
+   * List one page of a parent's children, in editorial order.
+   *
+   * Pagination is keyset-based: pass the previous response's `nextCursor` back as
+   * `cursor` to get the following page. `nextCursor` is `null` on the last page.
+   * Treat the cursor as opaque — do not parse or construct it.
+   *
+   * @param parentPath - Path of the parent node
+   * @param options - `cursor` from a previous page, and page `limit`
+   */
+  async listChildrenPage(parentPath, options = {}) {
     const payload = {
       parent_path: parentPath
     };
+    if (options.cursor !== void 0) payload.cursor = options.cursor;
+    if (options.limit !== void 0) payload.limit = options.limit;
     const result = await this.sendRequest(payload, "node_list_children");
-    return result;
+    if (Array.isArray(result)) {
+      return { items: result, nextCursor: null };
+    }
+    const page = result;
+    return {
+      items: page.nodes ?? [],
+      nextCursor: page.next_cursor == null ? null : JSON.stringify(page.next_cursor)
+    };
   }
   /**
    * Get a node tree starting from a root node
@@ -1740,53 +1763,54 @@ var NodeOperations = class {
     return result;
   }
   /**
-   * Reorder a node by setting a new order key
+   * Move a child to a specific position among its siblings.
    *
-   * @param nodePath - Node path
-   * @param orderKey - New order key (base62-encoded fractional index)
-   * @returns Reordered node
+   * Positions are 0-based; a position past the end appends. The server owns the
+   * fractional order key — you name a position, it mints the key.
+   *
+   * @param parentPath - Parent node path
+   * @param childName - Name of the child to move (not a full path)
+   * @param position - Target 0-based position among the parent's children
+   * @returns The reordered node, carrying its newly assigned `order_key`
    */
-  async reorder(nodePath, orderKey) {
+  async reorder(parentPath, childName, position) {
     const payload = {
-      node_path: nodePath,
-      order_key: orderKey
+      parent_path: parentPath,
+      child_name: childName,
+      position
     };
     const result = await this.sendRequest(payload, "node_reorder");
     return result;
   }
   /**
-   * Move a child node before a reference sibling
+   * Move a child so it sits immediately before one of its siblings.
    *
    * @param parentPath - Parent node path
-   * @param childPath - Child node path to move
-   * @param referencePath - Reference sibling path to position before
-   * @returns Moved node
+   * @param childName - Name of the child to move (not a full path)
+   * @param beforeChildName - Name of the sibling to sit before
    */
-  async moveChildBefore(parentPath, childPath, referencePath) {
+  async moveChildBefore(parentPath, childName, beforeChildName) {
     const payload = {
       parent_path: parentPath,
-      child_path: childPath,
-      reference_path: referencePath
+      child_name: childName,
+      before_child_name: beforeChildName
     };
-    const result = await this.sendRequest(payload, "node_move_child_before");
-    return result;
+    await this.sendRequest(payload, "node_move_child_before");
   }
   /**
-   * Move a child node after a reference sibling
+   * Move a child so it sits immediately after one of its siblings.
    *
    * @param parentPath - Parent node path
-   * @param childPath - Child node path to move
-   * @param referencePath - Reference sibling path to position after
-   * @returns Moved node
+   * @param childName - Name of the child to move (not a full path)
+   * @param afterChildName - Name of the sibling to sit after
    */
-  async moveChildAfter(parentPath, childPath, referencePath) {
+  async moveChildAfter(parentPath, childName, afterChildName) {
     const payload = {
       parent_path: parentPath,
-      child_path: childPath,
-      reference_path: referencePath
+      child_name: childName,
+      after_child_name: afterChildName
     };
-    const result = await this.sendRequest(payload, "node_move_child_after");
-    return result;
+    await this.sendRequest(payload, "node_move_child_after");
   }
   /**
    * Replay a parent's child order from another branch onto the current branch.
@@ -9933,7 +9957,12 @@ var NodeBuilder = class _NodeBuilder {
     return this;
   }
   /**
-   * Set the order key
+   * Set the order key.
+   *
+   * @deprecated The server owns editorial ordering: the order key is assigned by
+   * the ordering index on write, so any value set here is overwritten. To place a
+   * node, create it (it appends to the end of its parent) then call
+   * `nodes.reorder()`, `nodes.moveChildBefore()` or `nodes.moveChildAfter()`.
    */
   orderKey(orderKey) {
     this.node.order_key = orderKey;
@@ -10013,10 +10042,10 @@ var NodeBuilder = class _NodeBuilder {
     if (!this.node.node_type) {
       throw new Error("Node type is required");
     }
+    if (this.node.order_key === void 0) this.node.order_key = "";
     if (!this.node.children) this.node.children = [];
     if (!this.node.relations) this.node.relations = [];
     if (!this.node.properties) this.node.properties = {};
-    if (!this.node.order_key) this.node.order_key = "a";
     if (typeof this.node.version !== "number") this.node.version = 1;
     return this.node;
   }
@@ -10098,8 +10127,8 @@ var NodeHelpers = class {
       node_type: "MockType",
       properties: {},
       children: [],
+      order_key: "",
       relations: [],
-      order_key: "a",
       version: 1,
       ...overrides
     };