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

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) => {
@@ -43,11 +48,31 @@ describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
     });
 
     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,7 +1,13 @@
+// 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(() => {
@@ -18,7 +24,6 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
   });
 
   it("fetches and caches temp token on first call", async () => {
-    const mockDbid = "mockDbid123";
     const mockToken = "b123xyz_temp_token";
 
     mockFetch.mockResolvedValueOnce({
@@ -27,14 +32,14 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
     });
 
-    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,7 +48,6 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
   });
 
   it("reuses cached temp token on second call", async () => {
-    const mockDbid = "mockDbid123";
     const mockToken = "b123xyz_temp_token";
 
     mockFetch.mockResolvedValueOnce({
@@ -52,31 +56,40 @@ describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
       json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
     });
 
-    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";
-
     mockFetch.mockResolvedValueOnce({
       ok: false,
       status: 401,
       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/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

@@ -1,18 +1,22 @@
 // tests/vitest/unit/records/deleteRecords.test.ts
-import { describe, expect, test, beforeEach } from "vitest"; // Added 'describe'
-import { createClient, mockFetch } from "@tests/setup.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>;
 
-describe("QuickbaseClient - deleteRecords (Unit)", () => {
   beforeEach(() => {
-    mockFetch.mockClear(); // Clear mock state between tests
+    mockFetch.mockClear();
+    qb = createClient(mockFetch, { debug: true }); // Use debug: true for consistency with other tests
   });
 
-  test("deleteRecords - sends correct DELETE request and handles success", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      userToken: "test-token",
-    });
-
+  test("sends correct DELETE request and handles success", async () => {
     mockFetch.mockResolvedValueOnce({
       ok: true,
       status: 200,
@@ -21,7 +25,7 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
 
     const result = await qb.deleteRecords({
       body: {
-        from: "test-table-id",
+        from: QB_TABLE_ID_1,
         where: "{3.EX.'5'}", // Simulate deleting Record ID 5
       },
     });
@@ -31,22 +35,17 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
       expect.objectContaining({
         method: "DELETE",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
-        body: JSON.stringify({ from: "test-table-id", where: "{3.EX.'5'}" }),
+        body: JSON.stringify({ from: QB_TABLE_ID_1, 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",
-    });
-
+  test("handles no records deleted", async () => {
     mockFetch.mockResolvedValueOnce({
       ok: true,
       status: 200,
@@ -55,7 +54,7 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
 
     const result = await qb.deleteRecords({
       body: {
-        from: "test-table-id",
+        from: QB_TABLE_ID_1,
         where: "{3.EX.'999999'}", // Non-existent Record ID
       },
     });
@@ -65,12 +64,12 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
       expect.objectContaining({
         method: "DELETE",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          from: "test-table-id",
+          from: QB_TABLE_ID_1,
           where: "{3.EX.'999999'}",
         }),
       })
@@ -78,12 +77,7 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
     expect(result).toEqual({ numberDeleted: 0 });
   });
 
-  test("deleteRecords - throws error on API failure", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      userToken: "test-token",
-    });
-
+  test("throws error on API failure", async () => {
     mockFetch.mockResolvedValueOnce({
       ok: false,
       status: 400,
@@ -93,7 +87,7 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
     await expect(() =>
       qb.deleteRecords({
         body: {
-          from: "test-table-id",
+          from: QB_TABLE_ID_1,
           where: "{3.EX.'invalid'}",
         },
       })
@@ -104,12 +98,12 @@ describe("QuickbaseClient - deleteRecords (Unit)", () => {
       expect.objectContaining({
         method: "DELETE",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          from: "test-table-id",
+          from: QB_TABLE_ID_1,
           where: "{3.EX.'invalid'}",
         }),
       })

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

@@ -0,0 +1,102 @@
+// tests/vitest/unit/records/runQuery.test.ts
+import { describe, test, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+import { RunQueryRequest, RunQueryResponse } from "@/generated";
+
+describe("QuickbaseClient Unit - runQuery", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  test("sends correct POST request and handles successful query response", async () => {
+    const queryRequest: RunQueryRequest = {
+      from: QB_TABLE_ID_1,
+      select: [3, 6, 7],
+      where: "{6.EX.'Task 1'}",
+      sortBy: [{ fieldId: 6, order: "ASC" }],
+      groupBy: [{ fieldId: 7, grouping: "equal-values" }],
+      options: { skip: 0, top: 100, compareWithAppLocalTime: false },
+    };
+
+    const mockResponse: RunQueryResponse = {
+      data: [
+        { "3": { value: 1 }, "6": { value: "Task 1" }, "7": { value: "High" } },
+      ],
+      fields: [
+        { id: 3, label: "Record ID#", type: "recordid" },
+        { id: 6, label: "Task Name", type: "text" },
+        { id: 7, label: "Priority", type: "text" },
+      ],
+      metadata: {
+        numFields: 3,
+        numRecords: 1,
+        skip: 0,
+        top: 100,
+        totalRecords: 1,
+      },
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await client.runQuery({ body: queryRequest });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records/query",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify(queryRequest),
+      })
+    );
+
+    expect(result).toEqual(mockResponse);
+  });
+
+  test("handles API error with invalid query", async () => {
+    const invalidQueryRequest = {
+      from: QB_TABLE_ID_1,
+      select: [3],
+      where: "{999.EX.'Invalid'}", // Invalid field ID
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid query" }),
+    });
+
+    await expect(
+      client.runQuery({ body: invalidQueryRequest })
+    ).rejects.toThrow("API Error: Invalid query (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/records/query",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify(invalidQueryRequest),
+      })
+    );
+  });
+});