quickbase-js 0.1.0-beta.10

package/src/generated-unified/missing-types-report.json

@@ -0,0 +1,3 @@
+{
+  "missingTypes": []
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./quickbaseClient.ts";

package/src/invokeMethod.ts

@@ -0,0 +1,245 @@
+// src/invokeMethod.ts
+
+import { AuthorizationStrategy, extractDbid } from "./authorizationStrategy";
+import { RateLimiter } from "./rateLimiter";
+import { RateLimitError } from "./RateLimitError";
+import { ResponseError } from "./generated/runtime";
+import { QuickbaseClient } from "./quickbaseClient";
+
+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 async function invokeMethod<K extends keyof QuickbaseClient>(
+  methodName: K,
+  params: Parameters<QuickbaseClient[K]>[0] & {
+    dbid?: string;
+    tableId?: string;
+    appId?: string;
+  },
+  methodMap: { [P in keyof QuickbaseClient]: MethodInfo<P> },
+  baseHeaders: Record<string, string>,
+  authStrategy: AuthorizationStrategy,
+  rateLimiter: RateLimiter,
+  transformDates: (obj: any, convertStringsToDates: boolean) => any,
+  debug: boolean | undefined,
+  convertDates: boolean
+): Promise<ReturnType<QuickbaseClient[K]>> {
+  console.log("[invokeMethod] Starting for method:", methodName);
+
+  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.body : undefined;
+  const restParams: any = hasBody
+    ? Object.fromEntries(
+        Object.entries(params).filter(([key]) => key !== "body")
+      )
+    : { ...params };
+  const requestParameters: any = {
+    ...restParams,
+    ...(hasBody ? { generated: body } : {}),
+  };
+
+  const requestOptions: RequestInit = {
+    credentials: methodName === "getTempTokenDBID" ? "include" : "omit",
+    method: methodInfo.httpMethod,
+  };
+
+  let dbid: string | undefined = extractDbid(params);
+  console.log("[invokeMethod] Extracted dbid:", dbid);
+
+  let token = dbid
+    ? await authStrategy.getToken(dbid)
+    : await authStrategy.getToken("");
+  console.log("[invokeMethod] Initial token:", token);
+
+  if (token) {
+    authStrategy.applyHeaders(baseHeaders, token);
+    requestOptions.headers = { ...baseHeaders };
+    console.log(
+      "[invokeMethod] Token found, headers set:",
+      requestOptions.headers
+    );
+    if (methodName === "getTempTokenDBID") {
+      console.log("[invokeMethod] Using cached token:", token);
+      return { temporaryAuthorization: token } as ReturnType<
+        QuickbaseClient[K]
+      >;
+    }
+  }
+
+  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/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]
+      >;
+    }
+    return transformDates(rawResponse, convertDates) as ReturnType<
+      QuickbaseClient[K]
+    >;
+  }
+
+  async function parseErrorResponse(
+    response: Response
+  ): Promise<{ message: string; status: number }> {
+    let message = "Unknown error";
+    let status = response.status || 500;
+    try {
+      const contentType =
+        response.headers?.get("Content-Type")?.toLowerCase() ||
+        "application/json";
+      if (
+        contentType.includes("application/json") &&
+        typeof response.json === "function"
+      ) {
+        const errorBody = await response.json();
+        if (
+          errorBody &&
+          typeof errorBody === "object" &&
+          "message" in errorBody
+        ) {
+          message = errorBody.message;
+        } else {
+          message = "Invalid error response format";
+        }
+      } else if (typeof response.text === "function") {
+        message = (await response.text()) || message;
+      }
+    } catch (e) {
+      if (debug) console.log(`[${methodName}] Error parsing response body:`, e);
+      message = "Failed to parse error response";
+    }
+    if (debug)
+      console.log(
+        "[invokeMethod] Parsed error - status:",
+        status,
+        "message:",
+        message
+      );
+    return { message, status };
+  }
+
+  let attempt = 0;
+  const maxAttempts = rateLimiter.maxRetries + 1;
+
+  while (attempt < maxAttempts) {
+    console.log("[invokeMethod] Attempt:", attempt + 1, "of", maxAttempts);
+    try {
+      await rateLimiter.throttle();
+      console.log("[invokeMethod] About to call API for method:", methodName);
+      const response = await methodInfo.method(
+        requestParameters,
+        requestOptions
+      );
+      console.log("[invokeMethod] API call completed for method:", methodName);
+      return await processResponse(response);
+    } catch (error: unknown) {
+      if (debug) console.log("[invokeMethod] Caught error:", error);
+
+      let status: number;
+      let message: string;
+      let response: Response | undefined;
+
+      if (error instanceof ResponseError && error.response) {
+        response = error.response;
+        ({ message, status } = await parseErrorResponse(response));
+      } else if (error instanceof Response) {
+        response = error;
+        ({ message, status } = await parseErrorResponse(response));
+      } else {
+        if (debug) console.log(`[${methodName}] Unexpected error:`, error);
+        // Attempt to handle as a fetch error with a response
+        if (error instanceof Error && "response" in error) {
+          response = (error as any).response;
+          if (response instanceof Response) {
+            ({ message, status } = await parseErrorResponse(response));
+          } else {
+            throw error; // Rethrow if no response
+          }
+        } else {
+          throw error; // Rethrow truly unexpected errors
+        }
+      }
+
+      if (debug)
+        console.log("[invokeMethod] Handling error with status:", status);
+
+      if (status === 429) {
+        if (!(error instanceof ResponseError)) {
+          throw new Error("Expected ResponseError for 429 handling");
+        }
+        const delay = await rateLimiter.handle429(error, attempt + 1);
+        if (debug) console.log(`[${methodName}] 429 delay: ${delay}ms`);
+        if (attempt + 1 === maxAttempts) {
+          throw new RateLimitError(
+            `API Error: ${message} (Status: ${status})`,
+            status,
+            response?.headers.get("Retry-After")
+              ? parseInt(response.headers.get("Retry-After")!, 10)
+              : undefined
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        attempt++;
+        continue;
+      }
+
+      const newToken = await authStrategy.handleError(
+        status,
+        params,
+        attempt,
+        maxAttempts,
+        debug,
+        methodName
+      );
+      if (newToken) {
+        token = newToken;
+        authStrategy.applyHeaders(baseHeaders, token);
+        requestOptions.headers = { ...baseHeaders };
+        attempt++;
+        if (debug)
+          console.log(
+            `[${methodName}] Retrying with token: ${token.substring(0, 10)}...`
+          );
+        continue;
+      }
+
+      throw new Error(`API Error: ${message} (Status: ${status})`);
+    }
+  }
+  throw new Error(`API Error: Exhausted retries after ${maxAttempts} attempts`);
+}

package/src/quickbaseClient.ts

@@ -0,0 +1,194 @@
+// 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,
+  getParamNames,
+  transformDates,
+  extractHttpMethod,
+} from "./utils"; // Updated 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";
+
+export interface QuickbaseClient extends IQuickbaseClient {}
+
+export interface QuickbaseConfig {
+  realm: string;
+  userToken?: string;
+  tempToken?: string;
+  useTempTokens?: boolean;
+  useSso?: boolean;
+  samlToken?: string;
+  debug?: boolean;
+  fetchApi?: typeof fetch;
+  convertDates?: boolean;
+  tempTokenLifespan?: number;
+  throttle?: { rate: number; burst: number };
+  maxRetries?: number;
+  retryDelay?: number;
+  tokenCache?: TokenCache;
+  baseUrl?: string;
+}
+
+type MethodMap = {
+  [K in keyof QuickbaseClient]: MethodInfo<K>;
+};
+
+export function quickbase(config: QuickbaseConfig): QuickbaseClient {
+  const {
+    realm,
+    userToken,
+    tempToken,
+    useTempTokens,
+    useSso,
+    samlToken,
+    fetchApi,
+    debug,
+    convertDates = true,
+    tempTokenLifespan = 290000,
+    throttle = { rate: 10, burst: 10 },
+    maxRetries = 3,
+    retryDelay = 1000,
+    tokenCache: providedTokenCache,
+    baseUrl = "https://api.quickbase.com/v1",
+  } = config;
+
+  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,
+        effectiveFetch,
+        realm,
+        baseUrl
+      )
+    : new UserTokenStrategy(userToken || "");
+
+  const baseHeaders: HTTPHeaders = {
+    "QB-Realm-Hostname": `${realm}.quickbase.com`,
+    "Content-Type": "application/json",
+  };
+
+  const configuration = new Configuration({
+    basePath: baseUrl,
+    headers: { ...baseHeaders },
+    fetchApi: effectiveFetch,
+    credentials: "omit",
+  });
+
+  const apiInstances = Object.fromEntries(
+    Object.entries(apis)
+      .filter(([name]) => name.endsWith("Api"))
+      .map(([name, ApiClass]) => [
+        name.replace("Api", "").toLowerCase(),
+        new ApiClass(configuration),
+      ])
+  );
+
+  function buildMethodMap(): MethodMap {
+    const methodMap: Partial<MethodMap> = {};
+    const isValidMethod = (name: string) =>
+      !name.startsWith("_") &&
+      name !== "constructor" &&
+      !["Middleware", "Pre", "Post", "Raw"].some((s) => name.includes(s));
+
+    for (const [apiName, api] of Object.entries(apiInstances)) {
+      Object.getOwnPropertyNames(Object.getPrototypeOf(api))
+        .filter(
+          (name) =>
+            isValidMethod(name) &&
+            typeof api[name as keyof typeof api] === "function"
+        )
+        .forEach((rawMethodName) => {
+          const simplifiedName = simplifyName(
+            rawMethodName
+          ) as keyof QuickbaseClient;
+          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 httpMethod = extractHttpMethod(method);
+            methodMap[simplifiedName] = {
+              api,
+              method: boundMethod as any,
+              paramMap: getParamNames(method),
+              httpMethod,
+            };
+          }
+        });
+    }
+    if (debug) {
+      console.log("[buildMethodMap] Methods:", Object.keys(methodMap));
+    }
+    return methodMap as MethodMap;
+  }
+
+  const methodMap = buildMethodMap();
+
+  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]) =>
+          invokeMethod(
+            methodName,
+            params,
+            methodMap,
+            baseHeaders,
+            authStrategy,
+            rateLimiter,
+            transformDates,
+            debug,
+            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] 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

@@ -0,0 +1,35 @@
+// src/tokenCache.ts
+interface CachedToken {
+  token: string;
+  expiresAt: number;
+}
+
+export class TokenCache {
+  private cache: Map<string, CachedToken>;
+  private readonly tempTokenLifespan: number;
+
+  constructor(tempTokenLifespan: number = 4 * 60 * 1000 + 50 * 1000) {
+    this.cache = new Map<string, CachedToken>();
+    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;
+    if (entry) this.cache.delete(dbid); // Clean up expired temp tokens
+    return undefined;
+  }
+
+  set(dbid: string, token: string, lifespan?: number): void {
+    const now = Date.now();
+    this.cache.set(dbid, {
+      token,
+      expiresAt: now + (lifespan || this.tempTokenLifespan),
+    });
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}

package/src/utils.ts

@@ -0,0 +1,50 @@
+// src/utils.ts
+
+export function simplifyName(methodName: string): string {
+  // Assuming this removes 'Raw' or similar suffixes as per your original logic
+  return methodName
+    .replace(/Raw$/, "")
+    .replace(/^./, (str) => str.toLowerCase());
+}
+
+export function getParamNames(func: Function): string[] {
+  // Your existing logic to extract parameter names from a function
+  const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+  const ARGUMENT_NAMES = /([^\s,]+)/g;
+  const fnStr = func.toString().replace(STRIP_COMMENTS, "");
+  const result = fnStr
+    .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
+    .match(ARGUMENT_NAMES);
+  return result || [];
+}
+
+export function transformDates(obj: any, convertStringsToDates: boolean): any {
+  // Your existing logic to transform dates
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => transformDates(item, convertStringsToDates));
+  const result: any = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (
+      typeof value === "string" &&
+      convertStringsToDates &&
+      /^\d{4}-\d{2}-\d{2}/.test(value)
+    ) {
+      result[key] = new Date(value);
+    } else if (value instanceof Date) {
+      result[key] = value;
+    } else if (typeof value === "object") {
+      result[key] = transformDates(value, convertStringsToDates);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function extractHttpMethod(method: Function): string {
+  const source = method.toString();
+  // Match the `method: 'SOME_METHOD'` part of the `request` call
+  const match = source.match(/method:\s*['"](\w+)['"]/i);
+  return match ? match[1].toUpperCase() : "GET"; // Fallback to GET if no match
+}