@multiplatform.one/frappe 6.0.0

package/dist/cjs/call.cjs

@@ -0,0 +1,45 @@
+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 call_exports = {};
+__export(call_exports, {
+  CallModule: () => CallModule
+});
+module.exports = __toCommonJS(call_exports);
+class CallModule {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  get(method, params) {
+    return this.http.get(`/api/method/${method}`, params);
+  }
+  post(method, body) {
+    return this.http.post(`/api/method/${method}`, body);
+  }
+  put(method, body) {
+    return this.http.put(`/api/method/${method}`, body);
+  }
+  delete(method, body) {
+    return this.http.delete(`/api/method/${method}`, body);
+  }
+}

package/dist/cjs/call.native.js

@@ -0,0 +1,93 @@
+"use strict";
+
+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 call_exports = {};
+__export(call_exports, {
+  CallModule: () => CallModule
+});
+module.exports = __toCommonJS(call_exports);
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var CallModule = /* @__PURE__ */function () {
+  "use strict";
+
+  function CallModule2(http) {
+    _class_call_check(this, CallModule2);
+    _define_property(this, "http", void 0);
+    this.http = http;
+  }
+  _create_class(CallModule2, [{
+    key: "get",
+    value: function get(method, params) {
+      return this.http.get(`/api/method/${method}`, params);
+    }
+  }, {
+    key: "post",
+    value: function post(method, body) {
+      return this.http.post(`/api/method/${method}`, body);
+    }
+  }, {
+    key: "put",
+    value: function put(method, body) {
+      return this.http.put(`/api/method/${method}`, body);
+    }
+  }, {
+    key: "delete",
+    value: function _delete(method, body) {
+      return this.http.delete(`/api/method/${method}`, body);
+    }
+  }]);
+  return CallModule2;
+}();
+//# sourceMappingURL=call.native.js.map

package/dist/cjs/call.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","call_exports","__export","CallModule","module","exports","_class_call_check","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_create_class","protoProps","staticProps","prototype"],"sources":["../../src/call.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,YAAA;AAAAC,QAAA,CAAAD,YAAA;EAAAE,UAAA,EAAAA,CAAA,KAAAA;AAAA;AAEOC,MAAM,CAAAC,OAAA,GAAWT,YAAA,CAAAK,YAAA;AAAA,SACtBK,iBAA+CA,CAAAC,QAAA,EAAAC,WAAA;EAAlB,MAAAD,QAAA,YAAAC,WAAA;IAAmB,UAAAC,SAAA;EAAnB;AAAA;AAG3B,SAAAC,iBAAwBA,CAAAC,MAAA,EAAAC,KAAe;EACzC,SAAAC,CAAA,MAAAA,CAAA,GAAAD,KAAA,CAAAE,MAAA,EAAAD,CAAA;IAEA,IAAQE,UAAgB,GAAYH,KAAA,CAAAC,CAAA;IAClCE,UAAO,CAAAC,UAAU,GAAQD,UAAA,CAAAC,UAAqB,IAAI,KAAI;IACxDD,UAAA,CAAAE,YAAA;IAEA,IAAO,OAAgB,IAAAF,UAAY,EAAAA,UAAA,CAAAG,QAAA;IACjCC,MAAA,CAAOC,cAAiB,CAAAT,MAAA,EAAAI,UAAe,CAAAM,GAAM,EAAIN,UAAI;EACvD;AAAA;AAGE,SAAAO,aAAiBA,CAAAd,WAAU,EAAAe,UAAe,EAAAC,WAAc;EAC1D,IAAAD,UAAA,EAAAb,iBAAA,CAAAF,WAAA,CAAAiB,SAAA,EAAAF,UAAA;EACF,IAAAC,WAAA,EAAAd,iBAAA,CAAAF,WAAA,EAAAgB,WAAA","ignoreList":[]}

package/dist/cjs/call.spec.cjs

@@ -0,0 +1,427 @@
+var import_vitest = require("vitest");
+var import_call = require("./call.cjs");
+(0, import_vitest.describe)("CallModule", () => {
+  let call;
+  let mockHttpClient;
+  (0, import_vitest.beforeEach)(() => {
+    mockHttpClient = {
+      get: import_vitest.vi.fn(),
+      post: import_vitest.vi.fn(),
+      put: import_vitest.vi.fn(),
+      delete: import_vitest.vi.fn(),
+      head: import_vitest.vi.fn(),
+      request: import_vitest.vi.fn(),
+      setToken: import_vitest.vi.fn()
+    };
+    call = new import_call.CallModule(mockHttpClient);
+  });
+  (0, import_vitest.describe)("constructor", () => {
+    (0, import_vitest.it)("should initialize with http client", () => {
+      const callInstance = new import_call.CallModule(mockHttpClient);
+      (0, import_vitest.expect)(callInstance).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("get", () => {
+    (0, import_vitest.it)("should call GET method without params", async () => {
+      const mockResponse = {
+        payload: {
+          message: "Success",
+          data: {
+            result: "test"
+          }
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      const result = await call.get("frappe.api.test_method");
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.api.test_method", void 0);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should call GET method with params", async () => {
+      const params = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        fields: ["name", "title"]
+      };
+      const mockResponse = {
+        payload: {
+          message: "Success"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      const result = await call.get("frappe.api.get_doc", params);
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.api.get_doc", params);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should handle method with dots in name", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      await call.get("frappe.core.doctype.user.user.get_list");
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.core.doctype.user.user.get_list", void 0);
+    });
+    (0, import_vitest.it)("should handle empty params object", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      await call.get("test_method", {});
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/test_method", {});
+    });
+    (0, import_vitest.it)("should handle complex params", async () => {
+      const params = {
+        filters: [["status", "=", "Active"]],
+        order_by: "creation desc",
+        limit: 10,
+        nested: {
+          value: "test",
+          enabled: true
+        }
+      };
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      await call.get("custom_method", params);
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/custom_method", params);
+    });
+    (0, import_vitest.it)("should handle error response", async () => {
+      const mockError = new Error("Method not found");
+      mockHttpClient.get.mockRejectedValue(mockError);
+      await (0, import_vitest.expect)(call.get("invalid_method")).rejects.toThrow("Method not found");
+    });
+  });
+  (0, import_vitest.describe)("post", () => {
+    (0, import_vitest.it)("should call POST method without body", async () => {
+      const mockResponse = {
+        payload: {
+          message: "Created"
+        },
+        headers: new Headers(),
+        status: 201,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      const result = await call.post("frappe.api.create");
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.api.create", void 0);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should call POST method with body", async () => {
+      const body = {
+        doctype: "TestDocType",
+        title: "Test Document",
+        description: "Test description"
+      };
+      const mockResponse = {
+        payload: {
+          message: "Document created",
+          data: {
+            name: "TEST-001",
+            ...body
+          }
+        },
+        headers: new Headers(),
+        status: 201,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      const result = await call.post("frappe.api.insert", body);
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.api.insert", body);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should handle FormData body", async () => {
+      const formData = new FormData();
+      formData.append("file", new Blob(["test"]), "test.txt");
+      formData.append("doctype", "File");
+      const mockResponse = {
+        payload: {
+          message: "File uploaded"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      await call.post("upload_file", formData);
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/upload_file", formData);
+    });
+    (0, import_vitest.it)("should handle array body", async () => {
+      const body = ["item1", "item2", "item3"];
+      const mockResponse = {
+        payload: {
+          message: "Processed"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      await call.post("process_items", body);
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/process_items", body);
+    });
+    (0, import_vitest.it)("should handle null body", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      await call.post("test_method", null);
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/test_method", null);
+    });
+    (0, import_vitest.it)("should handle error response", async () => {
+      const mockError = {
+        status: 500,
+        message: "Internal server error"
+      };
+      mockHttpClient.post.mockRejectedValue(mockError);
+      await (0, import_vitest.expect)(call.post("failing_method", {})).rejects.toEqual(mockError);
+    });
+  });
+  (0, import_vitest.describe)("put", () => {
+    (0, import_vitest.it)("should call PUT method without body", async () => {
+      const mockResponse = {
+        payload: {
+          message: "Updated"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.put.mockResolvedValue(mockResponse);
+      const result = await call.put("frappe.api.update");
+      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/frappe.api.update", void 0);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should call PUT method with body", async () => {
+      const body = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        updates: {
+          title: "Updated Title",
+          status: "Completed"
+        }
+      };
+      const mockResponse = {
+        payload: {
+          message: "Document updated",
+          success: true
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.put.mockResolvedValue(mockResponse);
+      const result = await call.put("frappe.api.update_doc", body);
+      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/frappe.api.update_doc", body);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should handle partial updates", async () => {
+      const body = {
+        field: "status",
+        value: "Active"
+      };
+      const mockResponse = {
+        payload: {
+          message: "Field updated"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.put.mockResolvedValue(mockResponse);
+      await call.put("update_field", body);
+      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/update_field", body);
+    });
+    (0, import_vitest.it)("should handle error response", async () => {
+      const mockError = new Error("Update failed");
+      mockHttpClient.put.mockRejectedValue(mockError);
+      await (0, import_vitest.expect)(call.put("update_method", {})).rejects.toThrow("Update failed");
+    });
+  });
+  (0, import_vitest.describe)("delete", () => {
+    (0, import_vitest.it)("should call DELETE method without body", async () => {
+      const mockResponse = {
+        payload: {
+          message: "Deleted"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+      const result = await call.delete("frappe.api.delete");
+      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/frappe.api.delete", void 0);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should call DELETE method with body", async () => {
+      const body = {
+        doctype: "TestDocType",
+        name: "TEST-001"
+      };
+      const mockResponse = {
+        payload: {
+          message: "Document deleted",
+          success: true
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+      const result = await call.delete("frappe.api.delete_doc", body);
+      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/frappe.api.delete_doc", body);
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+    });
+    (0, import_vitest.it)("should handle batch delete", async () => {
+      const body = {
+        doctype: "TestDocType",
+        names: ["TEST-001", "TEST-002", "TEST-003"]
+      };
+      const mockResponse = {
+        payload: {
+          message: "3 documents deleted"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+      await call.delete("batch_delete", body);
+      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/batch_delete", body);
+    });
+    (0, import_vitest.it)("should handle soft delete", async () => {
+      const body = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        soft_delete: true
+      };
+      const mockResponse = {
+        payload: {
+          message: "Document marked as deleted"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+      await call.delete("soft_delete", body);
+      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/soft_delete", body);
+    });
+    (0, import_vitest.it)("should handle error response", async () => {
+      const mockError = {
+        status: 403,
+        message: "Permission denied"
+      };
+      mockHttpClient.delete.mockRejectedValue(mockError);
+      await (0, import_vitest.expect)(call.delete("delete_method", {})).rejects.toEqual(mockError);
+    });
+  });
+  (0, import_vitest.describe)("method name handling", () => {
+    (0, import_vitest.it)("should handle method names with special characters", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      await call.get("frappe.utils.get-data");
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.utils.get-data", void 0);
+    });
+    (0, import_vitest.it)("should handle method names with underscores", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      await call.post("custom_app.api.test_method_name");
+      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/custom_app.api.test_method_name", void 0);
+    });
+    (0, import_vitest.it)("should handle single word method names", async () => {
+      const mockResponse = {
+        payload: {
+          message: "OK"
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      await call.get("ping");
+      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/ping", void 0);
+    });
+  });
+  (0, import_vitest.describe)("generic type handling", () => {
+    (0, import_vitest.it)("should handle custom generic types", async () => {
+      const mockResponse = {
+        payload: {
+          id: 1,
+          name: "Test",
+          items: ["item1", "item2"]
+        },
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      const result = await call.get("get_custom_data");
+      (0, import_vitest.expect)(result).toEqual(mockResponse);
+      (0, import_vitest.expect)(result.payload.id).toBe(1);
+      (0, import_vitest.expect)(result.payload.name).toBe("Test");
+      (0, import_vitest.expect)(result.payload.items).toHaveLength(2);
+    });
+    (0, import_vitest.it)("should handle array response types", async () => {
+      const mockResponse = {
+        payload: ["item1", "item2", "item3"],
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      const result = await call.get("get_list");
+      (0, import_vitest.expect)(result.payload).toEqual(["item1", "item2", "item3"]);
+    });
+    (0, import_vitest.it)("should handle primitive response types", async () => {
+      const mockResponse = {
+        payload: 42,
+        headers: new Headers(),
+        status: 200,
+        _res: {}
+      };
+      mockHttpClient.get.mockResolvedValue(mockResponse);
+      const result = await call.get("get_count");
+      (0, import_vitest.expect)(result.payload).toBe(42);
+    });
+  });
+});