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

package/src/quickbaseClient.ts

@@ -1,11 +1,19 @@
 // src/quickbaseClient.ts
+
 import { QuickbaseClient as IQuickbaseClient } from "./generated-unified/QuickbaseClient";
 import { Configuration, HTTPHeaders } from "./generated/runtime";
 import * as apis from "./generated/apis";
 import { TokenCache } from "./tokenCache";
 import { simplifyName } from "./utils";
-import { invokeMethod, MethodInfo } from "./invokeMethod"; // Added import
+import { invokeMethod, MethodInfo } from "./invokeMethod";
+import {
+  TempTokenStrategy,
+  UserTokenStrategy,
+  AuthorizationStrategy,
+  SsoTokenStrategy,
+} from "./authorizationStrategy";
 import { ThrottleBucket } from "./ThrottleBucket";
+import { RateLimiter } from "./rateLimiter";
 
 export * from "./generated/models/index";
 
@@ -16,13 +24,17 @@ export interface QuickbaseConfig {
   userToken?: string;
   tempToken?: string;
   useTempTokens?: boolean;
+  useSso?: boolean;
+  samlToken?: string;
   debug?: boolean;
   fetchApi?: typeof fetch;
   convertDates?: boolean;
-  tokenLifespan?: number;
+  tempTokenLifespan?: number;
   throttle?: { rate: number; burst: number };
   maxRetries?: number;
   retryDelay?: number;
+  tokenCache?: TokenCache;
+  baseUrl?: string;
 }
 
 type MethodMap = {
@@ -64,11 +76,20 @@ function transformDates(obj: any, convertStringsToDates: boolean = true): any {
 }
 
 function inferHttpMethod(methodSource: string, debug?: boolean): string {
-  const methodMatch = methodSource.match(/method:\s*['"]?(\w+)['"]?/i);
-  const method = methodMatch ? methodMatch[1].toUpperCase() : "GET";
+  const methodMatches = [
+    ...methodSource.matchAll(/method:\s*['"]?(\w+)['"]?/gi),
+  ];
+  const method =
+    methodMatches.length > 0
+      ? methodMatches[methodMatches.length - 1][1].toUpperCase()
+      : "GET";
   if (debug) {
-    // console.log(`[inferHttpMethod] Source:`, methodSource);
-    // console.log(`[inferHttpMethod] Extracted method:`, method);
+    console.log(`[inferHttpMethod] Source:`, methodSource);
+    console.log(
+      `[inferHttpMethod] All matches:`,
+      methodMatches.map((m) => m[0])
+    );
+    console.log(`[inferHttpMethod] Extracted method:`, method);
   }
   return method;
 }
@@ -77,50 +98,59 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
   const {
     realm,
     userToken,
-    tempToken: initialTempToken,
+    tempToken,
     useTempTokens,
+    useSso,
+    samlToken,
     fetchApi,
     debug,
     convertDates = true,
-    tokenLifespan,
+    tempTokenLifespan = 290000,
     throttle = { rate: 10, burst: 10 },
     maxRetries = 3,
     retryDelay = 1000,
+    tokenCache: providedTokenCache,
+    baseUrl = "https://api.quickbase.com/v1",
   } = config;
-  const baseUrl = `https://api.quickbase.com/v1`;
 
-  const tokenCache = new TokenCache(tokenLifespan);
+  const tokenCache = providedTokenCache || new TokenCache(tempTokenLifespan);
   const throttleBucket = throttle
     ? new ThrottleBucket(throttle.rate, throttle.burst)
     : null;
+  const rateLimiter = new RateLimiter(throttleBucket, maxRetries, retryDelay);
+
+  const defaultFetch: typeof fetch | undefined =
+    typeof globalThis.window !== "undefined"
+      ? globalThis.window.fetch.bind(globalThis.window)
+      : undefined;
+  const effectiveFetch = fetchApi || defaultFetch;
+
+  if (!effectiveFetch) {
+    throw new Error("No fetch implementation available");
+  }
+
+  const authStrategy: AuthorizationStrategy = useSso
+    ? new SsoTokenStrategy(samlToken || "", realm, effectiveFetch, debug)
+    : useTempTokens
+    ? new TempTokenStrategy(tokenCache, tempToken)
+    : new UserTokenStrategy(userToken || "");
 
   const baseHeaders: HTTPHeaders = {
     "QB-Realm-Hostname": `${realm}.quickbase.com`,
     "Content-Type": "application/json",
   };
 
-  if (initialTempToken) {
-    baseHeaders["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
-  } else if (userToken && !useTempTokens) {
-    baseHeaders["Authorization"] = `QB-USER-TOKEN ${userToken}`;
-  }
-
-  const defaultFetch: typeof fetch | undefined =
-    typeof globalThis.window !== "undefined"
-      ? globalThis.window.fetch.bind(globalThis.window)
-      : undefined;
   const configuration = new Configuration({
     basePath: baseUrl,
     headers: { ...baseHeaders },
-    fetchApi: fetchApi || defaultFetch,
+    fetchApi: effectiveFetch,
     credentials: "omit",
   });
 
-  if (!configuration.fetchApi && typeof globalThis.window === "undefined") {
-    throw new Error(
-      "fetchApi must be provided in non-browser environments (e.g., Node.js)"
-    );
-  }
+  // Removed redundant check:
+  // if (!configuration.fetchApi && typeof globalThis.window === "undefined") {
+  //   throw new Error("fetchApi must be provided in non-browser environments (e.g., Node.js)");
+  // }
 
   const apiInstances = Object.fromEntries(
     Object.entries(apis)
@@ -131,8 +161,6 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
       ])
   );
 
-  const methodMap = buildMethodMap();
-
   function buildMethodMap(): MethodMap {
     const methodMap: Partial<MethodMap> = {};
     const isValidMethod = (name: string) =>
@@ -159,32 +187,27 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
             const methodSource = method.toString();
             methodMap[simplifiedName] = {
               api,
-              method: boundMethod as any, // Adjust typing as needed
+              method: boundMethod as any,
               paramMap: getParamNames(method),
               httpMethod: inferHttpMethod(methodSource, debug),
             };
           }
         });
     }
+    if (debug) {
+      console.log("[buildMethodMap] Methods:", Object.keys(methodMap));
+    }
     return methodMap as MethodMap;
   }
 
-  const fetchTempToken = async (dbid: string): Promise<string> => {
-    const effectiveFetch = fetchApi || defaultFetch;
-    if (!effectiveFetch) {
-      throw new Error(
-        "No fetch implementation available for fetching temp token"
-      );
-    }
+  const methodMap = buildMethodMap();
 
-    const response = await effectiveFetch(
-      `https://api.quickbase.com/v1/auth/temporary/${dbid}`,
-      {
-        method: "GET",
-        headers: { ...baseHeaders },
-        credentials: "include",
-      }
-    );
+  const fetchTempToken = async (dbid: string): Promise<string> => {
+    const response = await effectiveFetch(`${baseUrl}/auth/temporary/${dbid}`, {
+      method: "GET",
+      headers: { ...baseHeaders },
+      credentials: "include",
+    });
 
     if (!response.ok) {
       const errorBody: { message?: string } = await response.json();
@@ -196,19 +219,26 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
     }
 
     const tokenResult = await response.json();
+    console.log(`[fetchTempToken] Response:`, tokenResult);
     const token = tokenResult.temporaryAuthorization;
     if (!token) {
       throw new Error("No temporary token returned from API");
     }
-    tokenCache.set(dbid, token);
+    tokenCache.set(dbid, token, tempTokenLifespan);
     if (debug) {
       console.log(`Fetched and cached new token for dbid: ${dbid}`, token);
     }
     return token;
   };
 
-  const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, {
-    get: (_, prop: string): ((params: any) => Promise<any>) | undefined => {
+  const proxyHandler: ProxyHandler<QuickbaseClient> = {
+    get: (_, prop: string) => {
+      console.log(
+        "[proxy] Accessing:",
+        prop,
+        "in methodMap:",
+        prop in methodMap
+      );
       if (prop in methodMap) {
         const methodName = prop as keyof QuickbaseClient;
         return (params: Parameters<QuickbaseClient[typeof methodName]>[0]) =>
@@ -217,27 +247,24 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
             params,
             methodMap,
             baseHeaders,
-            tokenCache,
+            authStrategy,
+            rateLimiter,
             fetchTempToken,
             transformDates,
-            initialTempToken,
-            userToken,
-            useTempTokens,
             debug,
-            convertDates,
-            0, // retryCount
-            throttleBucket,
-            maxRetries,
-            retryDelay
+            convertDates
           );
       }
+      console.log("[proxy] Method not found:", prop);
       return undefined;
     },
-  });
+  };
+
+  const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, proxyHandler);
 
   if (debug) {
     console.log("[createClient] Config:", config);
-    console.log("[createClient] Returning:", proxy);
+    console.log("[createClient] Proxy created:", proxy);
   }
 
   return proxy;

package/src/rateLimiter.ts

@@ -0,0 +1,25 @@
+// src/rateLimiter.ts
+import { ThrottleBucket } from "./ThrottleBucket";
+import { ResponseError } from "./generated/runtime";
+
+export class RateLimiter {
+  constructor(
+    private throttleBucket: ThrottleBucket | null,
+    public maxRetries: number = 3,
+    private retryDelay: number = 1000
+  ) {}
+
+  async throttle(): Promise<void> {
+    if (this.throttleBucket) {
+      await this.throttleBucket.acquire();
+    }
+  }
+
+  async handle429(error: ResponseError, attempt: number): Promise<number> {
+    // Remove the throw here; let invokeMethod handle exhaustion
+    const retryAfter = error.response.headers.get("Retry-After");
+    return retryAfter
+      ? parseInt(retryAfter, 10) * 1000
+      : this.retryDelay * Math.pow(2, attempt - 1);
+  }
+}

package/src/tokenCache.ts

@@ -1,50 +1,34 @@
+// src/tokenCache.ts
 interface CachedToken {
   token: string;
-  expiresAt: number; // Timestamp in milliseconds
+  expiresAt: number;
 }
 
 export class TokenCache {
   private cache: Map<string, CachedToken>;
-  private readonly lifespan: number; // Token lifespan in milliseconds
+  private readonly tempTokenLifespan: number;
 
-  constructor(lifespan: number = 4 * 60 * 1000 + 50 * 1000) {
-    // Default 4:50
+  constructor(tempTokenLifespan: number = 4 * 60 * 1000 + 50 * 1000) {
     this.cache = new Map<string, CachedToken>();
-    this.lifespan = lifespan;
+    this.tempTokenLifespan = tempTokenLifespan;
   }
 
   get(dbid: string): string | undefined {
     const entry = this.cache.get(dbid);
     const now = Date.now();
-    if (entry && entry.expiresAt > now) {
-      return entry.token;
-    }
-    return undefined; // Expired or not found
+    if (entry && entry.expiresAt > now) return entry.token;
+    if (entry) this.cache.delete(dbid); // Clean up expired temp tokens
+    return undefined;
   }
 
-  // New method to get full entry
-  getEntry(dbid: string): CachedToken | undefined {
-    const entry = this.cache.get(dbid);
-    const now = Date.now();
-    if (entry && entry.expiresAt > now) {
-      return entry;
-    }
-    return undefined; // Expired or not found
-  }
-
-  set(dbid: string, token: string): void {
+  set(dbid: string, token: string, lifespan?: number): void {
     const now = Date.now();
     this.cache.set(dbid, {
       token,
-      expiresAt: now + this.lifespan,
+      expiresAt: now + (lifespan || this.tempTokenLifespan),
     });
   }
 
-  dump(): [string, CachedToken][] {
-    return Array.from(this.cache.entries());
-  }
-
-  // New method to clear the cache
   clear(): void {
     this.cache.clear();
   }

package/tests/vitest/qb/auth/mockQuickbaseServer.ts

@@ -0,0 +1,60 @@
+// tests/vitest/qb/auth/mockQuickbaseServer.ts
+import express from "express";
+
+export function startMockQuickbaseServer(port: number = 3000) {
+  const app = express();
+  app.use(express.json());
+  let failNextCall = false;
+
+  app.post("/v1/auth/oauth/token", (req, res) => {
+    const { subject_token } = req.body;
+    console.log("[Mock Server] Received SSO token request:", req.body);
+    if (!subject_token) {
+      return res.status(400).json({ message: "Missing SAML token" });
+    }
+    res.json({
+      access_token: "mock-temp-token",
+      token_type: "Bearer",
+    });
+  });
+
+  app.get("/v1/apps/:appId", (req, res) => {
+    const authHeader = req.headers.authorization;
+    console.log(
+      "[Mock Server] Received getApp request:",
+      req.params,
+      "Auth:",
+      authHeader
+    );
+    if (!authHeader || !authHeader.startsWith("QB-TEMP-TOKEN")) {
+      return res.status(401).json({ message: "Unauthorized" });
+    }
+    if (failNextCall) {
+      failNextCall = false;
+      return res.status(401).json({ message: "Token expired" });
+    }
+    res.json({
+      id: req.params.appId,
+      name: "Mock App",
+      created: "2025-03-19T12:00:00Z",
+      updated: "2025-03-19T12:00:00Z",
+    });
+  });
+
+  app.post("/mock/toggle-fail", (req, res) => {
+    failNextCall = true;
+    console.log("[Mock Server] Toggling next getApp call to fail with 401");
+    res.sendStatus(200);
+  });
+
+  const server = app.listen(port, () => {
+    console.log(`Mock QuickBase server running on port ${port}`);
+  });
+
+  return {
+    server,
+    close: () => server.close(),
+    toggleFail: () =>
+      fetch(`http://localhost:${port}/mock/toggle-fail`, { method: "POST" }),
+  };
+}

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

@@ -1,56 +1,73 @@
 import { describe, it, vi, expect, beforeEach } from "vitest";
 import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient";
-import { ResponseError } from "../../../../src/generated/runtime";
 
 describe("QuickbaseClient Integration - User Token Retry on 401", () => {
   let client: QuickbaseClient;
-  const mockFetch = vi.fn();
 
   beforeEach(() => {
+    const userToken = process.env.QB_USER_TOKEN;
+    const realm = process.env.QB_REALM;
+    const tableId = process.env.QB_TABLE_ID_1; // Consistent env var name
+
+    if (!userToken) {
+      throw new Error(
+        "QB_USER_TOKEN environment variable is required for integration test"
+      );
+    }
+    if (!tableId) {
+      throw new Error(
+        "QB_TABLE_ID_1 environment variable is required for integration test"
+      );
+    }
+
     const config = {
-      realm: process.env.QB_REALM || "builderprogram-dbradford6815",
-      userToken: "mock-user-token",
+      realm,
+      userToken,
       debug: true,
-      fetchApi: mockFetch,
     };
-    console.log("[quickbaseTest] Config:", config);
+    console.log("[quickbaseTest] Config:", {
+      realm,
+      userToken: userToken.substring(0, 10) + "...",
+      tableId, // Log to confirm
+      debug: true,
+    });
     client = quickbase(config);
   });
 
-  it("retries on transient 401 with user token and succeeds", async () => {
-    const consoleSpy = vi.spyOn(console, "log");
-
-    mockFetch
-      .mockImplementationOnce(() => {
-        const response = new Response(null, {
-          status: 401,
-          statusText: "Unauthorized",
-        });
-        console.log("[mockFetch] Throwing 401 ResponseError");
-        return Promise.reject(new ResponseError(response));
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => [{ id: 1, label: "Mock Field", fieldType: "text" }],
-      });
-
-    const fields = await client.getFields({ tableId: "mock-table-id" });
-
-    expect(fields).toBeInstanceOf(Array);
-    expect(fields.length).toBeGreaterThan(0);
-    expect(fields[0]).toHaveProperty("id");
-    expect(fields[0]).toHaveProperty("label");
-
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "Authorization error for getFields (user token), retrying with same token:",
-      "" // Matches empty ResponseError message from mock
-    );
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "Retrying getFields with user token"
-    );
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-
-    consoleSpy.mockRestore();
-  });
+  it(
+    "successfully retrieves fields with user token, retrying on transient 401 if needed",
+    async () => {
+      const consoleSpy = vi.spyOn(console, "log");
+
+      const tableId = process.env.QB_TABLE_ID_1!; // Match beforeEach
+      let fields;
+      try {
+        fields = await client.getFields({ tableId });
+      } catch (error) {
+        console.error("[integrationTest] Failed to retrieve fields:", error);
+        throw error;
+      }
+
+      expect(fields).toBeInstanceOf(Array);
+      expect(fields.length).toBeGreaterThan(0);
+      expect(fields[0]).toHaveProperty("id");
+      expect(fields[0]).toHaveProperty("label");
+
+      console.log("[integrationTest] Fields retrieved:", fields.length);
+
+      const retryLog = consoleSpy.mock.calls.some((call) =>
+        call[0].includes("Retrying getFields with existing user token")
+      );
+      if (retryLog) {
+        console.log("[integrationTest] Retry on 401 detected");
+      } else {
+        console.log(
+          "[integrationTest] No 401 retries observed (expected if no transient failure)"
+        );
+      }
+
+      consoleSpy.mockRestore();
+    },
+    { timeout: 10000 }
+  );
 });

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

@@ -0,0 +1,65 @@
+// tests/vitest/qb/auth/ssoTokenIntegrationWithServer.test.ts
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest"; // Add 'vi' to imports
+import { quickbase } from "../../../../src/quickbaseClient";
+import { startMockQuickbaseServer } from "./mockQuickbaseServer";
+
+describe("QuickbaseClient Integration - SSO with Mock Server", () => {
+  let mockServer: ReturnType<typeof startMockQuickbaseServer>;
+  const mockBaseUrl = "http://localhost:3000";
+
+  beforeAll(async () => {
+    mockServer = startMockQuickbaseServer(3000);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    console.log("Server setup complete, port 3000 should be listening");
+  });
+
+  afterAll(() => {
+    mockServer.close();
+    console.log("Server closed");
+  });
+
+  it(
+    "uses SSO token from mock server and retries on 401",
+    { timeout: 10000 }, // Move timeout to second argument
+    async () => {
+      const consoleSpy = vi.spyOn(console, "log"); // Spy on console.log to capture logs
+      const client = quickbase({
+        realm: "testrealm",
+        samlToken: "mock-saml-token",
+        useSso: true,
+        fetchApi: (url, options) => {
+          const rewrittenUrl = url.replace(
+            "https://api.quickbase.com/v1",
+            mockBaseUrl + "/v1"
+          );
+          console.log(
+            "[fetchApi] Requesting:",
+            rewrittenUrl,
+            "Options:",
+            options
+          );
+          return fetch(rewrittenUrl, options);
+        },
+        debug: true,
+      });
+
+      await mockServer.toggleFail();
+      const response = await client.getApp({ appId: "mockappid" });
+
+      expect(response).toBeDefined();
+      expect(response.id).toBe("mockappid");
+      expect(response.name).toBe("Mock App");
+
+      // Verify retry happened
+      const retryLog = consoleSpy.mock.calls.some((call) =>
+        call[0].includes(
+          "Authorization error for getApp (SSO), refreshing token"
+        )
+      );
+      expect(retryLog).toBe(true); // Ensure retry logic was triggered
+
+      consoleSpy.mockRestore();
+    }
+  );
+});