quickbase-js 0.1.0-beta.9 → 1.0.0

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

@@ -1,285 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

@@ -1,34 +0,0 @@
-// 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/inferHttpMethod.test.ts

@@ -1,131 +0,0 @@
-// tests/vitest/unit/inferHttpMethod.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 - inferHttpMethod", () => {
-  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("correctly identifies POST for updateApp", async () => {
-    setupMockFetch();
-    await clientTemp.updateApp({
-      appId: QB_APP_ID,
-      body: { name: "Test App" },
-    });
-    const call = mockFetch.mock.calls[1];
-    expect(call[1].method).toBe("POST");
-  });
-
-  it("correctly identifies POST for runReport", async () => {
-    setupMockFetch();
-    await clientTemp.runReport({
-      tableId: QB_APP_ID,
-      reportId: "report1",
-      body: { skip: 0, top: 10 },
-    });
-    const call = mockFetch.mock.calls[1];
-    expect(call[1].method).toBe("POST");
-  });
-
-  it("correctly identifies PUT for changesetSolution", async () => {
-    setupMockFetchForChangeset();
-    await clientUser.changesetSolution({
-      solutionId: "solution1",
-      body: "name: Test Solution\nversion: 1.0",
-    });
-    const call = mockFetch.mock.calls[0];
-    expect(call[1].method).toBe("PUT");
-  });
-
-  it("correctly identifies GET for getTable", async () => {
-    setupMockFetch();
-    await clientTemp.getTable({ appId: QB_APP_ID, tableId: "table1" });
-    const call = mockFetch.mock.calls[1];
-    expect(call[1].method).toBe("GET");
-  });
-
-  it("correctly identifies DELETE for deleteTable", async () => {
-    setupMockFetch();
-    await clientTemp.deleteTable({ appId: QB_APP_ID, tableId: "table1" });
-    const call = mockFetch.mock.calls[1];
-    expect(call[1].method).toBe("DELETE");
-  });
-});