quickbase-js 0.1.0-beta.13 → 0.1.0-beta.14

package/tests/vitest/unit/quickbase-js/FlowBucket.test.ts

@@ -1,101 +0,0 @@
-// test/vitest/unit/ThrottleBucket.test.ts
-import { describe, it, expect, vi } from "vitest";
-import { FlowThrottleBucket } from "@/FlowThrottleBucket"; // Should work with your alias
-
-describe("ConcurrentThrottleBucket Unit Tests", () => {
-  it("allows burst capacity immediately", async () => {
-    const bucket = new FlowThrottleBucket(5, 3); // rate: 5, burst: 3
-    const startTime = Date.now();
-
-    await Promise.all([
-      bucket.acquire().then(() => bucket.release()),
-      bucket.acquire().then(() => bucket.release()),
-      bucket.acquire().then(() => bucket.release()),
-    ]);
-
-    const duration = Date.now() - startTime;
-    expect(duration).toBeLessThan(50); // All 3 should be instant (within 50ms)
-  });
-
-  it("delays calls beyond burst at correct rate", async () => {
-    const bucket = new FlowThrottleBucket(5, 3); // rate: 5 tokens/sec, burst: 3
-    const timings: number[] = [];
-    const recordTime = async () => {
-      await bucket.acquire();
-      timings.push(Date.now());
-      bucket.release(); // Release slot
-    };
-
-    const startTime = Date.now();
-    await Promise.all([
-      recordTime(),
-      recordTime(),
-      recordTime(),
-      recordTime(), // 4th call should delay
-    ]);
-
-    const durations = timings.map((t) => t - startTime);
-    expect(durations.length).toBe(4);
-    expect(durations[0]).toBeLessThan(50); // 1st call instant
-    expect(durations[1]).toBeLessThan(50); // 2nd call instant
-    expect(durations[2]).toBeLessThan(50); // 3rd call instant
-    expect(durations[3]).toBeGreaterThanOrEqual(180); // 4th call delayed ~200ms
-    expect(durations[3]).toBeLessThan(250); // Shouldn’t exceed 250ms
-  });
-
-  it("maintains rate over sustained calls", async () => {
-    const bucket = new FlowThrottleBucket(2, 2); // rate: 2 tokens/sec, burst: 2
-    const timings: number[] = [];
-    const recordTime = async () => {
-      await bucket.acquire();
-      timings.push(Date.now());
-      bucket.release(); // Release slot
-    };
-
-    const startTime = Date.now();
-    await Promise.all([
-      recordTime(),
-      recordTime(),
-      recordTime(),
-      recordTime(),
-      recordTime(), // 5 calls total
-    ]);
-
-    const durations = timings.map((t) => t - startTime);
-    expect(durations.length).toBe(5);
-    expect(durations[0]).toBeLessThan(50); // 1st instant
-    expect(durations[1]).toBeLessThan(50); // 2nd instant
-    expect(durations[2]).toBeGreaterThanOrEqual(450); // 3rd delayed ~500ms (1/2 sec)
-    expect(durations[2]).toBeLessThan(550);
-    expect(durations[3]).toBeGreaterThanOrEqual(950); // 4th delayed ~1000ms
-    expect(durations[3]).toBeLessThan(1050);
-    expect(durations[4]).toBeGreaterThanOrEqual(1450); // 5th delayed ~1500ms
-    expect(durations[4]).toBeLessThan(1550);
-  });
-
-  it("handles high concurrency without exceeding burst", async () => {
-    const bucket = new FlowThrottleBucket(5, 3); // rate: 5, burst: 3
-    const timings: number[] = [];
-    const recordTime = async () => {
-      await bucket.acquire();
-      timings.push(Date.now());
-      bucket.release(); // Release slot
-    };
-
-    const startTime = Date.now();
-    await Promise.all(
-      Array(10)
-        .fill(null)
-        .map(() => recordTime())
-    ); // 10 concurrent calls
-
-    const durations = timings.map((t) => t - startTime);
-    expect(durations.length).toBe(10);
-    expect(durations.slice(0, 3).every((d) => d < 50)).toBe(true); // First 3 instant
-    for (let i = 3; i < 10; i++) {
-      const expectedDelay = (i - 2) * 200; // After burst, 200ms per token
-      expect(durations[i]).toBeGreaterThanOrEqual(expectedDelay - 50);
-      expect(durations[i]).toBeLessThan(expectedDelay + 50);
-    }
-  });
-});

package/tests/vitest/unit/quickbase-js/pagination.test.ts

@@ -1,251 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { paginateRecords, isPaginatable } from "@/pagination";
-import { QuickbaseClient } from "@/quickbaseClient";
-import * as invokeMethodModule from "@/invokeMethod";
-import { GetUsers200Response, GetUsersRequest } from "@/generated/models";
-
-// Extend GetUsersRequest to include nextPageToken
-interface TestGetUsersRequest extends GetUsersRequest {
-  nextPageToken?: string;
-}
-
-describe("Pagination Unit Tests", () => {
-  const methodMap = {
-    runQuery: {
-      api: {},
-      method: vi.fn(),
-      paramMap: ["body"],
-      httpMethod: "POST",
-    },
-    getUsers: {
-      api: {},
-      method: vi.fn(),
-      paramMap: ["body"],
-      httpMethod: "POST",
-    },
-  } as any;
-  const baseHeaders = {};
-  const authStrategy = {
-    getToken: vi.fn(),
-    applyHeaders: vi.fn(),
-    handleError: vi.fn(),
-  } as any;
-  const rateLimiter = {
-    throttle: vi.fn(),
-    release: vi.fn(),
-    maxRetries: 3,
-  } as any;
-  const transformDates = (obj: any) => obj;
-
-  it("fetches all pages for runQuery with skip-based pagination", async () => {
-    const mockInvoke = vi
-      .spyOn(invokeMethodModule, "invokeMethod")
-      .mockResolvedValueOnce({
-        data: Array(2429).fill({ "3": { value: "record" } }),
-        metadata: {
-          totalRecords: 5000,
-          numRecords: 2429,
-          numFields: 6,
-          skip: 0,
-        },
-      })
-      .mockResolvedValueOnce({
-        data: Array(2429).fill({ "3": { value: "record" } }),
-        metadata: {
-          totalRecords: 5000,
-          numRecords: 2429,
-          numFields: 6,
-          skip: 2429,
-        },
-      })
-      .mockResolvedValueOnce({
-        data: Array(142).fill({ "3": { value: "record" } }),
-        metadata: {
-          totalRecords: 5000,
-          numRecords: 142,
-          numFields: 6,
-          skip: 4858,
-        },
-      });
-
-    const result = await paginateRecords(
-      "runQuery",
-      { body: { from: "mock-table", select: [3, 6] } },
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true
-    );
-
-    expect(mockInvoke).toHaveBeenCalledTimes(3);
-    expect(result.data.length).toBe(5000);
-    expect(result.metadata).toEqual({
-      totalRecords: 5000,
-      numRecords: 5000,
-      numFields: 6,
-      skip: 0,
-      top: undefined,
-    });
-  });
-
-  it("fetches all pages for getUsers with token-based pagination", async () => {
-    const mockInvoke = vi
-      .spyOn(invokeMethodModule, "invokeMethod")
-      .mockImplementation(
-        async <K extends keyof QuickbaseClient>(
-          methodName: K,
-          params: Parameters<QuickbaseClient[K]>[0] & {
-            skip?: number;
-            top?: number;
-          },
-          methodMap: any,
-          baseHeaders: any,
-          authStrategy: any,
-          rateLimiter: any,
-          transformDates: any,
-          debug: any,
-          convertDates: any,
-          autoPaginate: any,
-          attempt: any,
-          maxAttempts: any,
-          isPaginating: any
-        ): Promise<ReturnType<QuickbaseClient[K]>> => {
-          if (methodName !== "getUsers")
-            throw new Error("Mock only supports 'getUsers'");
-          const body = (params as { body?: TestGetUsersRequest }).body;
-          const token = body?.nextPageToken;
-          if (!token) {
-            return {
-              users: Array(10).fill({ id: "user1" }),
-              metadata: { nextPageToken: "token1" },
-            } as GetUsers200Response as ReturnType<QuickbaseClient[K]>;
-          } else if (token === "token1") {
-            return {
-              users: Array(5).fill({ id: "user2" }),
-              metadata: { nextPageToken: "token2" },
-            } as GetUsers200Response as ReturnType<QuickbaseClient[K]>;
-          } else if (token === "token2") {
-            return {
-              users: Array(3).fill({ id: "user3" }),
-              metadata: { nextPageToken: "" },
-            } as GetUsers200Response as ReturnType<QuickbaseClient[K]>;
-          }
-          throw new Error("Unexpected token");
-        }
-      );
-
-    const result = await paginateRecords(
-      "getUsers",
-      { body: { userIds: ["id1", "id2"] } },
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true
-    );
-
-    expect(mockInvoke).toHaveBeenCalledTimes(3);
-    expect(mockInvoke).toHaveBeenNthCalledWith(
-      1,
-      "getUsers",
-      expect.objectContaining({ body: { userIds: ["id1", "id2"] } }),
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true,
-      false,
-      0,
-      4,
-      true
-    );
-    expect(mockInvoke).toHaveBeenNthCalledWith(
-      2,
-      "getUsers",
-      expect.objectContaining({
-        body: { userIds: ["id1", "id2"], nextPageToken: "token1" },
-      }),
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true,
-      false,
-      0,
-      4,
-      true
-    );
-    expect(mockInvoke).toHaveBeenNthCalledWith(
-      3,
-      "getUsers",
-      expect.objectContaining({
-        body: { userIds: ["id1", "id2"], nextPageToken: "token2" },
-      }),
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true,
-      false,
-      0,
-      4,
-      true
-    );
-    expect(result.users.length).toBe(18);
-    expect(result.metadata).toEqual({
-      numRecords: 18,
-      numFields: undefined,
-      nextPageToken: "",
-    });
-  });
-
-  it("stops when all skip-based records are fetched in one page", async () => {
-    const mockInvoke = vi
-      .spyOn(invokeMethodModule, "invokeMethod")
-      .mockResolvedValueOnce({
-        data: Array(10).fill({ id: "record" }),
-        metadata: { totalRecords: 10, numRecords: 10, numFields: 3, skip: 0 },
-      });
-
-    const result = await paginateRecords(
-      "runQuery",
-      { body: { from: "mock-table", select: [3] } },
-      methodMap,
-      baseHeaders,
-      authStrategy,
-      rateLimiter,
-      transformDates,
-      false,
-      true
-    );
-
-    expect(mockInvoke).toHaveBeenCalledTimes(1);
-    expect(result.data.length).toBe(10);
-    expect(result.metadata.totalRecords).toBe(10);
-    expect(result.metadata.numRecords).toBe(10);
-  });
-
-  it("isPaginatable detects metadata correctly", () => {
-    const skipResponse = {
-      data: [],
-      metadata: { totalRecords: 100, numRecords: 25, numFields: 3, skip: 0 },
-    };
-    const tokenResponse = { users: [], metadata: { nextPageToken: "abc" } };
-    const invalidResponse = { data: [], other: "stuff" };
-
-    expect(isPaginatable(skipResponse)).toBe(true);
-    expect(isPaginatable(tokenResponse)).toBe(true);
-    expect(isPaginatable(invalidResponse)).toBe(false);
-  });
-});

package/tests/vitest/unit/quickbase-js/quickbaseClientHttpMethods.test.ts

@@ -1,141 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { quickbase } from "@/quickbaseClient";
-import { mockFetch, QB_APP_ID, QB_REALM } from "../../../setup.ts";
-import {
-  UpdateAppRequest,
-  UpdateApp200Response,
-} from "../../../../src/generated/models/index.ts";
-import { ChangesetSolutionFromRecord200Response } from "../../../../src/generated/models/index.ts";
-
-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: ChangesetSolutionFromRecord200Response = [
-    { 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 GET for changesetSolutionFromRecord", async () => {
-    setupMockFetchForChangeset();
-    await clientUser.changesetSolutionFromRecord({
-      solutionId: "solution1",
-      tableId: "table1",
-      fieldId: 6,
-      recordId: "123",
-    });
-    const apiCall = mockFetch.mock.calls[0][1];
-    expect(apiCall.method).toBe("GET");
-  });
-
-  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");
-  });
-});

package/tests/vitest/unit/quickbase-js/rateLimit.test.ts

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