quickbase-js 0.1.0-beta.9 → 1.0.0

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

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

package/src/index.ts

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

package/src/invokeMethod.ts

@@ -1,242 +0,0 @@
-// 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";
-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 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,
-  fetchTempToken: (dbid: string) => Promise<string>,
-  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 && dbid) {
-    token = await fetchTempToken(dbid);
-    authStrategy.applyHeaders(baseHeaders, token);
-    requestOptions.headers = { ...baseHeaders };
-    console.log("[invokeMethod] Fetched new 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";
-    }
-    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) {
-      let status: number;
-      let message: string;
-      let response: Response;
-
-      console.log("[invokeMethod] Caught error:", error);
-
-      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);
-        throw error; // Rethrow non-response errors
-      }
-
-      console.log("[invokeMethod] Handling error with status:", status);
-
-      if (status === 429) {
-        if (!(error instanceof ResponseError)) {
-          throw new Error("Expected ResponseError for 429 handling"); // Shouldn't happen
-        }
-        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,
-        fetchTempToken,
-        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

@@ -1,271 +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";
-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>;
-};
-
-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 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] All matches:`,
-      methodMatches.map((m) => m[0])
-    );
-    console.log(`[inferHttpMethod] Extracted method:`, method);
-  }
-  return method;
-}
-
-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)
-    : 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",
-  });
-
-  // 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)
-      .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 methodSource = method.toString();
-            methodMap[simplifiedName] = {
-              api,
-              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 methodMap = buildMethodMap();
-
-  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();
-      throw new Error(
-        `API Error: ${errorBody.message || "Unknown error"} (Status: ${
-          response.status
-        })`
-      );
-    }
-
-    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, tempTokenLifespan);
-    if (debug) {
-      console.log(`Fetched and cached new token for dbid: ${dbid}`, token);
-    }
-    return token;
-  };
-
-  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,
-            fetchTempToken,
-            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

@@ -1,25 +0,0 @@
-// 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,35 +0,0 @@
-// 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

@@ -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);