quickbase-js 0.1.0-beta.8 → 0.1.0-beta.9

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

@@ -9,7 +9,7 @@ export * from "./apps/getApp.test.ts";
 export * from "./auth/fetchTempToken401.test.ts";
 export * from "./auth/getTempToken.test.ts";
 export * from "./auth/retryOn401.test.ts";
-export * from "./auth/two401s.test.ts";
+export * from "./auth/retryTempTokenTwo401.test.ts";
 
 // Fields
 export * from "./fields/getFields.test.ts";
@@ -31,3 +31,4 @@ 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

@@ -0,0 +1,131 @@
+// 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");
+  });
+});

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

@@ -140,6 +140,7 @@ describe("QuickbaseClient Unit - Rate Limit Handling", () => {
       userToken: QB_USER_TOKEN,
       debug: true,
       throttle: { rate: 5, burst: 5 },
+      maxRetries: 0, // Prevent retries for this test
     });
 
     const appId = QB_APP_ID;
@@ -177,13 +178,14 @@ describe("QuickbaseClient Unit - Rate Limit Handling", () => {
       client.getApp({ appId }),
       client.getApp({ appId }),
       client.getApp({ appId }),
-      client.getApp({ appId }), // 6th call triggers throttle
+      client.getApp({ appId }), // 6th call should be throttled
     ]);
     const endTime = Date.now();
     const durationMs = endTime - startTime;
 
+    console.log(`[Test Debug] mockFetch calls: ${mockFetch.mock.calls.length}`);
     expect(mockFetch).toHaveBeenCalledTimes(6);
-    expect(durationMs).toBeGreaterThanOrEqual(200);
+    expect(durationMs).toBeGreaterThanOrEqual(200); // 1/5 sec for 6th call
     expect(durationMs).toBeLessThan(1000);
   });
 });

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

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_TABLE_ID_1,
+  QB_TABLE_ID_2,
+} from "@tests/setup.ts";
+import {
+  CreateRelationship200Response,
+  CreateRelationshipRequest,
+} from "/home/drew/Projects/quickbase-js/src/generated/models";
+
+describe("QuickbaseClient Unit - createRelationship", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has createRelationship method", () => {
+    expect(typeof client.createRelationship).toBe("function");
+  });
+
+  it("sends correct request and handles successful response", async () => {
+    const mockResponse: CreateRelationship200Response = {
+      id: 6,
+      foreignKeyField: {
+        id: 6,
+        label: "my relationship field",
+        type: "numeric",
+      },
+      lookupFields: [
+        { id: 7, label: "Field 1", type: "text" },
+        { id: 8, label: "Field 2", type: "text" },
+        { id: 9, label: "Field 3", type: "text" },
+      ],
+      isCrossApp: false,
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+      summaryFields: [
+        { id: 10, label: "my first summary field", type: "numeric" },
+        { id: 11, label: "my second summary field", type: "numeric" },
+      ],
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: "my relationship field" },
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: [
+        {
+          summaryFid: 3,
+          label: "my first summary field",
+          accumulationType: "AVG",
+          where: "{'3'.EX.1}",
+        },
+        {
+          summaryFid: 4,
+          label: "my second summary field",
+          accumulationType: "SUM",
+        },
+      ],
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    const result = await client.createRelationship({
+      tableId,
+      body: requestBody,
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      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(requestBody),
+      })
+    );
+    expect(result).toEqual(mockResponse);
+    expect(result.id).toBe(6);
+    expect(result.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(result.childTableId).toBe(QB_TABLE_ID_2);
+    expect(result.foreignKeyField).toBeDefined();
+    if (result.foreignKeyField) {
+      expect(result.foreignKeyField.label).toBe("my relationship field");
+    }
+    expect(result.lookupFields).toHaveLength(3);
+    expect(result.summaryFields).toBeDefined();
+    if (result.summaryFields) {
+      expect(result.summaryFields).toHaveLength(2);
+      expect(result.summaryFields[0].label).toBe("my first summary field");
+      expect(result.summaryFields[1].label).toBe("my second summary field");
+    }
+  });
+
+  it("handles error from TablesApi", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid request payload" }),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: "my relationship field" },
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: [
+        { summaryFid: 3, label: "invalid", accumulationType: "INVALID" },
+      ],
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    await expect(
+      client.createRelationship({
+        tableId,
+        body: requestBody,
+      })
+    ).rejects.toThrow("API Error: Invalid request payload (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      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(requestBody),
+      })
+    );
+  });
+
+  it("handles response with undefined foreignKeyField and summaryFields", async () => {
+    const mockResponse: CreateRelationship200Response = {
+      id: 6,
+      foreignKeyField: undefined,
+      lookupFields: [
+        { id: 7, label: "Field 1", type: "text" },
+        { id: 8, label: "Field 2", type: "text" },
+        { id: 9, label: "Field 3", type: "text" },
+      ],
+      isCrossApp: false,
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+      summaryFields: undefined,
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: undefined,
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: undefined,
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    const result = await client.createRelationship({
+      tableId,
+      body: requestBody,
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      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(requestBody),
+      })
+    );
+    expect(result).toEqual(mockResponse);
+    expect(result.id).toBe(6);
+    expect(result.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(result.childTableId).toBe(QB_TABLE_ID_2);
+    expect(result.foreignKeyField).toBeUndefined();
+    expect(result.lookupFields).toHaveLength(3);
+    expect(result.summaryFields).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,97 @@
+// tests/vitest/unit/tables/deleteRelationship.test.ts
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_TABLE_ID_2, // Child table
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - deleteRelationship", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has deleteRelationship method", () => {
+    expect(typeof client.deleteRelationship).toBe("function");
+  });
+
+  it("sends correct DELETE request and handles successful response", async () => {
+    // Mock response for a successful deletion
+    const mockResponse = {
+      deletedRelationshipId: 6, // Matches the relationshipId
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const tableId = QB_TABLE_ID_2; // Child table
+    const relationshipId = 6; // Example relationship ID (foreign key field ID)
+
+    const result = await client.deleteRelationship({
+      tableId,
+      relationshipId,
+    });
+
+    // Verify the fetch call
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship/6`,
+      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",
+        }),
+      })
+    );
+
+    // Verify the response
+    expect(result).toEqual(mockResponse);
+    expect(result.deletedRelationshipId).toBe(6);
+  });
+
+  it("handles error when relationship is not found", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      json: () => Promise.resolve({ message: "Relationship not found" }),
+    });
+
+    const tableId = QB_TABLE_ID_2;
+    const relationshipId = 999; // Non-existent relationship ID
+
+    await expect(
+      client.deleteRelationship({
+        tableId,
+        relationshipId,
+      })
+    ).rejects.toThrow("API Error: Relationship not found (Status: 404)");
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship/999`,
+      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",
+        }),
+      })
+    );
+  });
+});