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

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import { createClient, mockFetch } from "@tests/setup.ts";
 
 describe("QuickbaseClient - getApp (Unit)", () => {
   const client = createClient(mockFetch);

package/tests/vitest/unit/auth/fetchTempToken401.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 - 401 with fetchTempToken 401", () => {
   let client: ReturnType<typeof createClient>;
@@ -28,14 +28,15 @@ 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}`));

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

@@ -1,12 +1,12 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import { createClient, mockFetch } from "@tests/setup.ts";
 
 describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
   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", () => {
@@ -25,7 +25,7 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
       ok: true,
       status: 200,
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-    } as Response);
+    });
 
     const result = await client.getTempTokenDBID({ dbid: mockDbid });
     expect(result).toEqual({ temporaryAuthorization: mockToken });
@@ -50,7 +50,7 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
       ok: true,
       status: 200,
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-    } as Response);
+    });
 
     const firstResult = await client.getTempTokenDBID({ dbid: mockDbid });
     expect(firstResult).toEqual({ temporaryAuthorization: mockToken });
@@ -64,13 +64,12 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
 
   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) => {

package/tests/vitest/unit/auth/retryOn401.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 - 401 Retry Creates New Token", () => {
   let client: ReturnType<typeof createClient>;

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,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import { createClient, mockFetch } from "@tests/setup.ts";
 
 describe("QuickbaseClient - getFields (Unit)", () => {
   it("calls getFields successfully", async () => {

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

@@ -0,0 +1,118 @@
+// tests/vitest/unit/records/deleteRecords.test.ts
+import { describe, expect, test, beforeEach } from "vitest"; // Added 'describe'
+import { createClient, mockFetch } from "@tests/setup.ts";
+
+describe("QuickbaseClient - deleteRecords (Unit)", () => {
+  beforeEach(() => {
+    mockFetch.mockClear(); // Clear mock state between tests
+  });
+
+  test("deleteRecords - sends correct DELETE request and handles success", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ numberDeleted: 1 }),
+    });
+
+    const result = await qb.deleteRecords({
+      body: {
+        from: "test-table-id",
+        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": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({ from: "test-table-id", where: "{3.EX.'5'}" }),
+      })
+    );
+    expect(result).toEqual({ numberDeleted: 1 });
+  });
+
+  test("deleteRecords - handles no records deleted", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ numberDeleted: 0 }),
+    });
+
+    const result = await qb.deleteRecords({
+      body: {
+        from: "test-table-id",
+        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": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          from: "test-table-id",
+          where: "{3.EX.'999999'}",
+        }),
+      })
+    );
+    expect(result).toEqual({ numberDeleted: 0 });
+  });
+
+  test("deleteRecords - throws error on API failure", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid query" }),
+    });
+
+    await expect(() =>
+      qb.deleteRecords({
+        body: {
+          from: "test-table-id",
+          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": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          from: "test-table-id",
+          where: "{3.EX.'invalid'}",
+        }),
+      })
+    );
+  });
+});

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

@@ -0,0 +1,228 @@
+// tests/vitest/unit/records/upsert.test.ts
+import { describe, expect, test, beforeEach } from "vitest";
+import { createClient, mockFetch } from "@tests/setup.ts";
+import { vi } from "vitest";
+
+// Note: Type augmentation moved to src/types.d.ts
+describe("QuickbaseClient - upsert (Unit)", () => {
+  beforeEach(() => {
+    vi.resetModules(); // Reset module cache
+    mockFetch.mockClear();
+  });
+
+  test("sends correct POST request and handles successful upsert", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+      debug: true,
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          data: [{ id: 1, "6": { value: "value1" } }],
+          metadata: {
+            createdRecordIds: [1],
+            updatedRecordIds: [],
+            unchangedRecordIds: [],
+            totalNumberOfRecordsProcessed: 1,
+          },
+        }),
+    });
+
+    console.log("[Test] Calling qb.upsert with:", {
+      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+    });
+    const result = await qb.upsert({
+      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+    });
+
+    console.log("[Test] mockFetch calls:", mockFetch.mock.calls);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          to: "test-table-id",
+          data: [{ "6": { value: "value1" } }],
+        }),
+      })
+    );
+
+    expect(result).toEqual({
+      data: [{ id: 1, "6": { value: "value1" } }],
+      metadata: {
+        createdRecordIds: [1],
+        updatedRecordIds: [],
+        unchangedRecordIds: [],
+        totalNumberOfRecordsProcessed: 1,
+      },
+    });
+  });
+
+  test("handles API error with invalid data", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+      debug: true,
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid data format" }),
+    });
+
+    await expect(
+      qb.upsert({
+        body: { to: "test-table-id", data: [{ "999": { value: "invalid" } }] },
+      })
+    ).rejects.toThrow("API Error: Invalid data format (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          to: "test-table-id",
+          data: [{ "999": { value: "invalid" } }],
+        }),
+      })
+    );
+  });
+
+  test("handles upsert with temp token", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      useTempTokens: true,
+      debug: true,
+    });
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "temp-token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            data: [{ id: 2, "7": { value: "value2" } }],
+            metadata: {
+              createdRecordIds: [2],
+              updatedRecordIds: [],
+              unchangedRecordIds: [],
+              totalNumberOfRecordsProcessed: 1,
+            },
+          }),
+      });
+
+    const result = await qb.upsert({
+      body: { to: "test-table-id", data: [{ "7": { value: "value2" } }] },
+      dbid: "test-dbid",
+    } as any); // Temporary type assertion until types.d.ts is applied
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      "https://api.quickbase.com/v1/auth/temporary/test-dbid",
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          "Content-Type": "application/json",
+        }),
+        credentials: "include",
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          Authorization: "QB-TEMP-TOKEN temp-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          to: "test-table-id",
+          data: [{ "7": { value: "value2" } }],
+        }),
+      })
+    );
+
+    expect(result).toEqual({
+      data: [{ id: 2, "7": { value: "value2" } }],
+      metadata: {
+        createdRecordIds: [2],
+        updatedRecordIds: [],
+        unchangedRecordIds: [],
+        totalNumberOfRecordsProcessed: 1,
+      },
+    });
+  });
+
+  test("sends correct POST request with data fields", async () => {
+    const qb = createClient(mockFetch, {
+      realm: "test-realm",
+      userToken: "test-token",
+      debug: true,
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          data: [{ id: 1, "6": { value: "value1" } }],
+          metadata: {
+            createdRecordIds: [1],
+            updatedRecordIds: [],
+            unchangedRecordIds: [],
+            totalNumberOfRecordsProcessed: 1,
+          },
+        }),
+    });
+
+    const result = await qb.upsert({
+      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          Authorization: "QB-USER-TOKEN test-token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify({
+          to: "test-table-id",
+          data: [{ "6": { value: "value1" } }],
+        }),
+      })
+    );
+
+    if (result.data && result.data.length > 0) {
+      expect((result.data[0]["6"] as { value: any }).value).toBe("value1");
+    } else {
+      throw new Error("Expected data array to have at least one element");
+    }
+  });
+});

package/tests/vitest/unit/tables/createTable.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch } from "@tests/setup.ts";
+
+describe("QuickbaseClient - createTable (Unit)", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("calls createTable successfully with user token", async () => {
+    const appId = "buwai2zpe";
+    const mockBody = {
+      name: "TestTable",
+      description: "Unit test table",
+      singleRecordName: "Test",
+      pluralRecordName: "Tests",
+    };
+    const mockResponse = {
+      id: "buya8h9iz",
+      name: "TestTable",
+      alias: "_DBID_TESTTABLE",
+      description: "Unit test table",
+      created: new Date("2025-03-10T21:00:00.000Z"),
+      updated: new Date("2025-03-10T21:00:00.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Test",
+      pluralRecordName: "Tests",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const response = await client.createTable({ appId, body: mockBody });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables?appId=${appId}`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+        body: JSON.stringify(mockBody),
+      })
+    );
+  });
+});

package/tests/vitest/unit/tables/deleteTable.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch } from "@tests/setup.ts";
+
+describe("QuickbaseClient - deleteTable (Unit)", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("calls deleteTable successfully with user token", async () => {
+    const appId = "buwai2zpe";
+    const tableId = "buya8h9iz";
+    const mockResponse = {
+      deletedTableId: tableId,
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const response = await client.deleteTable({ tableId, appId });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+      })
+    );
+  });
+
+  it("handles 404 error for non-existent table", async () => {
+    const appId = "buwai2zpe";
+    const tableId = "nonexistent";
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      json: () =>
+        Promise.resolve({
+          message: "Invalid DBID",
+          description: "Table not found in app.",
+        }),
+    });
+
+    await expect(client.deleteTable({ tableId, appId })).rejects.toThrow(
+      "API Error: Invalid DBID (Status: 404)"
+    );
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.any(Object),
+      })
+    );
+  });
+});

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createClient, mockFetch } from "@/tests/setup.ts";
+import { createClient, mockFetch } from "@tests/setup.ts";
 
 describe("QuickbaseClient - getAppTables (Unit)", () => {
   it("calls getAppTables successfully", async () => {