quickbase-js 1.0.1-beta.0

package/src/code-generation/regenerate-client.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import fetch from "node-fetch";
+import readline from "readline";
+
+const CURRENT_JAR_VERSION = "7.12.0";
+const MAVEN_METADATA_URL =
+  "https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/maven-metadata.xml";
+const CODEGEN_DIR = join(fileURLToPath(import.meta.url), "..");
+const JARS_DIR = join(CODEGEN_DIR, "..", "openapi-jars");
+const SPEC_INPUT = join(CODEGEN_DIR, "output", "quickbase-fixed.json"); // Updated path
+const OUTPUT_DIR = join(CODEGEN_DIR, "..", "generated");
+
+async function getLatestVersion(): Promise<string> {
+  const response = await fetch(MAVEN_METADATA_URL);
+  if (!response.ok)
+    throw new Error(`Failed to fetch Maven metadata: ${response.statusText}`);
+  const text = await response.text();
+  const match = text.match(/<latest>(.*?)<\/latest>/);
+  if (!match)
+    throw new Error("Couldn’t parse latest version from Maven metadata");
+  return match[1];
+}
+
+async function checkAndPromptForUpdate(messages: string[]): Promise<string> {
+  const latestVersion = await getLatestVersion();
+  if (latestVersion === CURRENT_JAR_VERSION) {
+    messages.push(`Current version (${CURRENT_JAR_VERSION}) is the latest.`);
+    return CURRENT_JAR_VERSION;
+  }
+
+  messages.push(
+    `Newer version available: ${latestVersion} (current: ${CURRENT_JAR_VERSION})`
+  );
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const prompt = "Do you want to update to the latest version? (y/n): ";
+    messages.push(prompt);
+    rl.question(prompt, (answer) => {
+      rl.close();
+      if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+        messages.push(`Switching to version ${latestVersion}...`);
+        resolve(latestVersion);
+      } else {
+        messages.push(`Sticking with version ${CURRENT_JAR_VERSION}.`);
+        resolve(CURRENT_JAR_VERSION);
+      }
+    });
+  });
+}
+
+async function ensureJarExists(
+  version: string,
+  messages: string[]
+): Promise<string> {
+  const jarPath = join(JARS_DIR, `openapi-generator-cli-${version}.jar`);
+  const jarUrl = `https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/${version}/openapi-generator-cli-${version}.jar`;
+
+  if (!existsSync(jarPath)) {
+    messages.push(`Downloading OpenAPI Generator CLI v${version}...`);
+    try {
+      execSync(`curl -L -o ${jarPath} ${jarUrl}`, { stdio: "inherit" });
+      messages.push(`Downloaded ${jarPath}`);
+    } catch (error) {
+      messages.push("Failed to download JAR.");
+      throw error;
+    }
+  } else {
+    messages.push(`Using existing ${jarPath}`);
+  }
+  return jarPath;
+}
+
+function regenerateClient(jarPath: string, messages: string[]) {
+  messages.push("Regenerating client from spec...");
+  const command = `java -jar ${jarPath} generate -i ${SPEC_INPUT} -g typescript-fetch -o ${OUTPUT_DIR}`;
+  try {
+    execSync(command, { stdio: "inherit" });
+    messages.push("Client regeneration complete.");
+  } catch (error) {
+    messages.push("Regeneration failed.");
+    throw error;
+  }
+}
+
+async function main() {
+  const messages: string[] = [];
+  try {
+    const versionToUse = await checkAndPromptForUpdate(messages);
+    const jarPath = await ensureJarExists(versionToUse, messages);
+    regenerateClient(jarPath, messages);
+  } catch (error) {
+    console.error("Error occurred during process:", error);
+  } finally {
+    console.log("\n--- Key Messages ---");
+    messages.forEach((msg) => console.log(msg));
+  }
+}
+
+main().catch((error) => {
+  console.error("Error in regeneration process:", error);
+  process.exit(1);
+});

package/src/generated-unified/QuickbaseClient.ts

@@ -0,0 +1,59 @@
+// Generated on 2025-03-10T01:23:11.216Z
+import { App, Field, GetTempTokenDBID200Response, Record, ReportRunResponse, Table, Upsert200Response, Upsert207Response } from "../generated/models";
+
+export interface QuickbaseClient {
+  createApp: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  getApp: (params: { appId: string }) => Promise<App>;
+  getAppEvents: (params: { appId: string }) => Promise<any[]>;
+  copyApp: (params: { appId: string; generated?: any }) => Promise<{ [key: string]: any }>;
+  getAppTables: (params: { appId: string }) => Promise<Table[]>;
+  getTable: (params: { appId: string; tableId: string }) => Promise<{ [key: string]: any }>;
+  updateTable: (params: { appId: string; tableId: string; generated?: { [key: string]: any } }) => Promise<{ [key: string]: any }>;
+  deleteTable: (params: { appId: string; tableId: string }) => Promise<{ [key: string]: any }>;
+  getRelationships: (params: { skip?: number; tableId: string }) => Promise<{ [key: string]: any }>;
+  createRelationship: (params: { tableId: string; generated?: any }) => Promise<{ [key: string]: any }>;
+  updateRelationship: (params: { tableId: string; relationshipId: any; generated?: any }) => Promise<{ [key: string]: any }>;
+  deleteRelationship: (params: { tableId: string; relationshipId: any }) => Promise<{ [key: string]: any }>;
+  getTableReports: (params: { tableId: string }) => Promise<any[]>;
+  getReport: (params: { tableId: string; reportId: string }) => Promise<{ [key: string]: any }>;
+  runReport: (params: { reportId: string; generated: any }) => Promise<ReportRunResponse[]>;
+  getFields: (params: { tableId: string; includeFieldPerms?: boolean }) => Promise<Field[]>;
+  getField: (params: { tableId: string; includeFieldPerms?: boolean; fieldId: number }) => Promise<{ [key: string]: any }>;
+  updateField: (params: { tableId: string; fieldId: number; generated?: any }) => Promise<{ [key: string]: any }>;
+  getFieldsUsage: (params: { tableId: string; skip?: number; top?: number }) => Promise<any[]>;
+  getFieldUsage: (params: { tableId: string; fieldId: number }) => Promise<any[]>;
+  runFormula: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  upsert: (params: { generated?: { [key: string]: any } }) => Promise<{ [key: string]: any }>;
+  deleteRecords: (params: { generated?: { [key: string]: any } }) => Promise<{ [key: string]: any }>;
+  upsertRecords: (params: { generated: { [key: string]: string }[] }) => Promise<Upsert200Response[] | Upsert207Response[]>;
+  getTempTokenDBID: (params: { dbid: string }) => Promise<GetTempTokenDBID200Response>;
+  exchangeSsoToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  cloneUserToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  transferUserToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  deactivateUserToken: (params: {  }) => Promise<{ [key: string]: any }>;
+  deleteUserToken: (params: {  }) => Promise<{ [key: string]: any }>;
+  downloadFile: (params: { tableId: string; recordId: number; fieldId: number; versionNumber: number }) => Promise<any>;
+  deleteFile: (params: { tableId: string; recordId: number; fieldId: number; versionNumber: number }) => Promise<{ [key: string]: any }>;
+  getUsers: (params: { accountId?: any; generated?: { [key: string]: any } }) => Promise<{ [key: string]: any }>;
+  denyUsers: (params: { accountId?: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  denyUsersAndGroups: (params: { accountId?: any; shouldDeleteFromGroups: boolean; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  undenyUsers: (params: { accountId?: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  addMembersToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  removeMembersFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  addManagersToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  removeManagersFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  addSubgroupsToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  removeSubgroupsFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
+  audit: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
+  platformAnalyticReads: (params: { day?: string }) => Promise<{ [key: string]: any }>;
+  platformAnalyticEventSummaries: (params: { accountId?: any; generated?: any }) => Promise<any>;
+  exportSolution: (params: { solutionId: string; qBLVersion?: string }) => Promise<any>;
+  updateSolution: (params: { solutionId: string; generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  createSolution: (params: { generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  exportSolutionToRecord: (params: { solutionId: string; tableId: string; fieldId: number; xQBLErrorsAsSuccess?: boolean; qBLVersion?: string }) => Promise<any>;
+  createSolutionFromRecord: (params: { tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  updateSolutionToRecord: (params: { solutionId: string; tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  changesetSolution: (params: { solutionId: string; generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  changesetSolutionFromRecord: (params: { solutionId: string; tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
+  generateDocument: (params: { templateId: any; tableId: string; recordId?: any; filename: string; accept?: string; format?: string; margin?: string; unit?: string; pageSize?: string; orientation?: string; realm?: string }) => Promise<{ [key: string]: any }>;
+}

package/src/index.ts

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

package/src/log-gen.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml"; // Requires "js-yaml": "^4.1.0" in package.json
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const rootDir: string = "./";
+const excludeDirs: string[] = ["node_modules", ".git"];
+
+const importantFolders: string[] = [];
+
+const importantFiles: string[] = [
+  "package.json",
+  "tsconfig.json",
+  "rollup.config.js",
+  "vitest.config.ts",
+  "generated-unified/QuickbaseClient.ts",
+  "src/quickbaseClient.ts",
+  "src/tokenCache.ts",
+  "src/code-generation/fix-spec-main.ts",
+  "src/code-generation/fix-spec-paths.ts",
+  "src/code-generation/fix-spec-definitions.ts",
+  "src/code-generation/regenerate-client.ts",
+  "src/code-generation/generate-unified-interface.ts",
+];
+
+const projectGoals: string[] = [
+  "Implement a QuickBase API client in TypeScript.",
+  "Generate client methods from the QuickBase RESTful API spec.",
+  "Provide a simple and intuitive interface for interacting with QuickBase.",
+  "Support both Node.js and browser environments.",
+  "Use case: JS frameworks like React, Vue, and Angular hosted in QuickBase code pages.",
+  "Node.js is supported using User Tokens",
+  "Use OpenAPI to generate the TypeScript types and methods.",
+  "Use the latest ES6+ features and TypeScript features.",
+  "#",
+  "No manual updating methods when the QuickBase API changes.",
+  "The proxy magic dynamically maps generated methods.",
+  "No manual endpoint definitions—endpoints come from the generated apis (e.g., AppsApi.getApp).",
+  "#",
+  "Per-Instance Store: tokenCache is defined per quickbaseClient call, so each instance has its own isolated TokenCache.",
+  "No Singleton: No shared state—tokens are fetched and cached within the current instance.",
+];
+
+interface TreeNode {
+  name: string;
+  type: "directory" | "file";
+  contents?: string;
+  children?: TreeNode[];
+}
+
+function buildTree(dir: string): TreeNode {
+  const node: TreeNode = {
+    name: path.basename(dir) || "",
+    type: "directory",
+    children: [],
+  };
+
+  const files: fs.Dirent[] = fs.readdirSync(dir, { withFileTypes: true });
+
+  files.forEach((file: fs.Dirent) => {
+    const filePath: string = path.join(dir, file.name);
+    const relativePath: string = path
+      .relative(rootDir, filePath)
+      .replace(/\\/g, "/");
+
+    if (file.isDirectory() && excludeDirs.includes(file.name)) return;
+
+    const childNode: TreeNode = {
+      name: file.name,
+      type: file.isDirectory() ? "directory" : "file",
+    };
+
+    if (file.isDirectory()) {
+      childNode.children = buildTree(filePath).children;
+    } else {
+      const isInImportantFolder = importantFolders.some(
+        (folder) =>
+          relativePath.startsWith(folder + "/") || relativePath === folder
+      );
+      if (importantFiles.includes(relativePath) || isInImportantFolder) {
+        try {
+          childNode.contents = fs.readFileSync(filePath, "utf8");
+        } catch (err: unknown) {
+          childNode.contents = `[Error reading file: ${
+            (err as Error).message
+          }]`;
+        }
+      }
+    }
+
+    node.children!.push(childNode);
+  });
+
+  return node;
+}
+
+function generateTreeSnapshot(): string {
+  const snapshot = {
+    project: "quickbase-js",
+    date: new Date().toLocaleDateString(),
+    root: path.resolve(rootDir),
+    goals: projectGoals,
+    tree: buildTree(rootDir),
+  };
+
+  return yaml.dump(snapshot, { lineWidth: -1 }); // No line wrapping for readability
+}
+
+try {
+  const output: string = generateTreeSnapshot();
+  fs.writeFileSync("logGen.yaml", output, "utf8");
+  const lineCount: number = output.split("\n").length - 1; // Exclude trailing newline
+  console.log("logGen.yaml");
+  console.log(`Lines: ${lineCount}`);
+} catch (error: unknown) {
+  console.error("Failed to generate tree snapshot:", (error as Error).message);
+  process.exit(1);
+}

package/src/quickbaseClient.ts

@@ -0,0 +1,320 @@
+// src/quickbaseClient.ts
+import { QuickbaseClient as IQuickbaseClient } from "./generated-unified/QuickbaseClient.ts";
+import {
+  Configuration,
+  HTTPHeaders,
+  ResponseError,
+} from "./generated/runtime.ts";
+import * as apis from "./generated/apis/index.ts";
+import { simplifyName } from "./utils.ts";
+import { TokenCache } from "./tokenCache.ts";
+
+// Re-export all model types from generated/models
+export * from "./generated/models";
+
+// Rename the interface to avoid naming conflict if needed
+export interface QuickbaseClient extends IQuickbaseClient {}
+
+export interface QuickbaseConfig {
+  realm: string;
+  userToken?: string;
+  tempToken?: string;
+  useTempTokens?: boolean;
+  debug?: boolean;
+  fetchApi?: typeof fetch;
+}
+
+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[];
+}
+
+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");
+
+// New utility function to extract dbid
+const extractDbid = (
+  params: Partial<TempTokenParams>,
+  errorMessage: string
+): string => {
+  const dbid = params.appId || params.tableId || params.dbid;
+  if (!dbid) {
+    throw new Error(errorMessage);
+  }
+  return dbid;
+};
+
+export function quickbaseClient(config: QuickbaseConfig): QuickbaseClient {
+  const {
+    realm,
+    userToken,
+    tempToken: initialTempToken,
+    useTempTokens,
+    fetchApi,
+    debug,
+  } = config;
+  const baseUrl = `https://api.quickbase.com/v1`;
+
+  const tokenCache = new TokenCache();
+
+  const headers: HTTPHeaders = {
+    "QB-Realm-Hostname": `${realm}.quickbase.com`,
+    "Content-Type": "application/json",
+  };
+
+  if (initialTempToken) {
+    headers["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
+  } else if (userToken && !useTempTokens) {
+    headers["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: { ...headers },
+    fetchApi: fetchApi || defaultFetch,
+    credentials: useTempTokens ? "include" : "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 method = api[rawMethodName as keyof typeof api];
+          const boundMethod = method.bind(api) as unknown;
+          if (typeof boundMethod === "function" && boundMethod.length <= 2) {
+            methodMap[simplifiedName] = {
+              api,
+              method: boundMethod as ApiMethod<typeof simplifiedName>,
+              paramMap: getParamNames(method),
+            };
+            if (debug)
+              console.log(`Mapped ${rawMethodName} to ${simplifiedName}`);
+          }
+        });
+    }
+    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: { ...headers },
+        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,
+        `Expires at: ${new Date(
+          Date.now() + (4 * 60 + 50) * 1000
+        ).toISOString()}`
+      );
+    }
+    return token;
+  };
+
+  const invokeMethod = async <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) {
+      console.error(`Method ${methodName} not found in methodMap`, methodMap);
+      throw new Error(`Method ${methodName} not found`);
+    }
+
+    let token =
+      initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
+    let initOverrides: RequestInit = {};
+
+    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]
+        >;
+      }
+    }
+
+    if (useTempTokens && !token) {
+      const dbid = extractDbid(
+        params,
+        `No dbid found in params for ${methodName} to fetch temp token`
+      );
+      if (debug)
+        console.log(`Cache state before fetch for ${dbid}:`, tokenCache.dump());
+      const cachedToken = tokenCache.get(dbid);
+      if (cachedToken) {
+        token = cachedToken;
+        if (debug) console.log(`Reusing cached token for dbid: ${dbid}`, token);
+      } else {
+        if (typeof globalThis.window === "undefined" && !fetchApi) {
+          throw new Error(
+            "Temporary tokens require a browser environment or a custom fetchApi with browser-like session support"
+          );
+        }
+        token = await fetchTempToken(dbid);
+        if (methodName === "getTempTokenDBID") {
+          return { temporaryAuthorization: token } as ReturnType<
+            QuickbaseClient[K]
+          >;
+        }
+      }
+      initOverrides.headers = {
+        ...headers,
+        Authorization: `QB-TEMP-TOKEN ${token}`,
+      };
+    }
+
+    if (debug) console.log(`Invoking ${methodName} with params:`, params);
+    if (debug)
+      console.log(`Calling method with args:`, [params, initOverrides]);
+    const args: [any, RequestInit | undefined] =
+      methodInfo.paramMap.length === 1 &&
+      methodInfo.paramMap[0] === "requestParameters"
+        ? [params, initOverrides]
+        : [params, initOverrides];
+
+    try {
+      const response = await methodInfo.method(...args);
+      if (debug) console.log(`Response from ${methodName}:`, response);
+      return response;
+    } catch (error) {
+      if (
+        error instanceof ResponseError &&
+        error.response.status === 401 &&
+        retryCount < 1
+      ) {
+        if (debug)
+          console.log(
+            `Authorization error for ${methodName}, refreshing token:`,
+            error.message
+          );
+        const dbid = extractDbid(
+          params,
+          `No dbid to refresh token after authorization error`
+        );
+        token = await fetchTempToken(dbid);
+        initOverrides.headers = {
+          ...headers,
+          Authorization: `QB-TEMP-TOKEN ${token}`,
+        };
+        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();
+          console.log(`Error response body for ${methodName}:`, errorBody);
+          errorMessage = errorBody.message || errorMessage;
+        } catch (e) {
+          console.log(
+            `Failed to parse error response for ${methodName}:`,
+            error.message
+          );
+        }
+        throw new Error(
+          `API Error: ${errorMessage} (Status: ${error.response.status})`
+        );
+      }
+      throw error;
+    }
+  };
+
+  return 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]) => {
+          if (debug) console.log(`Proxy called ${methodName} with:`, params);
+          return invokeMethod(methodName, params);
+        };
+      }
+      console.warn(`Method ${prop} not found in methodMap`);
+      return undefined;
+    },
+  });
+}