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

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

@@ -0,0 +1,191 @@
+// tests/vitest/unit/rateLimit.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+import { RateLimitError } from "@/RateLimitError";
+import { GetApp200Response } from "@/generated/models";
+
+describe("QuickbaseClient Unit - Rate Limit Handling", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it("succeeds after retrying on 429 Too Many Requests", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+      maxRetries: 2,
+      retryDelay: 100,
+      throttle: { rate: 10, burst: 10 },
+    });
+
+    const appId = QB_APP_ID;
+
+    const mockResponse: GetApp200Response = {
+      id: appId,
+      name: "TestApp",
+      created: "2025-01-01T00:00:00Z",
+      updated: "2025-01-02T00:00:00Z",
+      description: "Test app",
+      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,
+      },
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 429,
+        headers: new Headers({ "Retry-After": "1" }),
+        json: () => Promise.resolve({ message: "Too Many Requests" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const result = await client.getApp({ appId });
+
+    expect(result).toEqual({
+      ...mockResponse,
+      created: new Date("2025-01-01T00:00:00Z"),
+      updated: new Date("2025-01-02T00:00:00Z"),
+    });
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/apps/${appId}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        credentials: "omit",
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/apps/${appId}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+        credentials: "omit",
+      })
+    );
+  });
+
+  it("throws RateLimitError after max retries on 429", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+      maxRetries: 1,
+      retryDelay: 100,
+      throttle: { rate: 10, burst: 10 },
+    });
+
+    const appId = QB_APP_ID;
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 429,
+        headers: new Headers({ "Retry-After": "1" }),
+        json: () => Promise.resolve({ message: "Too Many Requests" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 429,
+        headers: new Headers({ "Retry-After": "1" }),
+        json: () => Promise.resolve({ message: "Too Many Requests" }),
+      });
+
+    await expect(client.getApp({ appId })).rejects.toMatchObject({
+      name: "RateLimitError",
+      message: "API Error: Too Many Requests (Status: 429)",
+      status: 429,
+      retryAfter: 1,
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("respects throttle limits without exceeding rate", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+      throttle: { rate: 5, burst: 5 },
+      maxRetries: 0, // Prevent retries for this test
+    });
+
+    const appId = QB_APP_ID;
+
+    const mockResponse: GetApp200Response = {
+      id: appId,
+      name: "TestApp",
+      created: "2025-01-01T00:00:00Z",
+      updated: "2025-01-02T00:00:00Z",
+      description: "Test app",
+      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,
+      },
+    };
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const startTime = Date.now();
+    await Promise.all([
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      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); // 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",
+        }),
+      })
+    );
+  });
+});