@raisindb/client 0.1.18 → 0.1.38

package/dist/index.mjs

@@ -390,6 +390,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["NodeReorder"] = "node_reorder";
   RequestType2["NodeMoveChildBefore"] = "node_move_child_before";
   RequestType2["NodeMoveChildAfter"] = "node_move_child_after";
+  RequestType2["NodeApplyChildOrder"] = "node_apply_child_order";
   RequestType2["PropertyGet"] = "property_get";
   RequestType2["PropertyUpdate"] = "property_update";
   RequestType2["RelationAdd"] = "relation_add";
@@ -409,6 +410,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["BranchUpdateHead"] = "branch_update_head";
   RequestType2["BranchMerge"] = "branch_merge";
   RequestType2["BranchCompare"] = "branch_compare";
+  RequestType2["BranchDiff"] = "branch_diff";
   RequestType2["TagCreate"] = "tag_create";
   RequestType2["TagGet"] = "tag_get";
   RequestType2["TagList"] = "tag_list";
@@ -429,6 +431,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ArchetypeDelete"] = "archetype_delete";
   RequestType2["ArchetypePublish"] = "archetype_publish";
   RequestType2["ArchetypeUnpublish"] = "archetype_unpublish";
+  RequestType2["ArchetypeGetResolved"] = "archetype_get_resolved";
   RequestType2["ElementTypeCreate"] = "element_type_create";
   RequestType2["ElementTypeGet"] = "element_type_get";
   RequestType2["ElementTypeList"] = "element_type_list";
@@ -436,6 +439,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ElementTypeDelete"] = "element_type_delete";
   RequestType2["ElementTypePublish"] = "element_type_publish";
   RequestType2["ElementTypeUnpublish"] = "element_type_unpublish";
+  RequestType2["ElementTypeGetResolved"] = "element_type_get_resolved";
   RequestType2["FullTextSearch"] = "full_text_search";
   RequestType2["VectorSearch"] = "vector_search";
   RequestType2["Subscribe"] = "subscribe";
@@ -904,6 +908,40 @@ var NodeOperations = class {
     const result = await this.sendRequest(payload);
     return result;
   }
+  /**
+   * Create a node, auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Created node
+   */
+  async createDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_create_deep");
+    return result;
+  }
+  /**
+   * Upsert a node by path (create-or-update), auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Upserted node
+   */
+  async upsertDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_upsert_deep");
+    return result;
+  }
   /**
    * Update an existing node
    *
@@ -953,6 +991,75 @@ var NodeOperations = class {
       throw error;
     }
   }
+  /**
+   * List a node's revision history (git-style "file history"), newest first.
+   *
+   * Each entry carries the `revision` (usable with `atRevision()` reads to
+   * fetch the full snapshot), plus when/who and whether the node was deleted
+   * at that revision. Always available regardless of the NodeType `auditable`
+   * flag — it reflects the structural MVCC version history.
+   *
+   * @param id - Node ID
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   *
+   * @example
+   * ```typescript
+   * const history = await ws.nodes().history(nodeId, { limit: 50 });
+   * for (const rev of history) {
+   *   const snapshot = await ws.atRevision(rev.revision).nodes().get(nodeId);
+   * }
+   * ```
+   */
+  async history(id, options) {
+    const payload = {
+      node_id: id,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * List a node's revision history by path (newest first).
+   *
+   * @param path - Node path
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   */
+  async historyByPath(path, options) {
+    const payload = {
+      path,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by ID.
+   *
+   * Audit logs are only produced for NodeTypes marked `auditable`. This is
+   * distinct from {@link history}, which is the always-on structural revision
+   * history available for every node.
+   *
+   * @param id - Node ID
+   * @returns Array of audit-log entries
+   */
+  async auditLog(id) {
+    const payload = { node_id: id };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by path.
+   *
+   * @param path - Node path
+   * @returns Array of audit-log entries
+   */
+  async auditLogByPath(path) {
+    const payload = { path };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
   /**
    * Query nodes
    *
@@ -1120,7 +1227,7 @@ var NodeOperations = class {
    */
   async rename(nodePath, newName) {
     const payload = {
-      node_path: nodePath,
+      old_path: nodePath,
       new_name: newName
     };
     const result = await this.sendRequest(payload, "node_rename");
@@ -1136,9 +1243,8 @@ var NodeOperations = class {
    */
   async copy(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: false
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1156,9 +1262,8 @@ var NodeOperations = class {
    */
   async copyTree(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: true
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1215,6 +1320,24 @@ var NodeOperations = class {
     const result = await this.sendRequest(payload, "node_move_child_after");
     return result;
   }
+  /**
+   * Replay a parent's child order from another branch onto the current branch.
+   *
+   * Carries node sibling-order across branches — useful for selective publish
+   * flows, where copying node content (e.g. via SQL) does not move the ordering
+   * index. Only children that exist under the parent on both branches are
+   * reordered. The target branch is the connection's current branch.
+   *
+   * @param parentPath - Parent node path
+   * @param sourceBranch - Branch to copy the child order FROM
+   */
+  async applyChildOrder(parentPath, sourceBranch) {
+    const payload = {
+      parent_path: parentPath,
+      source_branch: sourceBranch
+    };
+    await this.sendRequest(payload, "node_apply_child_order");
+  }
   // ========================================================================
   // Relationship Operations
   // ========================================================================
@@ -2300,6 +2423,17 @@ var Archetypes = class {
       "archetype_unpublish" /* ArchetypeUnpublish */
     );
   }
+  /**
+   * Get resolved Archetype with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "archetype_get_resolved" /* ArchetypeGetResolved */
+    );
+  }
 };
 
 // src/element-types.ts
@@ -2387,6 +2521,17 @@ var ElementTypes = class {
       "element_type_unpublish" /* ElementTypeUnpublish */
     );
   }
+  /**
+   * Get resolved ElementType with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "element_type_get_resolved" /* ElementTypeGetResolved */
+    );
+  }
 };
 
 // src/branches.ts
@@ -2488,6 +2633,21 @@ var Branches = class {
       "branch_compare" /* BranchCompare */
     );
   }
+  /**
+   * Per-node diff of `branch` relative to `baseBranch` (added/modified/deleted).
+   *
+   * Cheaper than reading both branch listings: cost scales with the number of
+   * changed nodes since the branches diverged, not the total content.
+   */
+  async diff(branch, baseBranch) {
+    return this.sendRequest(
+      {
+        branch,
+        base_branch: baseBranch
+      },
+      "branch_diff" /* BranchDiff */
+    );
+  }
 };
 
 // src/tags.ts
@@ -5236,6 +5396,107 @@ var UploadManager = class {
   }
 };
 
+// src/http-schema.ts
+var HttpSchemaBase = class {
+  constructor(repository, branch, client) {
+    this.repository = repository;
+    this.branch = branch;
+    this.client = client;
+  }
+  /** Base management URL for this schema kind. */
+  base() {
+    return `/api/management/${this.repository}/${this.branch}/${this.kind}`;
+  }
+  /** List all schemas (or only published ones). */
+  async list(publishedOnly = false) {
+    const path = publishedOnly ? `${this.base()}/published` : this.base();
+    const result = await this.client.managementRequest("GET", path);
+    return Array.isArray(result) ? result : [];
+  }
+  /** Get a single schema by name. */
+  async get(name) {
+    return this.client.managementRequest("GET", `${this.base()}/${encodeURIComponent(name)}`);
+  }
+  /** Get the schema with full inheritance (`extends`) applied. */
+  async getResolved(name) {
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved`
+    );
+  }
+  /** Create a schema. `name` is folded into the definition body if absent. */
+  async create(name, definition, commit) {
+    return this.client.managementRequest("POST", this.base(), {
+      [this.defField]: { name, ...definition },
+      commit
+    });
+  }
+  /** Update an existing schema. */
+  async update(name, definition, commit) {
+    return this.client.managementRequest(
+      "PUT",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      { [this.defField]: { name, ...definition }, commit }
+    );
+  }
+  /** Delete a schema. */
+  async delete(name, commit) {
+    return this.client.managementRequest(
+      "DELETE",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      commit
+    );
+  }
+  /** Publish a schema. */
+  async publish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/publish`,
+      commit
+    );
+  }
+  /** Unpublish a schema. */
+  async unpublish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/unpublish`,
+      commit
+    );
+  }
+};
+var HttpNodeTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "nodetypes";
+    this.defField = "node_type";
+  }
+  /**
+   * Get the resolved NodeType. Unlike archetypes/element types, NodeType
+   * resolution can be workspace-aware (honors workspace NodeType pins).
+   */
+  async getResolved(name, opts) {
+    const query = opts?.workspace ? `?workspace=${encodeURIComponent(opts.workspace)}` : "";
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved${query}`
+    );
+  }
+};
+var HttpArchetypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "archetypes";
+    this.defField = "archetype";
+  }
+};
+var HttpElementTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "elementtypes";
+    this.defField = "element_type";
+  }
+};
+
 // src/http-client.ts
 var RaisinHttpClient = class extends EventEmitter {
   constructor(baseUrl, options = {}) {
@@ -5935,6 +6196,17 @@ var RaisinHttpClient = class extends EventEmitter {
     });
     return response.data;
   }
+  /**
+   * Make a management REST request and return the parsed body.
+   *
+   * @internal Used by the HTTP schema-management helpers
+   * ({@link HttpNodeTypes}/{@link HttpArchetypes}/{@link HttpElementTypes}) to
+   * reuse the client's centralized auth, timeout, and base-URL handling.
+   */
+  async managementRequest(method, path, body) {
+    const response = await this.request({ method, path, body });
+    return response.data;
+  }
   /**
    * Get a simplified database interface for SSR
    * This returns an HTTP-based database client
@@ -6022,6 +6294,22 @@ var HttpDatabase = class _HttpDatabase {
       (repo, name, input) => this.client.invokeFunctionSync(repo, name, input)
     );
   }
+  /** Effective branch for management calls. */
+  schemaBranch() {
+    return this.branch ?? this.client.getBranch();
+  }
+  /** NodeType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  nodeTypes() {
+    return new HttpNodeTypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** Archetype management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  archetypes() {
+    return new HttpArchetypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** ElementType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  elementTypes() {
+    return new HttpElementTypes(this.repository, this.schemaBranch(), this.client);
+  }
 };
 var HttpWorkspaceClient = class {
   constructor(repository, workspace, client) {
@@ -8280,8 +8568,11 @@ export {
   FlowClient,
   FlowsApi,
   FunctionsApi,
+  HttpArchetypes,
   HttpDatabase,
+  HttpElementTypes,
   HttpFunctionsApi,
+  HttpNodeTypes,
   HttpWorkspaceClient,
   InboxApi,
   LocalStorageTokenStorage,