@multiplatform.one/frappe 6.0.0

package/dist/esm/db.spec.native.js

@@ -0,0 +1,863 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DbModule } from "./db.native.js";
+import { Order } from "./sync/types.native.js";
+describe("DbModule", function () {
+  var db;
+  var mockHttpClient;
+  beforeEach(function () {
+    mockHttpClient = {
+      get: vi.fn(),
+      post: vi.fn(),
+      put: vi.fn(),
+      delete: vi.fn(),
+      head: vi.fn(),
+      request: vi.fn(),
+      setToken: vi.fn()
+    };
+    db = new DbModule(mockHttpClient);
+  });
+  describe("constructor", function () {
+    it("should initialize with default endpoints", function () {
+      var dbInstance = new DbModule(mockHttpClient);
+      expect(dbInstance).toBeDefined();
+    });
+    it("should initialize with custom endpoints", function () {
+      var dbInstance = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          createDoc: "custom.create",
+          updateDoc: "custom.update",
+          deleteDoc: "custom.delete",
+          backfill: "custom.backfill"
+        }
+      });
+      expect(dbInstance).toBeDefined();
+    });
+    it("should initialize with partial custom endpoints", function () {
+      var dbInstance = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          createDoc: "custom.create"
+        }
+      });
+      expect(dbInstance).toBeDefined();
+    });
+  });
+  describe("getDoc", function () {
+    it("should fetch a document by doctype and name", async function () {
+      var mockDoc = {
+        name: "TEST-001",
+        title: "Test Document",
+        description: "Test description",
+        doctype: "TestDoc"
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: mockDoc
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.getDoc("TestDocType", "TEST-001");
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType/TEST-001");
+      expect(result).toEqual(mockDoc);
+    });
+    it("should properly encode doctype and name with special characters", async function () {
+      var mockDoc = {
+        name: "Test/Doc-001"
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: mockDoc
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.getDoc("Test DocType", "Test/Doc-001");
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/Test%20DocType/Test%2FDoc-001");
+    });
+  });
+  describe("getDocVersion", function () {
+    it("should return ETag when available", async function () {
+      var mockHeaders = new Headers({
+        ETag: '"abc123"',
+        "Last-Modified": "Wed, 21 Oct 2025 07:28:00 GMT"
+      });
+      mockHttpClient.head.mockResolvedValue({
+        headers: mockHeaders,
+        status: 200,
+        payload: ""
+      });
+      var version = await db.getDocVersion("TestDocType", "TEST-001");
+      expect(mockHttpClient.head).toHaveBeenCalledWith("/api/resource/TestDocType/TEST-001");
+      expect(version).toBe('"abc123"');
+    });
+    it("should return Last-Modified when ETag is not available", async function () {
+      var mockHeaders = new Headers({
+        "Last-Modified": "Wed, 21 Oct 2025 07:28:00 GMT"
+      });
+      mockHttpClient.head.mockResolvedValue({
+        headers: mockHeaders,
+        status: 200,
+        payload: ""
+      });
+      var version = await db.getDocVersion("TestDocType", "TEST-001");
+      expect(version).toBe("Wed, 21 Oct 2025 07:28:00 GMT");
+    });
+    it("should return undefined when neither ETag nor Last-Modified is available", async function () {
+      var mockHeaders = new Headers();
+      mockHttpClient.head.mockResolvedValue({
+        headers: mockHeaders,
+        status: 200,
+        payload: ""
+      });
+      var version = await db.getDocVersion("TestDocType", "TEST-001");
+      expect(version).toBeUndefined();
+    });
+    it("should return undefined and log error on exception", async function () {
+      var consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(function () {});
+      mockHttpClient.head.mockRejectedValue(new Error("Network error"));
+      var version = await db.getDocVersion("TestDocType", "TEST-001");
+      expect(version).toBeUndefined();
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+  describe("getDocList", function () {
+    it("should fetch document list without options", async function () {
+      var mockDocs = [{
+        name: "TEST-001",
+        title: "Doc 1",
+        doctype: "TestDoc"
+      }, {
+        name: "TEST-002",
+        title: "Doc 2",
+        doctype: "TestDoc"
+      }];
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: mockDocs
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.getDocList("TestDocType");
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {});
+      expect(result).toEqual(mockDocs);
+    });
+    it("should fetch document list with all options", async function () {
+      var mockDocs = [{
+        name: "TEST-001",
+        title: "Doc 1",
+        doctype: "TestDoc"
+      }];
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: mockDocs
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var options = {
+        fields: ["name", "title"],
+        filters: {
+          status: "Active"
+        },
+        orFilters: [["type", "=", "A"]],
+        limitStart: 10,
+        limit: 20,
+        orderBy: {
+          field: "name",
+          order: Order.Asc
+        },
+        groupBy: "status",
+        asDict: true
+      };
+      var result = await db.getDocList("TestDocType", options);
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        fields: ["name", "title"],
+        filters: [["status", "=", "Active"]],
+        or_filters: [["type", "=", "A"]],
+        limit_start: 10,
+        limit_page_length: 20,
+        order_by: "name asc",
+        group_by: "status",
+        as_dict: true
+      });
+      expect(result).toEqual(mockDocs);
+    });
+    it("should handle array filters", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.getDocList("TestDocType", {
+        filters: [["status", "=", "Active"], ["type", "!=", "Deleted"]]
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        filters: [["status", "=", "Active"], ["type", "!=", "Deleted"]]
+      });
+    });
+    it("should handle object filters", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.getDocList("TestDocType", {
+        filters: {
+          status: "Active",
+          type: "Standard"
+        }
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        filters: [["status", "=", "Active"], ["type", "=", "Standard"]]
+      });
+    });
+    it("should return empty array when data is undefined", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {},
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.getDocList("TestDocType");
+      expect(result).toEqual([]);
+    });
+    it("should handle response with message field instead of data", async function () {
+      var mockDocs = [{
+        name: "TEST-001",
+        title: "Doc 1",
+        doctype: "TestDoc"
+      }];
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: mockDocs
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.getDocList("TestDocType");
+      expect(result).toEqual([]);
+    });
+  });
+  describe("getCount", function () {
+    it("should get document count without filters", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: 42
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType");
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.client.get_count", {
+        doctype: "TestDocType"
+      });
+      expect(count).toBe(42);
+    });
+    it("should get document count with array filters", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: 10
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType", [["status", "=", "Active"]]);
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.client.get_count", {
+        doctype: "TestDocType",
+        filters: [["status", "=", "Active"]]
+      });
+      expect(count).toBe(10);
+    });
+    it("should get document count with object filters", async function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: 5
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType", {
+        status: "Active"
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.client.get_count", {
+        doctype: "TestDocType",
+        filters: [["status", "=", "Active"]]
+      });
+      expect(count).toBe(5);
+    });
+    it("should return 0 and log error for invalid count", async function () {
+      var consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(function () {});
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: "invalid"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType");
+      expect(count).toBe(0);
+      expect(consoleErrorSpy).toHaveBeenCalledWith("invalid count for doctype TestDocType: invalid");
+      consoleErrorSpy.mockRestore();
+    });
+    it("should return 0 for NaN", async function () {
+      var consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(function () {});
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: Number.NaN
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType");
+      expect(count).toBe(0);
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+    it("should return 0 for Infinity", async function () {
+      var consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(function () {});
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          message: Number.POSITIVE_INFINITY
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var count = await db.getCount("TestDocType");
+      expect(count).toBe(0);
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+  describe("createDoc", function () {
+    it("should create a document", async function () {
+      var newDoc = {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document",
+        description: "Test description"
+      };
+      var createdDoc = {
+        ...newDoc
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: createdDoc,
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.createDoc(newDoc);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.create_doc", {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document",
+        description: "Test description"
+      }, {});
+      expect(result).toEqual(createdDoc);
+    });
+    it("should include Idempotency-Key header when client_mutation_id is provided", async function () {
+      var newDoc = {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document",
+        client_mutation_id: "mutation-123"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-003",
+          title: "New Document"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.createDoc(newDoc);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.create_doc", {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document"
+      }, {
+        "Idempotency-Key": "mutation-123"
+      });
+    });
+    it("should exclude base_modified from request body", async function () {
+      var newDoc = {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document",
+        base_modified: "2025-01-01"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-003",
+          title: "New Document"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.createDoc(newDoc);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.create_doc", {
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "New Document"
+      }, {});
+    });
+    it("should use custom endpoint when provided", async function () {
+      var customDb = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          createDoc: "custom.create_endpoint"
+        }
+      });
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-003"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await customDb.createDoc({
+        doctype: "TestDocType",
+        name: "TEST-003",
+        title: "Test"
+      });
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/custom.create_endpoint", expect.any(Object), expect.any(Object));
+    });
+  });
+  describe("updateDoc", function () {
+    it("should update a document", async function () {
+      var updates = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+        status: "Completed"
+      };
+      var updatedDoc = {
+        name: "TEST-001",
+        title: "Updated Title",
+        status: "Completed",
+        doctype: "TestDoc"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: updatedDoc,
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.updateDoc(updates);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.update_doc", {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        data: {
+          title: "Updated Title",
+          status: "Completed"
+        }
+      }, {});
+      expect(result).toEqual(updatedDoc);
+    });
+    it("should include Idempotency-Key when client_mutation_id is provided", async function () {
+      var updates = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+        client_mutation_id: "mutation-456"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-001",
+          title: "Updated Title"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.updateDoc(updates);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.update_doc", {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        data: {
+          title: "Updated Title"
+        }
+      }, {
+        "Idempotency-Key": "mutation-456"
+      });
+    });
+    it("should include If-Match header when base_modified is provided", async function () {
+      var updates = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+        base_modified: "2025-01-01T10:00:00Z"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-001",
+          title: "Updated Title"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.updateDoc(updates);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.update_doc", {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        data: {
+          title: "Updated Title"
+        }
+      }, {
+        "If-Match": "2025-01-01T10:00:00Z"
+      });
+    });
+    it("should include both headers when both IDs are provided", async function () {
+      var updates = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+        client_mutation_id: "mutation-789",
+        base_modified: "2025-01-01T10:00:00Z"
+      };
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-001",
+          title: "Updated Title"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.updateDoc(updates);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.update_doc", expect.any(Object), {
+        "Idempotency-Key": "mutation-789",
+        "If-Match": "2025-01-01T10:00:00Z"
+      });
+    });
+    it("should use custom endpoint when provided", async function () {
+      var customDb = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          updateDoc: "custom.update_endpoint"
+        }
+      });
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          name: "TEST-001"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await customDb.updateDoc({
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Test"
+      });
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/custom.update_endpoint", expect.any(Object), expect.any(Object));
+    });
+  });
+  describe("deleteDoc", function () {
+    it("should delete a document", async function () {
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Document deleted successfully"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.deleteDoc({
+        doctype: "TestDocType",
+        name: "TEST-001"
+      });
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.delete_doc", {
+        doctype: "TestDocType",
+        name: "TEST-001"
+      }, {});
+      expect(result).toEqual({
+        message: "Document deleted successfully"
+      });
+    });
+    it("should include Idempotency-Key when mutationId is provided", async function () {
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Document deleted successfully"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.deleteDoc({
+        doctype: "TestDocType",
+        name: "TEST-001",
+        client_mutation_id: "delete-mutation-123"
+      });
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/live.live.api.delete_doc", {
+        doctype: "TestDocType",
+        name: "TEST-001"
+      }, {
+        "Idempotency-Key": "delete-mutation-123"
+      });
+    });
+    it("should use custom endpoint when provided", async function () {
+      var customDb = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          deleteDoc: "custom.delete_endpoint"
+        }
+      });
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Deleted"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await customDb.deleteDoc({
+        doctype: "TestDocType",
+        name: "TEST-001"
+      });
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/custom.delete_endpoint", expect.any(Object), expect.any(Object));
+    });
+  });
+  describe("renameDoc", function () {
+    it("should rename a document", async function () {
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Document renamed successfully"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      var result = await db.renameDoc({
+        doctype: "TestDocType",
+        name: "OLD-001"
+      }, "NEW-001", false);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.model.rename_doc.rename_doc", {
+        doctype: "TestDocType",
+        old_name: "OLD-001",
+        new_name: "NEW-001",
+        merge: false
+      });
+      expect(result).toEqual({
+        message: "Document renamed successfully"
+      });
+    });
+    it("should rename and merge when merge is true", async function () {
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Document renamed and merged"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.renameDoc({
+        doctype: "TestDocType",
+        name: "OLD-001"
+      }, "EXISTING-001", true);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.model.rename_doc.rename_doc", {
+        doctype: "TestDocType",
+        old_name: "OLD-001",
+        new_name: "EXISTING-001",
+        merge: true
+      });
+    });
+    it("should handle falsy merge values", async function () {
+      mockHttpClient.post.mockResolvedValue({
+        payload: {
+          message: "Renamed"
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await db.renameDoc({
+        doctype: "TestDocType",
+        name: "OLD-001"
+      }, "NEW-001", false);
+      expect(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.model.rename_doc.rename_doc", {
+        doctype: "TestDocType",
+        old_name: "OLD-001",
+        new_name: "NEW-001",
+        merge: false
+      });
+    });
+  });
+  describe("backfill", function () {
+    it("should perform backfill with minimal args", async function () {
+      var mockResponse = {
+        rows: [{
+          name: "TEST-001",
+          title: "Doc 1",
+          doctype: "TestDoc"
+        }, {
+          name: "TEST-002",
+          title: "Doc 2",
+          doctype: "TestDoc"
+        }]
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: mockResponse,
+        headers: new Headers(),
+        status: 200
+      });
+      var args = {
+        doctype: "TestDocType"
+      };
+      var result = await db.backfill(args);
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/live.live.api.backfill", {
+        doctype: "TestDocType",
+        fields: void 0,
+        filters: void 0,
+        limit: 200,
+        modified_after: void 0
+      });
+      expect(result).toEqual(mockResponse);
+    });
+    it("should perform backfill with all args", async function () {
+      var mockResponse = {
+        rows: [{
+          name: "TEST-001",
+          title: "Doc 1",
+          doctype: "TestDoc"
+        }],
+        checkpoint: "checkpoint-123",
+        deleted: [{
+          doctype: "TestDocType",
+          name: "DELETED-001"
+        }]
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: mockResponse,
+        headers: new Headers(),
+        status: 200
+      });
+      var args = {
+        method: "custom.backfill_method",
+        doctype: "TestDocType",
+        fields: ["name", "title"],
+        filters: {
+          status: "Active"
+        },
+        modifiedAfter: "2025-01-01T00:00:00Z",
+        limit: 50
+      };
+      var result = await db.backfill(args);
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/custom.backfill_method", {
+        doctype: "TestDocType",
+        fields: ["name", "title"],
+        filters: {
+          status: "Active"
+        },
+        limit: 50,
+        modified_after: "2025-01-01T00:00:00Z"
+      });
+      expect(result).toEqual(mockResponse);
+    });
+    it("should handle array filters in backfill", async function () {
+      var mockResponse = {
+        rows: []
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: mockResponse,
+        headers: new Headers(),
+        status: 200
+      });
+      var args = {
+        doctype: "TestDocType",
+        filters: [["status", "=", "Active"], ["type", "!=", "Deleted"]]
+      };
+      await db.backfill(args);
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/live.live.api.backfill", {
+        doctype: "TestDocType",
+        fields: void 0,
+        filters: [["status", "=", "Active"], ["type", "!=", "Deleted"]],
+        limit: 200,
+        modified_after: void 0
+      });
+    });
+    it("should use custom endpoint from constructor", async function () {
+      var customDb = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          backfill: "custom.default_backfill"
+        }
+      });
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          rows: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await customDb.backfill({
+        doctype: "TestDocType"
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/custom.default_backfill", expect.any(Object));
+    });
+    it("should override custom endpoint with method arg", async function () {
+      var customDb = new DbModule(mockHttpClient, {
+        customEndpoints: {
+          backfill: "custom.default_backfill"
+        }
+      });
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          rows: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      await customDb.backfill({
+        doctype: "TestDocType",
+        method: "override.backfill"
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/method/override.backfill", expect.any(Object));
+    });
+  });
+  describe("normalizeFilters", function () {
+    it("should return array filters as-is", function () {
+      var filters = [["status", "=", "Active"], ["type", "!=", "Deleted"]];
+      var db2 = new DbModule(mockHttpClient);
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      db2.getDocList("TestDocType", {
+        filters
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        filters: [["status", "=", "Active"], ["type", "!=", "Deleted"]]
+      });
+    });
+    it("should convert object filters to array format", function () {
+      var filters = {
+        status: "Active",
+        type: "Standard",
+        count: 5,
+        enabled: true
+      };
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      db.getDocList("TestDocType", {
+        filters
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        filters: [["status", "=", "Active"], ["type", "=", "Standard"], ["count", "=", 5], ["enabled", "=", true]]
+      });
+    });
+    it("should handle empty object filters", function () {
+      mockHttpClient.get.mockResolvedValue({
+        payload: {
+          data: []
+        },
+        headers: new Headers(),
+        status: 200
+      });
+      db.getDocList("TestDocType", {
+        filters: {}
+      });
+      expect(mockHttpClient.get).toHaveBeenCalledWith("/api/resource/TestDocType", {
+        filters: []
+      });
+    });
+  });
+});
+//# sourceMappingURL=db.spec.native.js.map