quickbase-js 1.0.1-beta.0

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

@@ -0,0 +1,234 @@
+import { describe, it, expect } from "vitest";
+import { createClient } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - getFields", () => {
+  const client = createClient();
+
+  it(
+    "fetches real field data from QuickBase",
+    async () => {
+      const tableId = "buwai2z3s";
+      if (!tableId) throw new Error("Table ID is not defined");
+      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:", {
+        realm: process.env.QB_REALM,
+        userToken: process.env.QB_USER_TOKEN,
+        tableId,
+      });
+      const result = await client.getFields({
+        tableId,
+        includeFieldPerms: true,
+      });
+      console.log("Real API response:", result);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: 1,
+            label: "Date Created",
+            fieldType: "timestamp",
+            noWrap: true,
+            bold: false,
+            required: false,
+            appearsByDefault: false,
+            findEnabled: false,
+            unique: false,
+            doesDataCopy: false,
+            fieldHelp: "",
+            audited: false,
+            properties: expect.objectContaining({
+              primaryKey: false,
+              foreignKey: false,
+              sortAsGiven: true,
+              carryChoices: true,
+              allowNewChoices: false,
+              formula: "",
+              defaultValue: "",
+            }),
+            permissions: expect.arrayContaining([
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Viewer",
+                roleId: 10,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Participant",
+                roleId: 11,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Administrator",
+                roleId: 12,
+              }),
+            ]),
+          }),
+          expect.objectContaining({
+            id: 2,
+            label: "Date Modified",
+            fieldType: "timestamp",
+            noWrap: true,
+            bold: false,
+            required: false,
+            appearsByDefault: false,
+            findEnabled: false,
+            unique: false,
+            doesDataCopy: false,
+            fieldHelp: "",
+            audited: false,
+            properties: expect.objectContaining({
+              primaryKey: false,
+              foreignKey: false,
+              sortAsGiven: true,
+              carryChoices: true,
+              allowNewChoices: false,
+              formula: "",
+              defaultValue: "",
+            }),
+            permissions: expect.arrayContaining([
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Viewer",
+                roleId: 10,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Participant",
+                roleId: 11,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Administrator",
+                roleId: 12,
+              }),
+            ]),
+          }),
+          expect.objectContaining({
+            id: 3,
+            label: "Record ID#",
+            fieldType: "recordid",
+            noWrap: true,
+            bold: false,
+            required: false,
+            appearsByDefault: false,
+            findEnabled: false,
+            unique: true,
+            doesDataCopy: false,
+            fieldHelp: "",
+            audited: false,
+            properties: expect.objectContaining({
+              primaryKey: true,
+              foreignKey: false,
+              sortAsGiven: true,
+              carryChoices: true,
+              allowNewChoices: false,
+              formula: "",
+              defaultValue: "",
+            }),
+            permissions: expect.arrayContaining([
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Viewer",
+                roleId: 10,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Participant",
+                roleId: 11,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Administrator",
+                roleId: 12,
+              }),
+            ]),
+          }),
+          expect.objectContaining({
+            id: 4,
+            label: "Record Owner",
+            fieldType: "user",
+            noWrap: true,
+            bold: false,
+            required: false,
+            appearsByDefault: false,
+            findEnabled: true,
+            unique: false,
+            doesDataCopy: false,
+            fieldHelp: "",
+            audited: false,
+            properties: expect.objectContaining({
+              primaryKey: false,
+              foreignKey: false,
+              sortAsGiven: true,
+              carryChoices: true,
+              allowNewChoices: true,
+              formula: "",
+              defaultValue: "",
+            }),
+            permissions: expect.arrayContaining([
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Viewer",
+                roleId: 10,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Participant",
+                roleId: 11,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Administrator",
+                roleId: 12,
+              }),
+            ]),
+          }),
+          expect.objectContaining({
+            id: 5,
+            label: "Last Modified By",
+            fieldType: "user",
+            noWrap: true,
+            bold: false,
+            required: false,
+            appearsByDefault: false,
+            findEnabled: true,
+            unique: false,
+            doesDataCopy: false,
+            fieldHelp: "",
+            audited: false,
+            properties: expect.objectContaining({
+              primaryKey: false,
+              foreignKey: false,
+              sortAsGiven: true,
+              carryChoices: true,
+              allowNewChoices: true,
+              formula: "",
+              defaultValue: "",
+            }),
+            permissions: expect.arrayContaining([
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Viewer",
+                roleId: 10,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Participant",
+                roleId: 11,
+              }),
+              expect.objectContaining({
+                permissionType: "Modify",
+                role: "Administrator",
+                roleId: 12,
+              }),
+            ]),
+          }),
+        ])
+      );
+    },
+    { timeout: 10000 }
+  );
+});

package/tests/vitest/qb/index.ts

@@ -0,0 +1,4 @@
+// Optional: Only add if you need to export tests
+export * from "./apps/getApp.test.ts";
+export * from "./fields/getFields.test.ts";
+export * from "./tables/getAppTables.test.ts";

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

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { createClient } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - getAppTables", () => {
+  const client = createClient();
+
+  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:", {
+        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 }
+  );
+});

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

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createClient, mockFetch } from "@/tests/setup.ts";
+
+describe("QuickbaseClient - getApp (Unit)", () => {
+  const client = createClient(mockFetch);
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has getApp method", () => {
+    expect(typeof client.getApp).toBe("function");
+  });
+
+  it("calls getApp successfully", async () => {
+    mockFetch.mockImplementation((url: string, options: any) => {
+      console.log("Mock fetch:", url, options);
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            id: process.env.QB_APP_ID,
+            name: "qb-copy",
+            created: "2025-02-13T18:22:33Z",
+            updated: "2025-03-04T04:25:51Z",
+            description: "",
+            timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+            dateFormat: "MM-DD-YYYY",
+            hasEveryoneOnTheInternet: false,
+            memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+            securityProperties: {
+              allowClone: false,
+              allowExport: true,
+              enableAppTokens: true,
+              hideFromPublic: false,
+              mustBeRealmApproved: false,
+              useIPFilter: false,
+            },
+          }),
+      } 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 });
+    expect(result).toEqual({
+      id: getAppId,
+      name: "qb-copy",
+      created: new Date("2025-02-13T18:22:33Z"),
+      updated: new Date("2025-03-04T04:25:51Z"),
+      description: "",
+      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+      dateFormat: "MM-DD-YYYY",
+      hasEveryoneOnTheInternet: false,
+      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+      securityProperties: {
+        allowClone: false,
+        allowExport: true,
+        enableAppTokens: true,
+        hideFromPublic: false,
+        mustBeRealmApproved: false,
+        useIPFilter: false,
+      },
+    });
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/apps/${getAppId}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
+          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+        }),
+      })
+    );
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch } from "@/tests/setup.ts";
+
+describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { useTempTokens: true, debug: true });
+  });
+
+  it("fails without infinite loop when fetchTempToken returns 401 after initial 401", async () => {
+    const mockDbid = "mockDbid123";
+    let callCount = 0;
+
+    mockFetch.mockImplementation((url) => {
+      callCount++;
+      console.log(`Mock fetch call ${callCount}: ${url}`);
+      if (url.includes("auth/temporary") && callCount === 1) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () =>
+            Promise.resolve({ temporaryAuthorization: "initial_token" }),
+        });
+      }
+      if (url.includes("fields") && callCount === 2) {
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          text: () => Promise.resolve("Unauthorized"),
+        });
+      }
+      if (url.includes("auth/temporary") && callCount === 3) {
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          text: () => Promise.resolve("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(
+      "API Error: Unauthorized in fetchTempToken (Status: 401)"
+    );
+
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Authorization error for getFields, refreshing token:",
+      expect.any(String)
+    );
+    expect(consoleSpy).not.toHaveBeenCalledWith(
+      "Retrying getFields with new token"
+    );
+    consoleSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach } from "vitest";
+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
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has getTempTokenDBID method", () => {
+    expect(typeof client.getTempTokenDBID).toBe("function");
+  });
+
+  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 });
+    expect(result).toEqual({ temporaryAuthorization: mockToken });
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/auth/temporary/${mockDbid}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          "Content-Type": "application/json",
+        }),
+        credentials: "include",
+      })
+    );
+  });
+
+  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 });
+    expect(firstResult).toEqual({ temporaryAuthorization: mockToken });
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    mockFetch.mockClear();
+    const secondResult = await client.getTempTokenDBID({ dbid: mockDbid });
+    expect(secondResult).toEqual({ temporaryAuthorization: mockToken });
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("handles API error", async () => {
+    const mockDbid = "mockDbid123";
+    const errorResponse = {
+      ok: false,
+      status: 401,
+      text: () => Promise.resolve("Unauthorized"),
+    } as Response;
+
+    mockFetch.mockResolvedValueOnce(errorResponse);
+
+    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;
+      }
+    );
+  });
+});

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

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch } from "@/tests/setup.ts";
+
+describe("QuickbaseClient - 401 Retry Creates New Token", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { useTempTokens: true, debug: true });
+  });
+
+  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;
+
+    mockFetch.mockImplementation((url) => {
+      callCount++;
+      console.log(`Mock fetch call ${callCount}: ${url}`);
+      if (url.includes("auth/temporary") && callCount === 1) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
+        });
+      }
+      if (url.includes("fields") && callCount === 2) {
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          text: () => Promise.resolve("Unauthorized"),
+        });
+      }
+      if (url.includes("auth/temporary") && callCount === 3) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () =>
+            Promise.resolve({ temporaryAuthorization: mockToken + "_retry" }),
+        });
+      }
+      if (url.includes("fields") && callCount === 4) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve(mockFields),
+        });
+      }
+      return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
+    });
+
+    const consoleSpy = vi.spyOn(console, "log");
+    const result = await client.getFields({ tableId: mockDbid });
+
+    expect(result).toEqual(mockFields);
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Authorization error for getFields, refreshing token:",
+      expect.any(String)
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Fetched and cached new token for dbid: mockDbid123",
+      mockToken + "_retry",
+      expect.any(String)
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Retrying getFields with new token"
+    );
+    consoleSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch } from "@/tests/setup.ts";
+
+describe("QuickbaseClient - Two 401s in a Row", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { useTempTokens: true, debug: true });
+  });
+
+  it("logs an error after two 401s in a row", async () => {
+    const mockDbid = "mockDbid123";
+    const mockToken = "new_token_456";
+    let callCount = 0;
+
+    mockFetch.mockImplementation((url) => {
+      callCount++;
+      console.log(`Mock fetch call ${callCount}: ${url}`);
+      if (url.includes("auth/temporary") && callCount === 1) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
+        });
+      }
+      if (url.includes("fields") && callCount === 2) {
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          text: () => Promise.resolve("Unauthorized"),
+        });
+      }
+      if (url.includes("auth/temporary") && callCount === 3) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () =>
+            Promise.resolve({ temporaryAuthorization: mockToken + "_retry" }),
+        });
+      }
+      if (url.includes("fields") && callCount === 4) {
+        return Promise.resolve({
+          ok: false,
+          status: 401,
+          json: () => Promise.resolve({ message: "Unauthorized again" }), // Changed to json()
+          text: () => Promise.resolve("Unauthorized again"), // Keep text() for fallback
+        });
+      }
+      return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
+    });
+
+    const consoleSpy = vi.spyOn(console, "log");
+    await expect(client.getFields({ tableId: mockDbid })).rejects.toThrow(
+      "API Error: Unauthorized again (Status: 401)"
+    );
+
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Authorization error for getFields, refreshing token:",
+      expect.any(String)
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Fetched and cached new token for dbid: mockDbid123",
+      mockToken + "_retry",
+      expect.any(String)
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Retrying getFields with new token"
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Error response body for getFields:",
+      { message: "Unauthorized again" }
+    );
+    consoleSpy.mockRestore();
+  });
+});