quickbase-js 0.1.0-beta.8 → 1.0.0

package/src/invokeMethod.ts

@@ -1,357 +0,0 @@
-// 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,244 +0,0 @@
-// 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 { ThrottleBucket } from "./ThrottleBucket";
-
-export * from "./generated/models/index";
-
-export interface QuickbaseClient extends IQuickbaseClient {}
-
-export interface QuickbaseConfig {
-  realm: string;
-  userToken?: string;
-  tempToken?: string;
-  useTempTokens?: boolean;
-  debug?: boolean;
-  fetchApi?: typeof fetch;
-  convertDates?: boolean;
-  tokenLifespan?: number;
-  throttle?: { rate: number; burst: number };
-  maxRetries?: number;
-  retryDelay?: number;
-}
-
-type MethodMap = {
-  [K in keyof QuickbaseClient]: MethodInfo<K>;
-};
-
-const getParamNames = (fn: (...args: any[]) => any): string[] =>
-  fn
-    .toString()
-    .slice(fn.toString().indexOf("(") + 1, fn.toString().indexOf(")"))
-    .split(",")
-    .map((p) => p.trim().split("=")[0]?.trim())
-    .filter((p) => p && !p.match(/^\{/) && p !== "options");
-
-function transformDates(obj: any, convertStringsToDates: boolean = true): any {
-  if (obj === null || obj === undefined) return obj;
-  if (obj instanceof Date) return obj;
-  if (
-    convertStringsToDates &&
-    typeof obj === "string" &&
-    /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?/.test(
-      obj
-    )
-  ) {
-    return new Date(obj);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => transformDates(item, convertStringsToDates));
-  }
-  if (typeof obj === "object") {
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [
-        key,
-        transformDates(value, convertStringsToDates),
-      ])
-    );
-  }
-  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,
-    userToken,
-    tempToken: initialTempToken,
-    useTempTokens,
-    fetchApi,
-    debug,
-    convertDates = true,
-    tokenLifespan,
-    throttle = { rate: 10, burst: 10 },
-    maxRetries = 3,
-    retryDelay = 1000,
-  } = config;
-  const baseUrl = `https://api.quickbase.com/v1`;
-
-  const tokenCache = new TokenCache(tokenLifespan);
-  const throttleBucket = throttle
-    ? new ThrottleBucket(throttle.rate, throttle.burst)
-    : null;
-
-  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,
-    credentials: "omit",
-  });
-
-  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)
-      .filter(([name]) => name.endsWith("Api"))
-      .map(([name, ApiClass]) => [
-        name.replace("Api", "").toLowerCase(),
-        new ApiClass(configuration),
-      ])
-  );
-
-  const methodMap = buildMethodMap();
-
-  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 methodSource = method.toString();
-            methodMap[simplifiedName] = {
-              api,
-              method: boundMethod as any, // Adjust typing as needed
-              paramMap: getParamNames(method),
-              httpMethod: inferHttpMethod(methodSource, debug),
-            };
-          }
-        });
-    }
-    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 response = await effectiveFetch(
-      `https://api.quickbase.com/v1/auth/temporary/${dbid}`,
-      {
-        method: "GET",
-        headers: { ...baseHeaders },
-        credentials: "include",
-      }
-    );
-
-    if (!response.ok) {
-      const errorBody: { message?: string } = await response.json();
-      throw new Error(
-        `API Error: ${errorBody.message || "Unknown error"} (Status: ${
-          response.status
-        })`
-      );
-    }
-
-    const tokenResult = await response.json();
-    const token = tokenResult.temporaryAuthorization;
-    if (!token) {
-      throw new Error("No temporary token returned from API");
-    }
-    tokenCache.set(dbid, token);
-    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 => {
-      if (prop in methodMap) {
-        const methodName = prop as keyof QuickbaseClient;
-        return (params: Parameters<QuickbaseClient[typeof methodName]>[0]) =>
-          invokeMethod(
-            methodName,
-            params,
-            methodMap,
-            baseHeaders,
-            tokenCache,
-            fetchTempToken,
-            transformDates,
-            initialTempToken,
-            userToken,
-            useTempTokens,
-            debug,
-            convertDates,
-            0, // retryCount
-            throttleBucket,
-            maxRetries,
-            retryDelay
-          );
-      }
-      return undefined;
-    },
-  });
-
-  if (debug) {
-    console.log("[createClient] Config:", config);
-    console.log("[createClient] Returning:", proxy);
-  }
-
-  return proxy;
-}

package/src/tokenCache.ts

@@ -1,51 +0,0 @@
-interface CachedToken {
-  token: string;
-  expiresAt: number; // Timestamp in milliseconds
-}
-
-export class TokenCache {
-  private cache: Map<string, CachedToken>;
-  private readonly lifespan: number; // Token lifespan in milliseconds
-
-  constructor(lifespan: number = 4 * 60 * 1000 + 50 * 1000) {
-    // Default 4:50
-    this.cache = new Map<string, CachedToken>();
-    this.lifespan = lifespan;
-  }
-
-  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
-  }
-
-  // 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 {
-    const now = Date.now();
-    this.cache.set(dbid, {
-      token,
-      expiresAt: now + this.lifespan,
-    });
-  }
-
-  dump(): [string, CachedToken][] {
-    return Array.from(this.cache.entries());
-  }
-
-  // New method to clear the cache
-  clear(): void {
-    this.cache.clear();
-  }
-}

package/src/utils.ts

@@ -1,7 +0,0 @@
-// src/utils.ts
-export function simplifyName(name: string): string {
-  return name
-    .replace(/ById$/, "")
-    .replace(/Api$/, "")
-    .replace(/^(\w)/, (_, c) => c.toLowerCase());
-}

package/test-esm.js

@@ -1 +0,0 @@
-import { quickbase } from './dist/esm/quickbase.js'; const qb = quickbase({ realm: 'example', userToken: 'your-token' }); console.log(qb);