@multiplatform.one/frappe 6.0.0

package/dist/cjs/db.cjs

@@ -0,0 +1,355 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var db_exports = {};
+__export(db_exports, {
+  DbModule: () => DbModule,
+  TreeDbModule: () => TreeDbModule
+});
+module.exports = __toCommonJS(db_exports);
+var import_types = require("./sync/types.cjs");
+const log = console;
+function buildEndpoints(appName, customEndpoints = {}) {
+  const prefix = appName ? `${appName}.api` : "live.live.api";
+  return {
+    createDoc: customEndpoints.createDoc || `${prefix}.create_doc`,
+    updateDoc: customEndpoints.updateDoc || `${prefix}.update_doc`,
+    deleteDoc: customEndpoints.deleteDoc || `${prefix}.delete_doc`,
+    backfill: customEndpoints.backfill || `${prefix}.backfill`,
+    getListWithCursor: customEndpoints.getListWithCursor || `${prefix}.get_list_with_cursor`,
+    batchMutations: customEndpoints.batchMutations || `${prefix}.batch_mutations`,
+    listSince: customEndpoints.listSince || `${prefix}.list_since`
+  };
+}
+class DbModule {
+  constructor(http, config = {}) {
+    this.http = http;
+    this.appName = config.appName;
+    this.endpoints = buildEndpoints(config.appName, config.customEndpoints);
+  }
+  http;
+  endpoints;
+  appName;
+  /**
+   * Get the configured app name
+   */
+  getAppName() {
+    return this.appName;
+  }
+  /**
+   * Get configured endpoints
+   */
+  getEndpoints() {
+    return {
+      ...this.endpoints
+    };
+  }
+  async getDoc(doctype, name) {
+    const res = await this.http.get(`/api/resource/${encodeURIComponent(doctype)}/${encodeURIComponent(name)}`);
+    return res.payload.data;
+  }
+  async getDocVersion(doctype, name) {
+    try {
+      const res = await this.http.head(`/api/resource/${encodeURIComponent(doctype)}/${encodeURIComponent(name)}`);
+      return res.headers.get("ETag") || res.headers.get("Last-Modified") || void 0;
+    } catch (err) {
+      log.error(err);
+      return;
+    }
+  }
+  async getDocList(doctype, options = {}) {
+    const params = {};
+    if (options.fields) params.fields = options.fields;
+    if (options.filters) params.filters = normalizeFilters(options.filters);
+    if (options.orFilters) params.or_filters = options.orFilters;
+    if (options.cursor) {
+      params.cursor = options.cursor;
+    } else if (typeof options.limitStart === "number") {
+      params.limit_start = options.limitStart;
+    }
+    if (options.limit != null) params.limit_page_length = options.limit;
+    if (options.orderBy) {
+      const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+      params.order_by = orderByArray.map(ob => `${ob.field} ${ob.order}`).join(", ");
+    }
+    if (options.groupBy) params.group_by = options.groupBy;
+    if (options.asDict != null) params.as_dict = options.asDict;
+    return (await this.http.get(`/api/resource/${encodeURIComponent(doctype)}`, params)).payload?.data ?? [];
+  }
+  async getCount(doctype, filters, _cache, _debug) {
+    const params = {
+      doctype
+    };
+    if (filters) params.filters = normalizeFilters(filters);
+    const count = (await this.http.get("/api/method/frappe.client.get_count", params)).payload?.message;
+    if (!Number.isFinite(count)) {
+      log.error(`invalid count for doctype ${doctype}: ${count}`);
+      return 0;
+    }
+    return count;
+  }
+  async createDoc(doc) {
+    const headers = {};
+    const {
+      client_mutation_id,
+      base_modified: _base_modified,
+      ...cleanDoc
+    } = doc;
+    if (client_mutation_id) {
+      headers["Idempotency-Key"] = client_mutation_id;
+    }
+    return (await this.http.post(`/api/method/${this.endpoints.createDoc}`, cleanDoc, headers)).payload;
+  }
+  async updateDoc(doc) {
+    const headers = {};
+    const {
+      client_mutation_id,
+      base_modified,
+      doctype,
+      name,
+      ...data
+    } = doc;
+    if (client_mutation_id) {
+      headers["Idempotency-Key"] = client_mutation_id;
+    }
+    if (base_modified) {
+      headers["If-Match"] = base_modified;
+    }
+    return (await this.http.post(`/api/method/${this.endpoints.updateDoc}`, {
+      doctype,
+      name,
+      data
+    }, headers)).payload;
+  }
+  async deleteDoc(doc) {
+    const headers = {};
+    const {
+      client_mutation_id,
+      ...cleanDoc
+    } = doc;
+    if (client_mutation_id) {
+      headers["Idempotency-Key"] = client_mutation_id;
+    }
+    return (await this.http.post(`/api/method/${this.endpoints.deleteDoc}`, cleanDoc, headers)).payload;
+  }
+  async renameDoc(doc, newName, merge) {
+    return (await this.http.post("/api/method/frappe.model.rename_doc.rename_doc", {
+      doctype: doc.doctype,
+      old_name: doc.name,
+      new_name: newName,
+      merge: !!merge
+    })).payload;
+  }
+  async backfill(args) {
+    const method = args.method || this.endpoints.backfill;
+    const raw = (await this.http.get(`/api/method/${method}`, {
+      doctype: args.doctype,
+      fields: args.fields ? args.fields : void 0,
+      filters: args.filters ? args.filters : void 0,
+      limit: args.limit ?? 200,
+      modified_after: args.modifiedAfter
+    })).payload;
+    const wrapped = raw;
+    return wrapped.message ?? raw;
+  }
+  /**
+   * Get documents using cursor-based pagination via frappe_live extension.
+   * Provides stable pagination that doesn't skip/duplicate items when data changes.
+   */
+  async getListWithCursor(args) {
+    const response = await this.http.post(`/api/method/${this.endpoints.getListWithCursor}`, {
+      doctype: args.doctype,
+      fields: args.fields,
+      filters: args.filters,
+      cursor: args.cursor,
+      limit: args.limit ?? 100,
+      order_by: formatOrderBy(args.orderBy)
+    });
+    return response.payload.message;
+  }
+  /**
+   * Execute batch mutations via frappe_live extension.
+   * Processes multiple create/update/delete operations in a single request.
+   */
+  async batchMutations(args) {
+    const response = await this.http.post(`/api/method/${this.endpoints.batchMutations}`, {
+      mutations: args.mutations,
+      atomic: args.atomic ?? false
+    });
+    return response.payload.message;
+  }
+  /**
+   * Get documents modified after a checkpoint via frappe_live extension (CDC).
+   * Optimized for incremental sync with tombstone tracking for deletions.
+   */
+  async listSince(args) {
+    const response = await this.http.post(`/api/method/${this.endpoints.listSince}`, {
+      doctype: args.doctype,
+      modified_after: args.modifiedAfter,
+      fields: args.fields,
+      filters: args.filters,
+      limit: args.limit ?? 1e3
+    });
+    return response.payload.message;
+  }
+}
+function normalizeFilters(filters) {
+  if (Array.isArray(filters)) return filters;
+  return Object.entries(filters).map(([k, v]) => [k, "=", v]);
+}
+function formatOrderBy(orderBy) {
+  if (!orderBy) return void 0;
+  const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return orderByArray.map(ob => `${ob.field} ${ob.order}`).join(", ");
+}
+class TreeDbModule {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /**
+   * Get children of a tree node.
+   * Pass parent=null/undefined to get root nodes.
+   *
+   * @example
+   * ```ts
+   * // Get root accounts
+   * const roots = await tree.getChildren({ doctype: "Account", parent: null });
+   * // Get children of a specific account
+   * const children = await tree.getChildren({ doctype: "Account", parent: "Assets" });
+   * ```
+   */
+  async getChildren(args) {
+    const parentField = this.getParentField(args.doctype);
+    const filters = [...normalizeFiltersForTree(args.filters)];
+    if (args.parent === null || args.parent === void 0) {
+      filters.push([parentField, "in", ["", null]]);
+    } else {
+      filters.push([parentField, "=", args.parent]);
+    }
+    return this.db.getDocList(args.doctype, {
+      fields: args.fields,
+      filters,
+      orderBy: [{
+        field: "name",
+        order: import_types.Order.Asc
+      }]
+    });
+  }
+  /**
+   * Get ancestors of a node (path from root to this node).
+   * Uses Frappe's built-in "ancestors of" filter.
+   *
+   * @example
+   * ```ts
+   * const path = await tree.getAncestors({ doctype: "Account", name: "Cash - ABC" });
+   * // Returns: [root, ..., parent, ..., Cash - ABC] if includeSelf is true
+   * ```
+   */
+  async getAncestors(args) {
+    const docs = await this.db.getDocList(args.doctype, {
+      fields: args.fields,
+      filters: [["name", "ancestors of", args.name]],
+      limit: 0
+      // Get all ancestors
+    });
+    if (args.includeSelf) {
+      const self = await this.db.getDoc(args.doctype, args.name);
+      return [...docs, self];
+    }
+    return docs;
+  }
+  /**
+   * Get all descendants of a node.
+   * Uses Frappe's built-in tree traversal.
+   *
+   * @example
+   * ```ts
+   * const allChildren = await tree.getDescendants({ doctype: "Account", name: "Assets" });
+   * ```
+   */
+  async getDescendants(args) {
+    const docs = await this.db.getDocList(args.doctype, {
+      fields: args.fields,
+      filters: [["name", "descendants of", args.name]],
+      limit: 0
+      // Get all
+    });
+    if (args.includeSelf) {
+      const self = await this.db.getDoc(args.doctype, args.name);
+      return [self, ...docs];
+    }
+    return docs;
+  }
+  /**
+   * Build a full tree structure from root nodes.
+   * This recursively fetches children to build a nested tree.
+   *
+   * @example
+   * ```ts
+   * const tree = await treeDb.buildTree<Account>({ doctype: "Account" });
+   * // Returns: [{ name: "Assets", children: [...] }, { name: "Liabilities", children: [...] }]
+   * ```
+   */
+  async buildTree(args) {
+    const {
+      doctype,
+      fields,
+      maxDepth = 10
+    } = args;
+    const buildNode = async (doc, depth) => {
+      if (depth >= maxDepth) {
+        return {
+          ...doc
+        };
+      }
+      const children = await this.getChildren({
+        doctype,
+        parent: doc.name,
+        fields
+      });
+      const childNodes = await Promise.all(children.map(child => buildNode(child, depth + 1)));
+      return {
+        ...doc,
+        children: childNodes.length > 0 ? childNodes : void 0
+      };
+    };
+    const roots = await this.getChildren({
+      doctype,
+      parent: null,
+      fields
+    });
+    return Promise.all(roots.map(root => buildNode(root, 0)));
+  }
+  /**
+   * Get the parent field name for a tree doctype.
+   * Convention: parent_<doctype_lowercase_with_underscores>
+   */
+  getParentField(doctype) {
+    return `parent_${doctype.toLowerCase().replace(/ /g, "_")}`;
+  }
+}
+function normalizeFiltersForTree(filters) {
+  if (!filters) return [];
+  if (Array.isArray(filters)) return filters;
+  return Object.entries(filters).map(([k, v]) => [k, "=", v]);
+}