quickbase-js 1.0.1-beta.0 → 1.1.0-beta.1

package/tests/vitest/qb/tables/getAppTables.test.ts

@@ -1,67 +1,46 @@
-import { describe, it, expect } from "vitest";
-import { createClient } from "../../../setup.ts";
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
 
-describe("QuickbaseClient Integration - getAppTables", () => {
-  const client = createClient();
+test(
+  "QuickbaseClient Integration - getAppTables > fetches real table data from QuickBase",
+  { timeout: 10000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+    };
+    const client = quickbase(config);
+    const tablesAppId = "buwai2zpe";
 
-  it(
-    "fetches real table data from QuickBase",
-    async () => {
-      const tablesAppId = process.env.QB_APP_ID;
-      if (!tablesAppId) throw new Error("QB_APP_ID is not defined in .env");
-      if (!process.env.QB_REALM)
-        throw new Error("QB_REALM is not defined in .env");
-      if (!process.env.QB_USER_TOKEN)
-        throw new Error("QB_USER_TOKEN is not defined in .env");
+    console.log("Config used:", config);
+    const result = await client.getAppTables({ appId: tablesAppId });
+    console.log("Real API response:", result);
 
-      console.log("Config used:", {
-        realm: process.env.QB_REALM,
-        userToken: process.env.QB_USER_TOKEN,
-        appId: tablesAppId,
-      });
-      const result = await client.getAppTables({ appId: tablesAppId });
-      console.log("Real API response:", result);
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            alias: "_DBID_ROOT",
-            created: new Date("2025-02-13T18:22:33Z"),
-            defaultSortFieldId: 2,
-            defaultSortOrder: "DESC",
-            description: "",
-            id: "buwai2zr4",
-            keyFieldId: 3,
-            name: "Root",
-            nextFieldId: 6,
-            nextRecordId: 1,
-            pluralRecordName: "Roots",
-            singleRecordName: "Root",
-            sizeLimit: "500 MB",
-            spaceRemaining: "500 MB",
-            spaceUsed: "0 KB",
-            updated: new Date("2025-02-13T18:22:34Z"),
-          }),
-          expect.objectContaining({
-            alias: "_DBID_ROLES",
-            created: new Date("2025-02-13T18:22:33Z"),
-            defaultSortFieldId: 2,
-            defaultSortOrder: "DESC",
-            description: "",
-            id: "buwai2z3s",
-            keyFieldId: 3,
-            name: "Roles",
-            nextFieldId: 6,
-            nextRecordId: 1,
-            pluralRecordName: "Roles",
-            singleRecordName: "Role",
-            sizeLimit: "500 MB",
-            spaceRemaining: "500 MB",
-            spaceUsed: "0 KB",
-            updated: new Date("2025-02-13T18:22:34Z"),
-          }),
-        ])
-      );
-    },
-    { timeout: 10000 }
-  );
-});
+    expect(result).toBeDefined();
+    expect(result).toBeInstanceOf(Array);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "buwai2zr4",
+          alias: "_DBID_ROOT",
+          name: expect.any(String), // Allow dynamic name due to updateTable
+          description: expect.any(String), // Allow dynamic description
+          created: expect.any(Date),
+          updated: expect.any(Date), // Allow varying timestamps
+          nextRecordId: expect.any(Number),
+          nextFieldId: expect.any(Number),
+          defaultSortFieldId: expect.any(Number),
+          defaultSortOrder: "DESC",
+          keyFieldId: expect.any(Number),
+          singleRecordName: "Root",
+          pluralRecordName: "Roots",
+          sizeLimit: "500 MB",
+          spaceUsed: expect.any(String),
+          spaceRemaining: "500 MB",
+        }),
+      ])
+    );
+  }
+);

package/tests/vitest/qb/tables/getTable.test.ts

@@ -0,0 +1,26 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getTable > fetches real table data from QuickBase",
+  { timeout: 10000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+    };
+    const client = quickbase(config);
+    const tableId = "buwai2zr4";
+    const appId = "buwai2zpe";
+
+    console.log("Config used:", config);
+    const response = await client.getTable({ tableId, appId });
+    expect(response).toBeDefined();
+    expect(response.id).toBe(tableId);
+    expect(response.name).toBe("Root"); // Expect original name
+    expect(response.alias).toBe("_DBID_ROOT");
+    expect(response.created).toBeInstanceOf(Date);
+    console.log("Real API response:", response);
+  }
+);

package/tests/vitest/qb/tables/updateTable.test.ts

@@ -0,0 +1,48 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - updateTable > updates real table data in QuickBase",
+  { timeout: 10000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+    };
+    const client = quickbase(config);
+    const appId = "buwai2zpe";
+    const tableId = "buwai2zr4";
+    const updatedBody = {
+      name: "Root Updated " + Date.now(),
+      description: "Integration test update",
+    };
+    const originalBody = {
+      name: "Root",
+      description: "",
+    };
+
+    console.log("Config used:", config);
+    // Update the table
+    const response = await client.updateTable({
+      tableId,
+      appId,
+      body: updatedBody,
+    });
+    expect(response).toBeDefined();
+    expect(response.id).toBe(tableId);
+    expect(response.name).toBe(updatedBody.name);
+    expect(response.description).toBe(updatedBody.description);
+    console.log("Real API response:", response);
+
+    // Cleanup: Revert the table to original state
+    const cleanupResponse = await client.updateTable({
+      tableId,
+      appId,
+      body: originalBody,
+    });
+    expect(cleanupResponse.name).toBe(originalBody.name);
+    expect(cleanupResponse.description).toBe(originalBody.description);
+    console.log("Cleanup API response:", cleanupResponse);
+  }
+);

package/tests/vitest/unit/apps/getApp.test.ts

@@ -1,11 +1,19 @@
+// tests/vitest/unit/apps/getApp.test.ts
 import { describe, it, expect, beforeEach } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - getApp (Unit)", () => {
-  const client = createClient(mockFetch);
+describe("QuickbaseClient Unit - getApp", () => {
+  let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
     mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
   });
 
   it("initializes without errors", () => {
@@ -24,7 +32,7 @@ describe("QuickbaseClient - getApp (Unit)", () => {
         status: 200,
         json: () =>
           Promise.resolve({
-            id: process.env.QB_APP_ID,
+            id: QB_APP_ID,
             name: "qb-copy",
             created: "2025-02-13T18:22:33Z",
             updated: "2025-03-04T04:25:51Z",
@@ -45,12 +53,9 @@ describe("QuickbaseClient - getApp (Unit)", () => {
       } as Response);
     });
 
-    const getAppId = process.env.QB_APP_ID;
-    if (!getAppId) throw new Error("QB_APP_ID is not defined in .env");
-    console.log("Test appId:", getAppId);
-    const result = await client.getApp({ appId: getAppId });
+    const result = await client.getApp({ appId: QB_APP_ID });
     expect(result).toEqual({
-      id: getAppId,
+      id: QB_APP_ID,
       name: "qb-copy",
       created: new Date("2025-02-13T18:22:33Z"),
       updated: new Date("2025-03-04T04:25:51Z"),
@@ -69,11 +74,11 @@ describe("QuickbaseClient - getApp (Unit)", () => {
       },
     });
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/apps/${getAppId}`,
+      `https://api.quickbase.com/v1/apps/${QB_APP_ID}`,
       expect.objectContaining({
         headers: expect.objectContaining({
-          Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
         }),
       })
     );

package/tests/vitest/unit/auth/fetchTempToken401.test.ts

@@ -1,7 +1,13 @@
+// tests/vitest/unit/auth/fetchTempToken401.test.ts
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
+describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
@@ -10,7 +16,6 @@ describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
   });
 
   it("fails without infinite loop when fetchTempToken returns 401 after initial 401", async () => {
-    const mockDbid = "mockDbid123";
     let callCount = 0;
 
     mockFetch.mockImplementation((url) => {
@@ -28,25 +33,46 @@ describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
         return Promise.resolve({
           ok: false,
           status: 401,
-          text: () => Promise.resolve("Unauthorized"),
+          json: () => Promise.resolve({ message: "Unauthorized" }),
         });
       }
       if (url.includes("auth/temporary") && callCount === 3) {
         return Promise.resolve({
           ok: false,
           status: 401,
-          text: () => Promise.resolve("Unauthorized in fetchTempToken"),
+          json: () =>
+            Promise.resolve({ message: "Unauthorized in fetchTempToken" }),
         });
       }
       return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
     });
 
     const consoleSpy = vi.spyOn(console, "log");
-    await expect(client.getFields({ tableId: mockDbid })).rejects.toThrow(
+    await expect(client.getFields({ tableId: QB_TABLE_ID_1 })).rejects.toThrow(
       "API Error: Unauthorized in fetchTempToken (Status: 401)"
     );
 
     expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      3,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+
     expect(consoleSpy).toHaveBeenCalledWith(
       "Authorization error for getFields, refreshing token:",
       expect.any(String)

package/tests/vitest/unit/auth/getTempToken.test.ts

@@ -1,12 +1,18 @@
+// tests/vitest/unit/auth/getTempTokenDBID.test.ts
 import { describe, it, expect, beforeEach } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
+describe("QuickbaseClient Unit - getTempTokenDBID", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
     mockFetch.mockClear();
-    client = createClient(mockFetch, { useTempTokens: true, debug: false }); // Keep debug off for unit test clarity
+    client = createClient(mockFetch, { useTempTokens: true, debug: false });
   });
 
   it("initializes without errors", () => {
@@ -18,23 +24,22 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
   });
 
   it("fetches and caches temp token on first call", async () => {
-    const mockDbid = "mockDbid123";
     const mockToken = "b123xyz_temp_token";
 
     mockFetch.mockResolvedValueOnce({
       ok: true,
       status: 200,
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-    } as Response);
+    });
 
-    const result = await client.getTempTokenDBID({ dbid: mockDbid });
+    const result = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
     expect(result).toEqual({ temporaryAuthorization: mockToken });
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/auth/temporary/${mockDbid}`,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
       expect.objectContaining({
         method: "GET",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           "Content-Type": "application/json",
         }),
         credentials: "include",
@@ -43,41 +48,48 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
   });
 
   it("reuses cached temp token on second call", async () => {
-    const mockDbid = "mockDbid123";
     const mockToken = "b123xyz_temp_token";
 
     mockFetch.mockResolvedValueOnce({
       ok: true,
       status: 200,
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-    } as Response);
+    });
 
-    const firstResult = await client.getTempTokenDBID({ dbid: mockDbid });
+    const firstResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
     expect(firstResult).toEqual({ temporaryAuthorization: mockToken });
     expect(mockFetch).toHaveBeenCalledTimes(1);
 
     mockFetch.mockClear();
-    const secondResult = await client.getTempTokenDBID({ dbid: mockDbid });
+    const secondResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
     expect(secondResult).toEqual({ temporaryAuthorization: mockToken });
     expect(mockFetch).not.toHaveBeenCalled();
   });
 
   it("handles API error", async () => {
-    const mockDbid = "mockDbid123";
-    const errorResponse = {
+    mockFetch.mockResolvedValueOnce({
       ok: false,
       status: 401,
-      text: () => Promise.resolve("Unauthorized"),
-    } as Response;
-
-    mockFetch.mockResolvedValueOnce(errorResponse);
+      json: () => Promise.resolve({ message: "Unauthorized" }),
+    });
 
-    await expect(client.getTempTokenDBID({ dbid: mockDbid })).rejects.toSatisfy(
-      (error: Error) => {
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBe("API Error: Unauthorized (Status: 401)");
-        return true;
-      }
+    await expect(
+      client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 })
+    ).rejects.toSatisfy((error: Error) => {
+      expect(error).toBeInstanceOf(Error);
+      expect(error.message).toBe("API Error: Unauthorized (Status: 401)");
+      return true;
+    });
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          "Content-Type": "application/json",
+        }),
+        credentials: "include",
+      })
     );
   });
 });

package/tests/vitest/unit/auth/retryOn401.test.ts

@@ -1,7 +1,13 @@
+// tests/vitest/unit/auth/retryOn401.test.ts
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - 401 Retry Creates New Token", () => {
+describe("QuickbaseClient Unit - 401 Retry Creates New Token", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
@@ -10,7 +16,6 @@ describe("QuickbaseClient - 401 Retry Creates New Token", () => {
   });
 
   it("creates a new token on 401 and retries successfully", async () => {
-    const mockDbid = "mockDbid123";
     const mockToken = "new_token_456";
     const mockFields = [{ id: 1, label: "Field1" }];
     let callCount = 0;
@@ -51,16 +56,45 @@ describe("QuickbaseClient - 401 Retry Creates New Token", () => {
     });
 
     const consoleSpy = vi.spyOn(console, "log");
-    const result = await client.getFields({ tableId: mockDbid });
+    const result = await client.getFields({ tableId: QB_TABLE_ID_1 });
 
     expect(result).toEqual(mockFields);
     expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      3,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      4,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        }),
+      })
+    );
+
     expect(consoleSpy).toHaveBeenCalledWith(
       "Authorization error for getFields, refreshing token:",
       expect.any(String)
     );
     expect(consoleSpy).toHaveBeenCalledWith(
-      "Fetched and cached new token for dbid: mockDbid123",
+      `Fetched and cached new token for dbid: ${QB_TABLE_ID_1}`,
       mockToken + "_retry",
       expect.any(String)
     );

package/tests/vitest/unit/auth/two401s.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import { createClient, mockFetch } from "@tests/setup.ts";
 
 describe("QuickbaseClient - Two 401s in a Row", () => {
   let client: ReturnType<typeof createClient>;

package/tests/vitest/unit/fields/getFields.test.ts

@@ -1,7 +1,14 @@
+// tests/vitest/unit/fields/getFields.test.ts
 import { describe, it, expect } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - getFields (Unit)", () => {
+describe("QuickbaseClient Unit - getFields", () => {
   it("calls getFields successfully", async () => {
     mockFetch.mockImplementation((url: string, options: any) => {
       console.log("Mock fetch for getFields:", url, options);
@@ -47,9 +54,9 @@ describe("QuickbaseClient - getFields (Unit)", () => {
       } as Response);
     });
 
-    const client = createClient(mockFetch);
+    const client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
     const result = await client.getFields({
-      tableId: "dummyTableId",
+      tableId: QB_TABLE_ID_1,
       includeFieldPerms: true,
     });
     console.log("getFields response:", result);
@@ -103,11 +110,11 @@ describe("QuickbaseClient - getFields (Unit)", () => {
       ])
     );
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields?tableId=dummyTableId&includeFieldPerms=true`,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}&includeFieldPerms=true`,
       expect.objectContaining({
         headers: expect.objectContaining({
-          Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
         }),
       })
     );

package/tests/vitest/unit/records/deleteRecords.test.ts

@@ -0,0 +1,112 @@
+// tests/vitest/unit/records/deleteRecords.test.ts
+import { describe, expect, test, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - deleteRecords", () => {
+  let qb: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    qb = createClient(mockFetch, { debug: true }); // Use debug: true for consistency with other tests
+  });
+
+  test("sends correct DELETE request and handles success", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ numberDeleted: 1 }),
+    });
+
+    const result = await qb.deleteRecords({
+      body: {
+        from: QB_TABLE_ID_1,
+        where: "{3.EX.'5'}", // Simulate deleting Record ID 5
+      },
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({ from: QB_TABLE_ID_1, where: "{3.EX.'5'}" }),
+      })
+    );
+    expect(result).toEqual({ numberDeleted: 1 });
+  });
+
+  test("handles no records deleted", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ numberDeleted: 0 }),
+    });
+
+    const result = await qb.deleteRecords({
+      body: {
+        from: QB_TABLE_ID_1,
+        where: "{3.EX.'999999'}", // Non-existent Record ID
+      },
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          from: QB_TABLE_ID_1,
+          where: "{3.EX.'999999'}",
+        }),
+      })
+    );
+    expect(result).toEqual({ numberDeleted: 0 });
+  });
+
+  test("throws error on API failure", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid query" }),
+    });
+
+    await expect(() =>
+      qb.deleteRecords({
+        body: {
+          from: QB_TABLE_ID_1,
+          where: "{3.EX.'invalid'}",
+        },
+      })
+    ).rejects.toThrow("API Error: Invalid query (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          from: QB_TABLE_ID_1,
+          where: "{3.EX.'invalid'}",
+        }),
+      })
+    );
+  });
+});