quickbase-js 0.1.0-beta.10

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

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+import { UpdateFieldRequest, UpdateField200Response } from "@/generated/models";
+
+describe("QuickbaseClient Unit - updateField", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it("initializes and has updateField method", () => {
+    client = createClient(mockFetch, { debug: true });
+    expect(client).toBeDefined();
+    expect(typeof client.updateField).toBe("function");
+  });
+
+  it("updates field successfully with user token", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    const tableId = QB_TABLE_ID_1;
+    const fieldId = 123;
+
+    const request: UpdateFieldRequest = {
+      label: "Field1",
+      // fieldType omitted as it’s not allowed in updates
+      noWrap: false,
+      bold: false,
+      required: true,
+      appearsByDefault: false,
+      findEnabled: false,
+      unique: true,
+      fieldHelp: "field help",
+      addToForms: true,
+      properties: {
+        numLines: 1,
+        maxLength: 50,
+        appendOnly: true,
+        sortAsGiven: false,
+        allowMentions: false,
+        comments: "Updated field settings",
+        doesTotal: false,
+        defaultValue: "Initial text",
+        choices: ["Option1", "Option2"],
+      },
+      permissions: [
+        { role: "Viewer", permissionType: "View", roleId: 10 },
+        { role: "Participant", permissionType: "None", roleId: 11 },
+        { role: "Administrator", permissionType: "Modify", roleId: 12 },
+      ],
+    };
+
+    const mockResponse: UpdateField200Response = {
+      id: fieldId,
+      label: "Field1",
+      fieldType: "text",
+      mode: "",
+      noWrap: false,
+      bold: false,
+      required: true,
+      appearsByDefault: false,
+      findEnabled: false,
+      unique: true,
+      doesDataCopy: false,
+      fieldHelp: "field help",
+      audited: false,
+      properties: {
+        numLines: 1,
+        maxLength: 50,
+        appendOnly: true,
+        sortAsGiven: false,
+        allowMentions: false,
+        comments: "Updated field settings",
+        doesTotal: false,
+        defaultValue: "Initial text",
+        choices: ["Option1", "Option2"],
+        allowHTML: false,
+        carryChoices: true,
+        allowNewChoices: false,
+        formula: "",
+      },
+      permissions: [
+        { permissionType: "View", role: "Viewer", roleId: 10 },
+        { permissionType: "None", role: "Participant", roleId: 11 },
+        { permissionType: "Modify", role: "Administrator", roleId: 12 },
+      ],
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await client.updateField({
+      fieldId,
+      tableId,
+      body: request,
+    });
+
+    expect(result).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/fields/${fieldId}?tableId=${tableId}`,
+      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: expect.any(String),
+        credentials: "omit",
+      })
+    );
+    const [_, callOptions] = mockFetch.mock.calls[0];
+    expect(JSON.parse(callOptions.body)).toEqual(request);
+  });
+
+  it("updates field successfully with temp token", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true,
+      debug: true,
+    });
+
+    const tableId = QB_TABLE_ID_1;
+    const fieldId = 123;
+
+    const request: UpdateFieldRequest = {
+      label: "Field1",
+      // fieldType omitted as it’s not allowed in updates
+      required: true,
+      unique: true,
+      properties: {
+        numLines: 1,
+        maxLength: 0,
+        choices: ["Yes", "No"],
+        allowNewChoices: true,
+        defaultValue: "No",
+      },
+    };
+
+    const mockResponse: UpdateField200Response = {
+      id: fieldId,
+      label: "Field1",
+      fieldType: "text-multiple-choice",
+      mode: "",
+      noWrap: false,
+      bold: false,
+      required: true,
+      appearsByDefault: false,
+      findEnabled: false,
+      unique: true,
+      doesDataCopy: false,
+      fieldHelp: "",
+      audited: false,
+      properties: {
+        numLines: 1,
+        maxLength: 0,
+        choices: ["Yes", "No"],
+        allowNewChoices: true,
+        defaultValue: "No",
+        appendOnly: false,
+        allowHTML: false,
+        allowMentions: false,
+        sortAsGiven: false,
+        carryChoices: true,
+        formula: "",
+      },
+      permissions: [
+        { permissionType: "View", role: "Viewer", roleId: 10 },
+        { permissionType: "None", role: "Participant", roleId: 11 },
+        { permissionType: "Modify", role: "Administrator", roleId: 12 },
+      ],
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const result = await client.updateField({
+      fieldId,
+      tableId,
+      body: request,
+    });
+
+    expect(result).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${tableId}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          "Content-Type": "application/json",
+        }),
+        credentials: "include",
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/fields/${fieldId}?tableId=${tableId}`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: "QB-TEMP-TOKEN temp_token",
+          "Content-Type": "application/json",
+        }),
+        body: expect.any(String),
+        credentials: "omit",
+      })
+    );
+    const [_, callOptions] = mockFetch.mock.calls[1];
+    expect(JSON.parse(callOptions.body)).toEqual(request);
+  });
+
+  it("handles 400 error for invalid field update", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    const tableId = QB_TABLE_ID_1;
+    const fieldId = 999;
+
+    const request: UpdateFieldRequest = {
+      label: "InvalidField",
+      // fieldType omitted as it’s not allowed in updates
+      required: true,
+      properties: {
+        numLines: 1,
+        decimalPlaces: 2,
+        currencySymbol: "$",
+      },
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid field ID" }),
+    });
+
+    await expect(
+      client.updateField({ fieldId, tableId, body: request })
+    ).rejects.toThrow("API Error: Invalid field ID (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/fields/${fieldId}?tableId=${tableId}`,
+      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: expect.any(String),
+        credentials: "omit",
+      })
+    );
+    const [_, callOptions] = mockFetch.mock.calls[0];
+    expect(JSON.parse(callOptions.body)).toEqual(request);
+  });
+});

package/tests/vitest/unit/formulas/runFormula.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+import { RunFormulaRequest, RunFormula200Response } from "@/generated/models";
+
+describe("QuickbaseClient Unit - runFormula", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it("initializes without errors and has runFormula method", () => {
+    client = createClient(mockFetch, { debug: true });
+    expect(client).toBeDefined();
+    expect(typeof client.runFormula).toBe("function");
+  });
+
+  it("calls runFormula successfully with user token", async () => {
+    client = createClient(mockFetch, { debug: true });
+
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "Sum([NumericField],20)",
+      rid: 1,
+    };
+
+    const mockResponse: RunFormula200Response = {
+      result: "30",
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await client.runFormula({ body: request });
+
+    expect(result).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/formula/run",
+      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",
+        }),
+        // Check body as parsed object to ignore order
+        body: expect.any(String), // First ensure it’s a string
+      })
+    );
+
+    // Additional check for body content
+    const calls = mockFetch.mock.calls;
+    expect(calls.length).toBe(1);
+    const fetchBody = calls[0][1].body as string;
+    expect(JSON.parse(fetchBody)).toEqual(request);
+
+    expect(result.result).toBe("30");
+  });
+
+  it("handles missing rid for formulas not requiring it", async () => {
+    client = createClient(mockFetch, { debug: true });
+
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "User()",
+      // rid omitted intentionally
+    };
+
+    const mockResponse: RunFormula200Response = {
+      result: "user@example.com",
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await client.runFormula({ body: request });
+
+    expect(result).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/formula/run",
+      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: expect.any(String),
+      })
+    );
+
+    const calls = mockFetch.mock.calls;
+    expect(calls.length).toBe(1);
+    const fetchBody = calls[0][1].body as string;
+    expect(JSON.parse(fetchBody)).toEqual(request);
+
+    expect(result.result).toBe("user@example.com");
+  });
+
+  it("handles API error for invalid formula", async () => {
+    client = createClient(mockFetch, { debug: true });
+
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "InvalidFormula()",
+      rid: 1,
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid formula syntax" }),
+    });
+
+    await expect(client.runFormula({ body: request })).rejects.toThrow(
+      "API Error: Invalid formula syntax (Status: 400)"
+    );
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://api.quickbase.com/v1/formula/run",
+      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: expect.any(String),
+      })
+    );
+
+    const calls = mockFetch.mock.calls;
+    expect(calls.length).toBe(1);
+    const fetchBody = calls[0][1].body as string;
+    expect(JSON.parse(fetchBody)).toEqual(request);
+  });
+
+  it("handles temp token with retry on 401", async () => {
+    client = createClient(mockFetch, { useTempTokens: true, debug: true });
+
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "Sum([NumericField],20)",
+      rid: 1,
+    };
+
+    const mockResponse: RunFormula200Response = {
+      result: "30",
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({ temporaryAuthorization: "new_temp_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const result = await client.runFormula({ body: request });
+
+    expect(result).toEqual(mockResponse);
+    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(
+      4,
+      "https://api.quickbase.com/v1/formula/run",
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN new_temp_token",
+        }),
+      })
+    );
+  });
+});

package/tests/vitest/unit/index.ts

@@ -0,0 +1,34 @@
+// tests/vitest/unit/index.ts
+// Apps
+export * from "./apps/copyApp.test.ts";
+export * from "./apps/createApp.test.ts";
+export * from "./apps/deleteApp.test.ts";
+export * from "./apps/getApp.test.ts";
+
+// Auth
+export * from "./auth/fetchTempToken401.test.ts";
+export * from "./auth/getTempToken.test.ts";
+export * from "./auth/retryOn401.test.ts";
+export * from "./auth/retryTempTokenTwo401.test.ts";
+
+// Fields
+export * from "./fields/getFields.test.ts";
+export * from "./fields/getField.test.ts";
+export * from "./fields/createField.test.ts";
+export * from "./fields/deleteFields.test.ts";
+export * from "./fields/getFieldsUsage.test.ts";
+export * from "./fields/getFieldUsage.test.ts";
+
+// Records
+export * from "./records/deleteRecords.test.ts";
+export * from "./records/runQuery.test.ts";
+export * from "./records/upsert.test.ts";
+
+// Tables
+export * from "./tables/createTable.test.ts";
+export * from "./tables/deleteTable.test.ts";
+export * from "./tables/getAppTables.test.ts";
+export * from "./tables/getRelationships.test.ts";
+export * from "./tables/getTable.test.ts";
+export * from "./tables/updateTable.test.ts";
+export * from "./tables/createRelationship.test.ts";

package/tests/vitest/unit/quickbaseClientHttpMethods.test.ts

@@ -0,0 +1,139 @@
+// tests/vitest/unit/quickbaseClient.test.ts
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { quickbase } from "../../../src/quickbaseClient";
+import { mockFetch, QB_APP_ID, QB_REALM } from "../../setup.ts";
+import {
+  UpdateAppRequest,
+  UpdateApp200Response,
+} from "../../../src/generated/models";
+import { ChangesetSolution200Response } from "../../../src/generated/models";
+
+describe("QuickbaseClient Unit - HTTP Method Extraction", () => {
+  let clientTemp: ReturnType<typeof quickbase>;
+  let clientUser: ReturnType<typeof quickbase>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    vi.useFakeTimers();
+
+    clientTemp = quickbase({
+      realm: QB_REALM,
+      userToken: "b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+      debug: false,
+      fetchApi: mockFetch,
+      throttle: { rate: 10, burst: 10 },
+      useTempTokens: true,
+      tempTokenLifespan: 500,
+    });
+
+    clientUser = quickbase({
+      realm: QB_REALM,
+      userToken: "b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+      debug: false,
+      fetchApi: mockFetch,
+      throttle: { rate: 10, burst: 10 },
+      useTempTokens: false,
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    mockFetch.mockReset();
+  });
+
+  const mockUpdateAppResponse: UpdateApp200Response = {
+    id: QB_APP_ID,
+    name: "Test App",
+    description: "",
+    created: new Date("2020-01-01T00:00:00Z"),
+    updated: new Date("2020-01-01T00:00:00Z"),
+    dateFormat: "MM-DD-YYYY",
+    timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+    hasEveryoneOnTheInternet: false,
+    ancestorId: undefined,
+    variables: [],
+    securityProperties: {},
+    memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+    dataClassification: "None",
+  };
+
+  const mockChangesetResponse: ChangesetSolution200Response = [{ changes: [] }];
+
+  const setupMockFetch = () => {
+    mockFetch.mockReset();
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "token1" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockUpdateAppResponse),
+      });
+  };
+
+  const setupMockFetchForChangeset = () => {
+    mockFetch.mockReset();
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockChangesetResponse),
+    });
+  };
+
+  it("uses POST for updateApp", async () => {
+    setupMockFetch();
+    await clientTemp.updateApp({
+      appId: QB_APP_ID,
+      body: { name: "Test App" },
+    });
+    const apiCall = mockFetch.mock.calls.find((call) =>
+      call[0].includes("/apps/")
+    )![1];
+    expect(apiCall.method).toBe("POST");
+  });
+
+  it("uses POST for runReport", async () => {
+    setupMockFetch();
+    await clientTemp.runReport({
+      tableId: QB_APP_ID,
+      reportId: "report1",
+      body: { skip: 0, top: 10 },
+    });
+    const apiCall = mockFetch.mock.calls.find((call) =>
+      call[0].includes("/reports/")
+    )![1];
+    expect(apiCall.method).toBe("POST");
+  });
+
+  it("uses PUT for changesetSolution", async () => {
+    setupMockFetchForChangeset();
+    await clientUser.changesetSolution({
+      solutionId: "solution1",
+      body: "name: Test Solution\nversion: 1.0",
+    });
+    const apiCall = mockFetch.mock.calls[0][1];
+    expect(apiCall.method).toBe("PUT");
+  });
+
+  it("uses GET for getTable", async () => {
+    setupMockFetch();
+    await clientTemp.getTable({ appId: QB_APP_ID, tableId: "table1" });
+    const apiCall = mockFetch.mock.calls.find((call) =>
+      call[0].includes("/tables/")
+    )![1];
+    expect(apiCall.method).toBe("GET");
+  });
+
+  it("uses DELETE for deleteTable", async () => {
+    setupMockFetch();
+    await clientTemp.deleteTable({ appId: QB_APP_ID, tableId: "table1" });
+    const apiCall = mockFetch.mock.calls.find((call) =>
+      call[0].includes("/tables/")
+    )![1];
+    expect(apiCall.method).toBe("DELETE");
+  });
+});