quickbase-js 0.1.0-beta.12 → 0.1.0-beta.14

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,212 +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";
-
-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;
-    startTime?: number; // Added for testing post-throttle timing
-  },
-  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,
-  attempt: number = 0,
-  maxAttempts: number = rateLimiter.maxRetries + 1
-): 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.body : undefined;
-  const restParams: any = hasBody
-    ? Object.fromEntries(
-        Object.entries(params).filter(
-          ([key]) => key !== "body" && key !== "startTime"
-        )
-      )
-    : { ...params, startTime: undefined };
-  const requestParameters: any = {
-    ...restParams,
-    ...(hasBody ? { generated: body } : {}),
-  };
-
-  const requestOptions: RequestInit = {
-    credentials: methodName === "getTempTokenDBID" ? "include" : "omit",
-    method: methodInfo.httpMethod,
-  };
-
-  let dbid: string | undefined = extractDbid(params);
-  let token = dbid
-    ? await authStrategy.getToken(dbid)
-    : await authStrategy.getToken("");
-
-  if (token) {
-    authStrategy.applyHeaders(baseHeaders, token);
-    requestOptions.headers = { ...baseHeaders };
-    if (methodName === "getTempTokenDBID") {
-      return { temporaryAuthorization: token } as ReturnType<
-        QuickbaseClient[K]
-      >;
-    }
-  }
-
-  async function processResponse(
-    rawResponse: any
-  ): Promise<ReturnType<QuickbaseClient[K]>> {
-    if (rawResponse instanceof Response) {
-      const contentType = rawResponse.headers
-        .get("Content-Type")
-        ?.toLowerCase();
-      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();
-      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) {
-      message = "Failed to parse error response";
-    }
-    return { message, status };
-  }
-
-  while (attempt < maxAttempts) {
-    let acquired = false;
-    try {
-      await rateLimiter.throttle();
-      acquired = true;
-      const postThrottleTime = Date.now(); // Capture post-throttle time
-      if (params.startTime !== undefined) params.startTime = postThrottleTime; // Update startTime for testing
-      const responsePromise = methodInfo.method(
-        requestParameters,
-        requestOptions
-      );
-      rateLimiter.release(); // Release slot immediately after starting fetch
-      const response = await responsePromise;
-      return await processResponse(response);
-    } catch (error: unknown) {
-      if (acquired) rateLimiter.release();
-      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 {
-        throw error;
-      }
-
-      if (status === 429) {
-        if (!(error instanceof ResponseError)) {
-          throw new Error("Expected ResponseError for 429 handling");
-        }
-        const delay = await rateLimiter.handle429(error, attempt + 1);
-        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;
-      }
-
-      let newToken: string | null;
-      try {
-        newToken = await authStrategy.handleError(
-          status,
-          params,
-          attempt,
-          maxAttempts,
-          debug,
-          methodName
-        );
-      } catch (authError) {
-        throw authError;
-      }
-
-      if (newToken !== null) {
-        token = newToken;
-        authStrategy.applyHeaders(baseHeaders, token);
-        requestOptions.headers = { ...baseHeaders };
-        if (debug)
-          console.log(
-            `[${methodName}] Retrying with token: ${token.substring(0, 10)}...`
-          );
-        attempt++;
-        continue;
-      }
-
-      throw new Error(`API Error: ${message} (Status: ${status})`);
-    }
-  }
-  throw new Error(`API Error: Exhausted retries after ${maxAttempts} attempts`);
-}

package/src/quickbaseClient.ts

@@ -1,199 +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,
-  getParamNames,
-  transformDates,
-  extractHttpMethod,
-} from "./utils";
-import { invokeMethod, MethodInfo } from "./invokeMethod";
-import {
-  TempTokenStrategy,
-  UserTokenStrategy,
-  AuthorizationStrategy,
-  SsoTokenStrategy,
-} from "./authorizationStrategy";
-import { ConcurrentThrottleBucket } 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: 5, burst: 3 }, // Updated default to match passing test
-    maxRetries = 3,
-    retryDelay = 1000,
-    tokenCache: providedTokenCache,
-    baseUrl = "https://api.quickbase.com/v1",
-  } = config;
-
-  const tokenCache = providedTokenCache || new TokenCache(tempTokenLifespan);
-  const throttleBucket = throttle
-    ? new ConcurrentThrottleBucket(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,
-        baseUrl
-      )
-    : useTempTokens
-    ? new TempTokenStrategy(
-        tokenCache,
-        tempToken,
-        effectiveFetch,
-        realm,
-        baseUrl
-      )
-    : new UserTokenStrategy(userToken || "", baseUrl);
-
-  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

@@ -1,30 +0,0 @@
-// src/rateLimiter.ts
-import { ConcurrentThrottleBucket } from "./ThrottleBucket"; // Updated import
-import { ResponseError } from "./generated/runtime";
-
-export class RateLimiter {
-  constructor(
-    private throttleBucket: ConcurrentThrottleBucket | null, // Updated type
-    public maxRetries: number = 3,
-    private retryDelay: number = 1000
-  ) {}
-
-  async throttle(): Promise<void> {
-    if (this.throttleBucket) {
-      await this.throttleBucket.acquire();
-    }
-  }
-
-  release(): void {
-    if (this.throttleBucket) {
-      this.throttleBucket.release();
-    }
-  }
-
-  async handle429(error: ResponseError, attempt: number): Promise<number> {
-    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,39 +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),
-    });
-  }
-
-  delete(dbid: string): void {
-    this.cache.delete(dbid);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-}

package/src/utils.ts

@@ -1,50 +0,0 @@
-// 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
-}

package/tests/playwright/qb/auth/cacheSwitching.test.ts

@@ -1,159 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient.ts";
-import dotenv from "dotenv";
-
-dotenv.config();
-
-const loginToQuickbase = async (
-  page: import("@playwright/test").Page,
-  quickbaseUrl: string,
-  username: string,
-  password: string
-): Promise<boolean> => {
-  console.log("Logging in to QuickBase");
-  let loginSuccess = false;
-  const maxLoginAttempts = 3;
-  let loginAttempt = 0;
-
-  while (!loginSuccess && loginAttempt < maxLoginAttempts) {
-    try {
-      loginAttempt++;
-      if (loginAttempt > 1) console.log(`Login attempt ${loginAttempt}`);
-
-      console.log("Navigating to login page");
-      await page.goto(quickbaseUrl, { timeout: 30000 });
-      console.log("Waiting for loginid selector");
-      await page.waitForSelector("input[name='loginid']", { timeout: 30000 });
-      await page.fill("input[name='loginid']", username);
-      await page.fill("input[name='password']", password);
-      console.log("Clicking signin");
-      await page.click("#signin");
-      console.log("Waiting for navigation");
-      await page.waitForURL(`https://*.quickbase.com/**`, {
-        waitUntil: "networkidle",
-        timeout: 30000,
-      });
-
-      const loginError = await page.$(".login-error");
-      if (loginError) {
-        throw new Error("Login failed. Please check your credentials.");
-      }
-
-      console.log("Signed In to QuickBase.");
-      loginSuccess = true;
-    } catch (error) {
-      console.error(
-        `Login attempt ${loginAttempt} failed: ${(error as Error).message}`
-      );
-      if (loginAttempt >= maxLoginAttempts) {
-        console.error("Max login attempts reached. Exiting.");
-        await page.context().browser()!.close();
-        return false;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  }
-  return loginSuccess;
-};
-
-test.describe("QuickbaseClient Integration - Cache Switching with Temp Tokens", () => {
-  test("caches and switches tokens for different DBIDs with getApp → getFields → getApp sequence", async ({
-    page,
-  }) => {
-    console.log("Starting cacheSwitching test");
-    const realm = process.env.QB_REALM ?? "";
-    const appId = process.env.QB_APP_ID ?? "";
-    const tableId = process.env.QB_TABLE_ID_1 ?? "";
-    const username = process.env.QB_USERNAME ?? "";
-    const password = process.env.QB_PASSWORD ?? "";
-
-    if (!realm || !appId || !tableId || !username || !password) {
-      throw new Error(
-        "Required QuickBase environment variables are not defined"
-      );
-    }
-
-    const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
-    const loginSuccess = await loginToQuickbase(
-      page,
-      quickbaseUrl,
-      username,
-      password
-    );
-    if (!loginSuccess) {
-      throw new Error("Failed to log in to QuickBase after max attempts.");
-    }
-
-    await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-      waitUntil: "networkidle",
-      timeout: 30000,
-    });
-    console.log("Post-login URL after app navigation:", page.url());
-
-    const client = quickbase({
-      realm,
-      useTempTokens: true,
-      debug: true,
-      fetchApi: async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = input.toString();
-        console.log(`Fetching ${url} with init:`, init);
-        const effectiveInit = init || {};
-        const response = await page.evaluate(
-          async ([fetchUrl, fetchInit]: [string, RequestInit]) => {
-            const res = await fetch(fetchUrl, fetchInit); // Rely on quickbaseClient.ts for credentials
-            const body = await res.text();
-            const headersObj: Record<string, string> = {};
-            res.headers.forEach((value, key) => {
-              headersObj[key] = value;
-            });
-            return {
-              ok: res.ok,
-              status: res.status,
-              statusText: res.statusText,
-              headers: headersObj,
-              body,
-            };
-          },
-          [url, effectiveInit] as [string, RequestInit]
-        );
-
-        console.log(`Raw response from ${url}:`, {
-          status: response.status,
-          statusText: response.statusText,
-          body: response.body,
-        });
-
-        const fetchResponse = new Response(response.body || null, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: new Headers(response.headers),
-        });
-
-        fetchResponse.json = async () => {
-          if (!response.body) {
-            throw new Error("Empty response body from API");
-          }
-          try {
-            return JSON.parse(response.body);
-          } catch (e) {
-            throw new SyntaxError(`Invalid JSON response: ${response.body}`);
-          }
-        };
-
-        return fetchResponse;
-      },
-    }) as QuickbaseClient;
-
-    const appResult1 = await client.getApp({ appId });
-    console.log("First getApp response:", appResult1);
-    expect(appResult1).toHaveProperty("id", appId);
-
-    const fieldsResult = await client.getFields({ tableId });
-    console.log("getFields response:", fieldsResult);
-    expect(fieldsResult.length).toBeGreaterThan(0);
-
-    const appResult2 = await client.getApp({ appId });
-    console.log("Second getApp response:", appResult2);
-    expect(appResult2).toHaveProperty("id", appId);
-  });
-});