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

package/tests/vitest/qb/auth/ssoTokenConcurrency.test.ts

@@ -0,0 +1,68 @@
+// tests/vitest/qb/auth/ssoTokenConcurrency.test.ts
+import { test, expect, vi } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+import { startMockQuickbaseServer } from "./mockQuickbaseServer";
+import { QB_APP_ID, QB_REALM } from "@tests/setup.ts";
+
+test(
+  "QuickbaseClient Integration - getApp with SsoTokenStrategy Concurrency",
+  async () => {
+    const mockServer = startMockQuickbaseServer(3000);
+
+    // Spy on console.log before any actions
+    const consoleSpy = vi.spyOn(console, "log");
+
+    try {
+      const client = quickbase({
+        realm: QB_REALM,
+        useSso: true,
+        samlToken: "mock-saml-token",
+        debug: true,
+        baseUrl: "http://localhost:3000/v1",
+      });
+
+      const concurrentRequests = [
+        client.getApp({ appId: QB_APP_ID }),
+        client.getApp({ appId: QB_APP_ID }),
+        client.getApp({ appId: QB_APP_ID }),
+      ];
+
+      const results = await Promise.all(concurrentRequests);
+
+      expect(results).toHaveLength(3);
+      results.forEach((result) =>
+        expect(result).toEqual({
+          id: QB_APP_ID,
+          name: "Mock App",
+          created: expect.any(Date),
+          updated: expect.any(Date),
+        })
+      );
+
+      // Verify token fetch and waits using console logs
+      const logs = consoleSpy.mock.calls;
+      const tokenFetchLogs = logs.filter((call) =>
+        call[0].includes("[fetchSsoToken] Fetched token")
+      );
+      expect(tokenFetchLogs).toHaveLength(1); // Single fetch with synchronization
+
+      const waitLogs = logs.filter((call) =>
+        call[0].includes("Waiting for existing SSO fetch")
+      );
+      expect(waitLogs.length).toBeGreaterThanOrEqual(2); // At least two waits
+
+      const appRequestLogs = logs.filter((call) =>
+        call[0].includes("Received getApp request")
+      );
+      expect(appRequestLogs).toHaveLength(3);
+
+      console.log(
+        "SsoTokenStrategy: Single token fetch with concurrent waits confirmed."
+      );
+    } finally {
+      mockServer.close();
+      consoleSpy.mockRestore();
+    }
+  },
+  { timeout: 20000 }
+);

package/tests/vitest/qb/auth/userTokenConcurrency.test.ts

@@ -0,0 +1,63 @@
+// tests/vitest/qb/auth/userTokenConcurrency.test.ts
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getApp with UserToken Concurrency",
+  async () => {
+    const realm = process.env.QB_REALM || "";
+    const appId = process.env.QB_APP_ID || "";
+    const userToken = process.env.QB_USER_TOKEN || "";
+
+    if (!realm || !appId || !userToken) {
+      throw new Error(
+        "QB_REALM, QB_APP_ID, and QB_USER_TOKEN must be set in .env"
+      );
+    }
+
+    const client = quickbase({
+      realm,
+      userToken,
+      debug: true,
+    });
+
+    const concurrentRequests = [
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    const expectedAppData = {
+      id: appId,
+      name: "qb-copy",
+      created: expect.any(Date),
+      updated: expect.any(Date),
+      description: "",
+      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,
+      },
+      ancestorId: undefined,
+      dataClassification: undefined,
+      variables: [{ name: "TestVar", value: "TestValue" }],
+    };
+
+    expect(results).toHaveLength(3);
+    results.forEach((result) => expect(result).toEqual(expectedAppData));
+
+    console.log(
+      "UserTokenStrategy: All concurrent requests used static token."
+    );
+  },
+  { timeout: 20000 }
+);

package/tests/vitest/unit/apps/getAppConcurrency.test.ts

@@ -0,0 +1,151 @@
+// tests/vitest/unit/apps/getAppConcurrency.test.ts
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch, QB_APP_ID, QB_REALM } from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getApp Concurrency with Temp Tokens", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    // Reset client before each test
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true, // Use TempTokenStrategy
+      debug: true,
+    });
+  });
+
+  it("handles concurrent getApp requests with a single token fetch", async () => {
+    // Mock the token fetch response
+    const tempTokenResponse = {
+      temporaryAuthorization: "temp-token-123",
+    };
+    mockFetch.mockImplementation((url: string, options: RequestInit) => {
+      if (url.includes(`/auth/temporary/${QB_APP_ID}`)) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve(tempTokenResponse),
+        });
+      }
+      // Mock the getApp response
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            id: QB_APP_ID,
+            name: "test-app",
+            created: "2025-02-13T18:22:33Z",
+            updated: "2025-03-04T04:25:51Z",
+          }),
+      });
+    });
+
+    // Simulate concurrent getApp requests
+    const concurrentRequests = [
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    // Assertions
+    expect(results).toHaveLength(3); // All requests completed
+    results.forEach((result) => {
+      expect(result).toEqual({
+        id: QB_APP_ID,
+        name: "test-app",
+        created: expect.any(Date), // Assuming convertDates is true
+        updated: expect.any(Date),
+      });
+    });
+
+    // Verify token fetch was called exactly once
+    const tokenFetchCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/auth/temporary/${QB_APP_ID}`)
+    );
+    expect(tokenFetchCalls).toHaveLength(1); // Only one token fetch despite 3 requests
+
+    // Verify getApp calls were made with the temp token
+    const getAppCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/apps/${QB_APP_ID}`)
+    );
+    expect(getAppCalls).toHaveLength(3); // Three getApp requests
+    getAppCalls.forEach((call) => {
+      expect(call[1].headers).toMatchObject({
+        Authorization: `QB-TEMP-TOKEN ${tempTokenResponse.temporaryAuthorization}`,
+        "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        "Content-Type": "application/json",
+      });
+    });
+  });
+
+  it("handles concurrent getApp requests with cached token", async () => {
+    // Pre-populate the token cache by making an initial request
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({ temporaryAuthorization: "cached-token-456" }),
+    });
+    await client.getApp({ appId: QB_APP_ID }); // This caches the token
+
+    // Reset mock to clear initial call tracking
+    mockFetch.mockClear();
+
+    // Mock only the getApp response now (no token fetch needed)
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          id: QB_APP_ID,
+          name: "test-app",
+          created: "2025-02-13T18:22:33Z",
+          updated: "2025-03-04T04:25:51Z",
+        }),
+    });
+
+    // Simulate concurrent getApp requests with cached token
+    const concurrentRequests = [
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    // Assertions
+    expect(results).toHaveLength(3); // All requests completed
+    results.forEach((result) => {
+      expect(result).toEqual({
+        id: QB_APP_ID,
+        name: "test-app",
+        created: expect.any(Date),
+        updated: expect.any(Date),
+      });
+    });
+
+    // Verify no token fetches occurred (cache was used)
+    const tokenFetchCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/auth/temporary/${QB_APP_ID}`)
+    );
+    expect(tokenFetchCalls).toHaveLength(0); // No token fetches
+
+    // Verify getApp calls were made with the cached token
+    const getAppCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/apps/${QB_APP_ID}`)
+    );
+    expect(getAppCalls).toHaveLength(3); // Three getApp requests
+    getAppCalls.forEach((call) => {
+      expect(call[1].headers).toMatchObject({
+        Authorization: `QB-TEMP-TOKEN cached-token-456`,
+        "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        "Content-Type": "application/json",
+      });
+    });
+  });
+});

package/tests/vitest/unit/auth/fetchTempToken401.test.ts

@@ -42,7 +42,7 @@ describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
           json: () => Promise.resolve({ message: "Temp token fetch failed" }),
         });
       }
-      return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
+      throw new Error(`Unexpected fetch call: ${url}`); // Use throw to stop further retries
     });
 
     const consoleSpy = vi.spyOn(console, "log");
@@ -52,8 +52,26 @@ describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
     );
 
     expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: `QB-TEMP-TOKEN ${mockToken}`,
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      3,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
 
-    // Updated to match the single-argument log from handleError
     expect(consoleSpy).toHaveBeenCalledWith(
       "Authorization error for getFields (temp token), refreshing token:"
     );

package/tests/vitest/unit/auth/userTokenConcurrency.test.ts

@@ -0,0 +1,62 @@
+// tests/vitest/unit/auth/userTokenConcurrency.test.ts
+import { describe, it, expect, vi } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+import { QB_APP_ID, QB_REALM, QB_USER_TOKEN, mockFetch } from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - UserTokenStrategy Concurrency", () => {
+  it("handles concurrent getApp requests with static user token", async () => {
+    mockFetch.mockClear();
+    const client = quickbase({
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+      fetchApi: mockFetch,
+    });
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          id: QB_APP_ID,
+          name: "test-app",
+          created: "2025-02-13T18:22:33Z",
+          updated: "2025-03-22T04:00:18Z",
+        }),
+    });
+
+    const concurrentRequests = [
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    expect(results).toHaveLength(3);
+    results.forEach((result) =>
+      expect(result).toEqual({
+        id: QB_APP_ID,
+        name: "test-app",
+        created: expect.any(Date),
+        updated: expect.any(Date),
+      })
+    );
+
+    const appCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/apps/${QB_APP_ID}`)
+    );
+    expect(appCalls).toHaveLength(3);
+    appCalls.forEach((call) =>
+      expect(call[1].headers).toMatchObject({
+        Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+      })
+    );
+
+    // No token fetches occur with UserTokenStrategy
+    const tokenFetchCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes("/auth")
+    );
+    expect(tokenFetchCalls).toHaveLength(0);
+  });
+});

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/retryTempTokenTwo401.test.ts";
+export * from "./auth/retryTempTokenMaxRetries.test.ts";
 
 // Fields
 export * from "./fields/getFields.test.ts";

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

@@ -1,13 +1,13 @@
 // tests/vitest/unit/quickbaseClient.test.ts
 
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { quickbase } from "../../../src/quickbaseClient";
+import { quickbase } from "../../../src/quickbaseClient.ts";
 import { mockFetch, QB_APP_ID, QB_REALM } from "../../setup.ts";
 import {
   UpdateAppRequest,
   UpdateApp200Response,
-} from "../../../src/generated/models";
-import { ChangesetSolution200Response } from "../../../src/generated/models";
+} from "../../../src/generated/models/index.ts";
+import { ChangesetSolution200Response } from "../../../src/generated/models/index.ts";
 
 describe("QuickbaseClient Unit - HTTP Method Extraction", () => {
   let clientTemp: ReturnType<typeof quickbase>;

package/tools/log-gen.ts

@@ -53,7 +53,7 @@ const includeFiles: string[] = [
   "src/generated-unified/QuickbaseClient.ts",
   "src/authorizationStrategy.ts",
   "src/rateLimiter.ts",
-  // "src/RateLimitError.ts",
+  "src/RateLimitError.ts",
   "src/ThrottleBucket.ts",
   "src/tokenCache.ts",
   "src/utils.ts",