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

package/src/invokeMethod.ts

@@ -0,0 +1,357 @@
+// src/invokeMethod.ts
+import { QuickbaseClient } from "./quickbaseClient";
+import { ResponseError } from "./generated/runtime";
+import { ThrottleBucket } from "./ThrottleBucket";
+import { RateLimitError } from "./RateLimitError";
+import { GetTempTokenDBID200Response } from "./generated/models";
+
+export type ApiMethod<K extends keyof QuickbaseClient> = (
+  requestParameters: Parameters<QuickbaseClient[K]>[0],
+  initOverrides?: RequestInit
+) => Promise<ReturnType<QuickbaseClient[K]>>;
+
+export interface MethodInfo<K extends keyof QuickbaseClient> {
+  api: any;
+  method: ApiMethod<K>;
+  paramMap: string[];
+  httpMethod: string;
+}
+
+export interface TempTokenParams {
+  appId?: string;
+  tableId?: string;
+  dbid?: string;
+}
+
+export interface TokenCache {
+  get: (dbid: string) => string | undefined;
+  set: (dbid: string, token: string) => void;
+}
+
+export async function invokeMethod<K extends keyof QuickbaseClient>(
+  methodName: K,
+  params: Parameters<QuickbaseClient[K]>[0] & Partial<TempTokenParams>,
+  methodMap: { [P in keyof QuickbaseClient]: MethodInfo<P> },
+  baseHeaders: Record<string, string>,
+  tokenCache: TokenCache,
+  fetchTempToken: (dbid: string) => Promise<string>,
+  transformDates: (obj: any, convertStringsToDates: boolean) => any,
+  initialTempToken: string | undefined,
+  userToken: string | undefined,
+  useTempTokens: boolean | undefined,
+  debug: boolean | undefined,
+  convertDates: boolean,
+  retryCount: number = 0,
+  throttleBucket: ThrottleBucket | null = null,
+  maxRetries: number = 3,
+  retryDelay: number = 1000
+): Promise<ReturnType<QuickbaseClient[K]>> {
+  const methodInfo = methodMap[methodName];
+  if (!methodInfo) throw new Error(`Method ${methodName} not found`);
+
+  const hasBody = "body" in params && params.body !== undefined;
+  const body = hasBody ? (params as any).body : undefined;
+  const restParams: any = hasBody
+    ? Object.fromEntries(
+        Object.entries(params).filter(([key]) => key !== "body")
+      )
+    : { ...params };
+
+  const requestParameters: any = {
+    ...restParams,
+    ...(hasBody ? { generated: body } : {}),
+  };
+
+  let requestOptions: RequestInit = {
+    credentials: "omit",
+    method: methodInfo.httpMethod,
+    ...(hasBody ? { body } : {}),
+  };
+
+  const selectedToken =
+    initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
+  let authorizationToken = selectedToken;
+
+  if (methodName === "getTempTokenDBID" && useTempTokens) {
+    const dbid = extractDbid(params, "No dbid provided for getTempTokenDBID");
+    const cachedToken = tokenCache.get(dbid);
+    if (cachedToken) {
+      return Promise.resolve({
+        temporaryAuthorization: cachedToken,
+      } as GetTempTokenDBID200Response as ReturnType<QuickbaseClient[K]>);
+    }
+  }
+
+  if (useTempTokens && !authorizationToken) {
+    const dbid = extractDbid(
+      params,
+      `No dbid found in params for ${methodName} to fetch temp token`
+    );
+    const cachedToken = tokenCache.get(dbid);
+    authorizationToken = cachedToken || (await fetchTempToken(dbid));
+    if (methodName === "getTempTokenDBID") {
+      return Promise.resolve({
+        temporaryAuthorization: authorizationToken,
+      } as GetTempTokenDBID200Response as ReturnType<QuickbaseClient[K]>);
+    }
+  }
+  requestOptions.headers = authorizationToken
+    ? {
+        ...baseHeaders,
+        Authorization: useTempTokens
+          ? `QB-TEMP-TOKEN ${authorizationToken}`
+          : `QB-USER-TOKEN ${authorizationToken}`,
+      }
+    : baseHeaders;
+
+  if (debug) {
+    console.log(`[${methodName}] requestParameters:`, requestParameters);
+    console.log(`[${methodName}] requestOptions:`, requestOptions);
+  }
+
+  async function processResponse(
+    rawResponse: any
+  ): Promise<ReturnType<QuickbaseClient[K]>> {
+    if (debug) console.log(`[${methodName}] rawResponse:`, rawResponse);
+
+    if (rawResponse instanceof Response) {
+      const contentType = rawResponse.headers
+        .get("Content-Type")
+        ?.toLowerCase();
+      if (debug) console.log(`[${methodName}] contentType:`, contentType);
+
+      if (contentType?.includes("application/octet-stream")) {
+        return (await rawResponse.arrayBuffer()) as ReturnType<
+          QuickbaseClient[K]
+        >;
+      }
+      if (
+        contentType?.includes("application/x-yaml") ||
+        contentType?.includes("text/yaml")
+      ) {
+        return (await rawResponse.text()) as ReturnType<QuickbaseClient[K]>;
+      }
+      if (contentType?.includes("application/json")) {
+        const jsonResponse = await rawResponse.json();
+        return transformDates(jsonResponse, convertDates) as ReturnType<
+          QuickbaseClient[K]
+        >;
+      }
+      return rawResponse as ReturnType<QuickbaseClient[K]>;
+    }
+
+    if (rawResponse && typeof rawResponse.value === "function") {
+      const response = await rawResponse.value();
+      if (debug)
+        console.log(`[${methodName}] Resolved JSONApiResponse:`, response);
+      return transformDates(response, convertDates) as ReturnType<
+        QuickbaseClient[K]
+      >;
+    }
+
+    const transformed = transformDates(rawResponse, convertDates);
+    if (debug)
+      console.log(`[${methodName}] Transformed non-Response:`, transformed);
+    return transformed as ReturnType<QuickbaseClient[K]>;
+  }
+
+  async function withRetries(
+    fn: () => Promise<ReturnType<QuickbaseClient[K]>>,
+    options: {
+      maxAttempts: number;
+      shouldRetry: (error: any) => boolean;
+      onRetry?: (error: any, attempt: number) => Promise<void>;
+      delay?: (attempt: number, error: any) => number;
+    }
+  ): Promise<ReturnType<QuickbaseClient[K]>> {
+    let attempt = 0;
+    while (true) {
+      try {
+        if (throttleBucket) {
+          if (debug) console.log(`[${methodName}] Awaiting throttle bucket`);
+          await throttleBucket.acquire();
+          if (debug) console.log(`[${methodName}] Throttle bucket acquired`);
+        }
+        return await fn();
+      } catch (error) {
+        console.log(`[${methodName}] Caught error:`, error);
+        console.log(
+          `[${methodName}] instanceof ResponseError:`,
+          error instanceof ResponseError
+        );
+        console.log(
+          `[${methodName}] Response status:`,
+          (error as any).response?.status
+        );
+        const effectiveError =
+          error instanceof Object &&
+          "cause" in error &&
+          error.cause instanceof ResponseError
+            ? error.cause
+            : error instanceof ResponseError
+            ? error
+            : error;
+        console.log(`[${methodName}] Effective error:`, effectiveError);
+        console.log(
+          `[${methodName}] Effective instanceof ResponseError:`,
+          effectiveError instanceof ResponseError
+        );
+        console.log(
+          `[${methodName}] Effective response status:`,
+          (effectiveError as any).response?.status
+        );
+
+        attempt++;
+        if (
+          !options.shouldRetry(effectiveError) ||
+          attempt >= options.maxAttempts
+        ) {
+          let errorMessage =
+            effectiveError instanceof ResponseError
+              ? effectiveError.message
+              : String(error);
+          console.log(`[${methodName}] No retry, throwing:`, errorMessage);
+          if (
+            effectiveError instanceof ResponseError &&
+            effectiveError.response
+          ) {
+            try {
+              const errorBody = await effectiveError.response.json();
+              if (debug)
+                console.log(`[${methodName}] Error response body:`, errorBody);
+              errorMessage = errorBody?.message || errorMessage;
+            } catch (e) {
+              if (debug)
+                console.log(`[${methodName}] Failed to parse error body:`, e);
+            }
+            throw new Error(
+              `API Error: ${errorMessage} (Status: ${effectiveError.response.status})`
+            );
+          }
+          throw new Error(`API Error: ${errorMessage} (Status: unknown)`);
+        }
+        if (options.onRetry) {
+          console.log(`[${methodName}] Retrying, attempt:`, attempt);
+          await options.onRetry(effectiveError, attempt);
+        }
+        const delayMs = options.delay
+          ? options.delay(attempt, effectiveError)
+          : retryDelay * Math.pow(2, attempt - 1);
+        if (debug)
+          console.log(
+            `[${methodName}] Retrying after ${delayMs}ms (attempt ${attempt}/${
+              options.maxAttempts - 1
+            })`
+          );
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+
+  const mainPromise = withRetries(
+    () =>
+      methodInfo
+        .method(requestParameters, requestOptions)
+        .then(processResponse),
+    {
+      maxAttempts: (useTempTokens ?? false) || userToken ? 2 : 1,
+      shouldRetry: (error) =>
+        error instanceof ResponseError &&
+        error.response?.status === 401 &&
+        ((useTempTokens ?? false) ||
+          (!!userToken && !(useTempTokens ?? false))),
+      onRetry: async (error) => {
+        if (error instanceof ResponseError && error.response?.status === 401) {
+          if (useTempTokens ?? false) {
+            if (debug)
+              console.log(
+                `Authorization error for ${methodName} (temp token), refreshing token:`,
+                error.message
+              );
+            const dbid = extractDbid(
+              params,
+              `No dbid to refresh token after authorization error`
+            );
+            try {
+              authorizationToken = await fetchTempToken(dbid);
+            } catch (fetchError) {
+              const fetchErrorMessage =
+                fetchError instanceof ResponseError && fetchError.response
+                  ? (await fetchError.response.json())?.message ||
+                    "Unauthorized"
+                  : String(fetchError);
+              throw new Error(
+                `API Error: ${fetchErrorMessage} (Status: ${
+                  fetchError instanceof ResponseError &&
+                  fetchError.response?.status
+                    ? fetchError.response.status
+                    : "unknown"
+                })`
+              );
+            }
+            requestOptions.headers = {
+              ...baseHeaders,
+              Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
+            };
+          } else if (userToken) {
+            if (debug)
+              console.log(
+                `Authorization error for ${methodName} (user token), retrying with same token:`,
+                error.message
+              );
+          }
+          if (debug)
+            console.log(
+              `Retrying ${methodName} with ${
+                useTempTokens ? "temp" : "user"
+              } token`
+            );
+        }
+      },
+    }
+  );
+
+  return mainPromise.catch((error: unknown) => {
+    let effectiveError: unknown = error;
+    if (
+      error instanceof Object &&
+      "cause" in error &&
+      error.cause instanceof ResponseError
+    ) {
+      effectiveError = error.cause;
+    } else if (error instanceof ResponseError) {
+      effectiveError = error;
+    }
+
+    if (
+      effectiveError instanceof ResponseError &&
+      effectiveError.response?.status === 429
+    ) {
+      return withRetries(() => Promise.reject(error), {
+        maxAttempts: maxRetries + 1,
+        shouldRetry: (err) =>
+          err instanceof ResponseError && err.response?.status === 429,
+        delay: (attempt, err) => {
+          const headers =
+            err instanceof ResponseError && err.response
+              ? err.response.headers
+              : new Headers();
+          const retryAfter = headers.get("Retry-After");
+          return retryAfter
+            ? parseInt(retryAfter, 10) * 1000
+            : retryDelay * Math.pow(2, attempt - 1);
+        },
+      });
+    }
+    throw effectiveError;
+  });
+}
+
+function extractDbid(
+  params: Partial<TempTokenParams>,
+  errorMessage: string
+): string {
+  const dbid = params.dbid || params.tableId || params.appId;
+  if (!dbid) throw new Error(errorMessage);
+  return dbid;
+}

package/src/quickbaseClient.ts

@@ -1,9 +1,11 @@
 // src/quickbaseClient.ts
 import { QuickbaseClient as IQuickbaseClient } from "./generated-unified/QuickbaseClient";
-import { Configuration, HTTPHeaders, ResponseError } from "./generated/runtime";
+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 { ThrottleBucket } from "./ThrottleBucket";
 
 export * from "./generated/models/index";
 
@@ -16,24 +18,11 @@ export interface QuickbaseConfig {
   useTempTokens?: boolean;
   debug?: boolean;
   fetchApi?: typeof fetch;
-  convertDates?: boolean; // New flag to control date string conversion, defaults to true
-}
-
-export interface TempTokenParams {
-  appId?: string;
-  tableId?: string;
-  dbid?: string;
-}
-
-type ApiMethod<K extends keyof QuickbaseClient> = (
-  requestParameters: Parameters<QuickbaseClient[K]>[0],
-  initOverrides?: RequestInit
-) => Promise<ReturnType<QuickbaseClient[K]>>;
-
-interface MethodInfo<K extends keyof QuickbaseClient> {
-  api: any;
-  method: ApiMethod<K>;
-  paramMap: string[];
+  convertDates?: boolean;
+  tokenLifespan?: number;
+  throttle?: { rate: number; burst: number };
+  maxRetries?: number;
+  retryDelay?: number;
 }
 
 type MethodMap = {
@@ -48,18 +37,6 @@ const getParamNames = (fn: (...args: any[]) => any): string[] =>
     .map((p) => p.trim().split("=")[0]?.trim())
     .filter((p) => p && !p.match(/^\{/) && p !== "options");
 
-const extractDbid = (
-  params: Partial<TempTokenParams>,
-  errorMessage: string
-): string => {
-  const dbid = params.dbid || params.tableId || params.appId;
-  if (!dbid) {
-    throw new Error(errorMessage);
-  }
-  return dbid;
-};
-
-// Utility to convert ISO date strings to Date objects recursively, with optional conversion
 function transformDates(obj: any, convertStringsToDates: boolean = true): any {
   if (obj === null || obj === undefined) return obj;
   if (obj instanceof Date) return obj;
@@ -86,6 +63,16 @@ function transformDates(obj: any, convertStringsToDates: boolean = true): any {
   return obj;
 }
 
+function inferHttpMethod(methodSource: string, debug?: boolean): string {
+  const methodMatch = methodSource.match(/method:\s*['"]?(\w+)['"]?/i);
+  const method = methodMatch ? methodMatch[1].toUpperCase() : "GET";
+  if (debug) {
+    // console.log(`[inferHttpMethod] Source:`, methodSource);
+    // console.log(`[inferHttpMethod] Extracted method:`, method);
+  }
+  return method;
+}
+
 export function quickbase(config: QuickbaseConfig): QuickbaseClient {
   const {
     realm,
@@ -94,11 +81,18 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
     useTempTokens,
     fetchApi,
     debug,
-    convertDates = true, // Default to true for backward compatibility
+    convertDates = true,
+    tokenLifespan,
+    throttle = { rate: 10, burst: 10 },
+    maxRetries = 3,
+    retryDelay = 1000,
   } = config;
   const baseUrl = `https://api.quickbase.com/v1`;
 
-  const tokenCache = new TokenCache();
+  const tokenCache = new TokenCache(tokenLifespan);
+  const throttleBucket = throttle
+    ? new ThrottleBucket(throttle.rate, throttle.burst)
+    : null;
 
   const baseHeaders: HTTPHeaders = {
     "QB-Realm-Hostname": `${realm}.quickbase.com`,
@@ -157,13 +151,17 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
           const simplifiedName = simplifyName(
             rawMethodName
           ) as keyof QuickbaseClient;
-          const method = api[rawMethodName as keyof typeof api];
+          const rawMethodKey = `${rawMethodName}Raw` as keyof typeof api;
+          const method =
+            api[rawMethodKey] || api[rawMethodName as keyof typeof api];
           const boundMethod = method.bind(api as any) as unknown;
           if (typeof boundMethod === "function" && boundMethod.length <= 2) {
+            const methodSource = method.toString();
             methodMap[simplifiedName] = {
               api,
-              method: boundMethod as ApiMethod<typeof simplifiedName>,
+              method: boundMethod as any, // Adjust typing as needed
               paramMap: getParamNames(method),
+              httpMethod: inferHttpMethod(methodSource, debug),
             };
           }
         });
@@ -209,185 +207,29 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
     return token;
   };
 
-  async function invokeMethod<K extends keyof QuickbaseClient>(
-    methodName: K,
-    params: Parameters<QuickbaseClient[K]>[0] & Partial<TempTokenParams>,
-    retryCount: number = 0
-  ): Promise<ReturnType<QuickbaseClient[K]>> {
-    const methodInfo = methodMap[methodName];
-    if (!methodInfo) {
-      throw new Error(`Method ${methodName} not found`);
-    }
-
-    // Safely handle body extraction
-    const hasBody = "body" in params && params.body !== undefined;
-    const body = hasBody ? (params as any).body : undefined;
-    const restParams: any = hasBody
-      ? Object.fromEntries(
-          Object.entries(params).filter(([key]) => key !== "body")
-        )
-      : { ...params };
-
-    // Construct requestParameters with 'generated' for body
-    const requestParameters: any = {
-      ...restParams,
-      ...(body ? { generated: { ...body } } : {}),
-    };
-
-    let requestOptions: RequestInit = {
-      credentials: "omit",
-    };
-
-    const selectedToken =
-      initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
-
-    if (methodName === "getTempTokenDBID" && useTempTokens) {
-      const dbid = extractDbid(params, "No dbid provided for getTempTokenDBID");
-      const cachedToken = tokenCache.get(dbid);
-      if (cachedToken) {
-        return { temporaryAuthorization: cachedToken } as ReturnType<
-          QuickbaseClient[K]
-        >;
-      }
-    }
-
-    let authorizationToken = selectedToken;
-    if (useTempTokens && !authorizationToken) {
-      const dbid = extractDbid(
-        params,
-        `No dbid found in params for ${methodName} to fetch temp token`
-      );
-      const cachedToken = tokenCache.get(dbid);
-      authorizationToken = cachedToken || (await fetchTempToken(dbid));
-      if (methodName === "getTempTokenDBID") {
-        return { temporaryAuthorization: authorizationToken } as ReturnType<
-          QuickbaseClient[K]
-        >;
-      }
-      requestOptions.headers = {
-        ...baseHeaders,
-        Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
-      };
-    } else if (authorizationToken) {
-      requestOptions.headers = {
-        ...baseHeaders,
-        Authorization: `QB-USER-TOKEN ${authorizationToken}`,
-      };
-    }
-
-    if (debug) {
-      console.log(`[${methodName}] requestParameters:`, requestParameters);
-      console.log(`[${methodName}] requestOptions:`, requestOptions);
-    }
-
-    try {
-      const response = await methodInfo.method(
-        requestParameters,
-        requestOptions
-      );
-      if (debug) {
-        console.log(`[${methodName}] rawResponse:`, response);
-      }
-      if (response instanceof Response) {
-        const contentType = response.headers.get("Content-Type")?.toLowerCase();
-        if (debug) {
-          console.log(`[${methodName}] contentType:`, contentType);
-        }
-        if (contentType?.includes("application/octet-stream")) {
-          return (await response.arrayBuffer()) as ReturnType<
-            QuickbaseClient[K]
-          >;
-        } else if (
-          contentType?.includes("application/x-yaml") ||
-          contentType?.includes("text/yaml")
-        ) {
-          return (await response.text()) as ReturnType<QuickbaseClient[K]>;
-        } else if (contentType?.includes("application/json")) {
-          const jsonResponse = await response.json();
-          if (debug) {
-            console.log(`[${methodName}] jsonResponse:`, jsonResponse);
-          }
-          const transformedResponse = transformDates(
-            jsonResponse,
-            convertDates
-          );
-          if (debug) {
-            console.log(
-              `[${methodName}] transformedResponse:`,
-              transformedResponse
-            );
-          }
-          return transformedResponse as ReturnType<QuickbaseClient[K]>;
-        }
-        return response as ReturnType<QuickbaseClient[K]>;
-      } else {
-        if (debug) {
-          console.log(
-            `[${methodName}] non-Response return, applying transform:`,
-            response
-          );
-        }
-        const transformedResponse = transformDates(response, convertDates);
-        if (debug) {
-          console.log(
-            `[${methodName}] transformedNonResponse:`,
-            transformedResponse
-          );
-        }
-        return transformedResponse as ReturnType<QuickbaseClient[K]>;
-      }
-    } catch (error) {
-      if (
-        error instanceof ResponseError &&
-        error.response.status === 401 &&
-        retryCount < 1 &&
-        useTempTokens
-      ) {
-        if (debug) {
-          console.log(
-            `Authorization error for ${methodName}, refreshing token:`,
-            error.message
-          );
-        }
-        const dbid = extractDbid(
-          params,
-          `No dbid to refresh token after authorization error`
-        );
-        authorizationToken = await fetchTempToken(dbid);
-        requestOptions.headers = {
-          ...baseHeaders,
-          Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
-        };
-        if (debug) {
-          console.log(`Retrying ${methodName} with new token`);
-        }
-        return invokeMethod(methodName, params, retryCount + 1);
-      }
-      if (error instanceof ResponseError) {
-        let errorMessage = error.message;
-        try {
-          const errorBody: { message?: string } = await error.response.json();
-          if (debug) {
-            console.log(`Error response body for ${methodName}:`, errorBody);
-          }
-          errorMessage = errorBody.message || errorMessage;
-        } catch (e) {
-          // Silent fail on parse error
-        }
-        throw new Error(
-          `API Error: ${errorMessage} (Status: ${error.response.status})`
-        );
-      }
-      throw error;
-    }
-  }
-
   const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, {
     get: (_, prop: string): ((params: any) => Promise<any>) | undefined => {
       if (prop in methodMap) {
         const methodName = prop as keyof QuickbaseClient;
         return (params: Parameters<QuickbaseClient[typeof methodName]>[0]) =>
-          invokeMethod(methodName, params);
+          invokeMethod(
+            methodName,
+            params,
+            methodMap,
+            baseHeaders,
+            tokenCache,
+            fetchTempToken,
+            transformDates,
+            initialTempToken,
+            userToken,
+            useTempTokens,
+            debug,
+            convertDates,
+            0, // retryCount
+            throttleBucket,
+            maxRetries,
+            retryDelay
+          );
       }
       return undefined;
     },

package/tests/setup.ts

@@ -38,12 +38,14 @@ export const createClient = (
     userToken,
     debug: true,
     fetchApi,
+    throttle: { rate: 10, burst: 10 }, // Throttle at 10 req/s with 10 burst capacity
     ...config, // Allow overrides if provided
   });
   console.log("[createClient] Config:", {
     realm,
     userToken,
     debug: true,
+    throttle: { rate: 10, burst: 10 },
     ...config,
   });
   console.log("[createClient] Returning:", client);