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

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

@@ -0,0 +1,251 @@
+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/{quickbaseClientHttpMethods.test.ts → quickbase-js/quickbaseClientHttpMethods.test.ts}

@@ -1,13 +1,11 @@
-// tests/vitest/unit/quickbaseClient.test.ts
-
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { quickbase } from "../../../src/quickbaseClient.ts";
-import { mockFetch, QB_APP_ID, QB_REALM } from "../../setup.ts";
+import { quickbase } from "@/quickbaseClient";
+import { mockFetch, QB_APP_ID, QB_REALM } from "../../../setup.ts";
 import {
   UpdateAppRequest,
   UpdateApp200Response,
-} from "../../../src/generated/models/index.ts";
-import { ChangesetSolution200Response } from "../../../src/generated/models/index.ts";
+} 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>;
@@ -58,7 +56,9 @@ describe("QuickbaseClient Unit - HTTP Method Extraction", () => {
     dataClassification: "None",
   };
 
-  const mockChangesetResponse: ChangesetSolution200Response = [{ changes: [] }];
+  const mockChangesetResponse: ChangesetSolutionFromRecord200Response = [
+    { changes: [] },
+  ];
 
   const setupMockFetch = () => {
     mockFetch.mockReset();
@@ -109,14 +109,16 @@ describe("QuickbaseClient Unit - HTTP Method Extraction", () => {
     expect(apiCall.method).toBe("POST");
   });
 
-  it("uses PUT for changesetSolution", async () => {
+  it("uses GET for changesetSolutionFromRecord", async () => {
     setupMockFetchForChangeset();
-    await clientUser.changesetSolution({
+    await clientUser.changesetSolutionFromRecord({
       solutionId: "solution1",
-      body: "name: Test Solution\nversion: 1.0",
+      tableId: "table1",
+      fieldId: 6,
+      recordId: "123",
     });
     const apiCall = mockFetch.mock.calls[0][1];
-    expect(apiCall.method).toBe("PUT");
+    expect(apiCall.method).toBe("GET");
   });
 
   it("uses GET for getTable", async () => {

package/tests/vitest/unit/records/runQuery.test.ts

@@ -1,4 +1,3 @@
-// tests/vitest/unit/records/runQuery.test.ts
 import { describe, test, expect, beforeEach } from "vitest";
 import {
   createClient,
@@ -7,7 +6,7 @@ import {
   QB_USER_TOKEN,
   QB_TABLE_ID_1,
 } from "@tests/setup.ts";
-import { RunQueryRequest, RunQueryResponse } from "@/generated";
+import { RunQueryRequest, RunQuery200Response } from "@/generated";
 
 describe("QuickbaseClient Unit - runQuery", () => {
   let client: ReturnType<typeof createClient>;
@@ -27,7 +26,7 @@ describe("QuickbaseClient Unit - runQuery", () => {
       options: { skip: 0, top: 100, compareWithAppLocalTime: false },
     };
 
-    const mockResponse: RunQueryResponse = {
+    const mockResponse: RunQuery200Response = {
       data: [
         { "3": { value: 1 }, "6": { value: "Task 1" }, "7": { value: "High" } },
       ],
@@ -40,7 +39,7 @@ describe("QuickbaseClient Unit - runQuery", () => {
         numFields: 3,
         numRecords: 1,
         skip: 0,
-        top: 100,
+        // top is omitted or undefined in the final response unless pagination continues
         totalRecords: 1,
       },
     };

package/src/ThrottleBucket.ts

@@ -1,41 +0,0 @@
-// src/ThrottleBucket.ts
-export class ThrottleBucket {
-  private tokens: number;
-  private maxTokens: number;
-  private refillRate: number; // Tokens per second
-  private lastRefill: number;
-  private pending: Promise<void> = Promise.resolve(); // Queue for sequential execution
-
-  constructor(rate: number, burst: number) {
-    this.tokens = burst;
-    this.maxTokens = burst;
-    this.refillRate = rate;
-    this.lastRefill = Date.now();
-  }
-
-  private refill(): void {
-    const now = Date.now();
-    const elapsed = (now - this.lastRefill) / 1000; // Seconds elapsed
-    const newTokens = elapsed * this.refillRate;
-    this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
-    this.lastRefill = now;
-  }
-
-  async acquire(): Promise<void> {
-    // Chain the new acquisition onto the pending queue
-    const previous = this.pending;
-    this.pending = (async () => {
-      await previous; // Wait for prior calls to complete
-      this.refill();
-      if (this.tokens >= 1) {
-        this.tokens -= 1;
-        return;
-      }
-      const waitTime = ((1 - this.tokens) / this.refillRate) * 1000; // ms until next token
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      this.refill();
-      this.tokens -= 1;
-    })();
-    await this.pending;
-  }
-}

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

@@ -1,8 +0,0 @@
-// tests/vitest/unit/umd.test.ts
-import { test, expect } from "vitest";
-const quickbaseUMD = require("../../dist/umd/quickbase.umd.js");
-const { quickbase: quickbaseESM } = await import("../../dist/esm/quickbase.js");
-test("UMD and ESM builds work in Node.js", () => {
-  expect(quickbaseUMD).toBeDefined();
-  expect(quickbaseESM).toBeDefined();
-});