quickbase-js 1.1.0-beta.1 → 1.1.0-beta.3

package/log-gen.yaml

@@ -140,6 +140,8 @@ tree:
                   type: file
                 - name: RecordsApi.ts
                   type: file
+                - name: RelationshipsApi.ts
+                  type: file
                 - name: ReportsApi.ts
                   type: file
                 - name: SolutionsApi.ts
@@ -181,6 +183,8 @@ tree:
                   type: file
                 - name: CopyAppRequest.ts
                   type: file
+                - name: CopyAppRequestProperties.ts
+                  type: file
                 - name: CreateApp200Response.ts
                   type: file
                 - name: CreateAppRequest.ts
@@ -223,6 +227,8 @@ tree:
                   type: file
                 - name: GetRelationships200Response.ts
                   type: file
+                - name: GetRelationships200ResponseMetadata.ts
+                  type: file
                 - name: GetReport200Response.ts
                   type: file
                 - name: GetTempTokenDBID200Response.ts
@@ -253,6 +259,12 @@ tree:
                   type: file
                 - name: Record.ts
                   type: file
+                - name: RecordValue.ts
+                  type: file
+                - name: Relationship.ts
+                  type: file
+                - name: RelationshipField.ts
+                  type: file
                 - name: RemoveMembersFromGroup200Response.ts
                   type: file
                 - name: RemoveSubgroupsFromGroup200Response.ts
@@ -263,6 +275,20 @@ tree:
                   type: file
                 - name: RunFormulaRequest.ts
                   type: file
+                - name: RunQueryRequest.ts
+                  type: file
+                - name: RunQueryRequestGroupByInner.ts
+                  type: file
+                - name: RunQueryRequestOptions.ts
+                  type: file
+                - name: RunQueryRequestSortByInner.ts
+                  type: file
+                - name: RunQueryResponse.ts
+                  type: file
+                - name: RunQueryResponseFieldsInner.ts
+                  type: file
+                - name: RunQueryResponseMetadata.ts
+                  type: file
                 - name: Table.ts
                   type: file
                 - name: TransferUserToken200Response.ts
@@ -279,6 +305,8 @@ tree:
                   type: file
                 - name: Upsert200Response.ts
                   type: file
+                - name: Upsert200ResponseDataInnerValue.ts
+                  type: file
                 - name: Upsert200ResponseMetadata.ts
                   type: file
                 - name: Upsert207Response.ts
@@ -296,6 +324,67 @@ tree:
           children:
             - name: QuickbaseClient.ts
               type: file
+              contents: |
+                // Generated on 2025-03-11T21:24:23.349Z
+                import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, DeleteRecords200Response, DeleteRecordsRequest, DeleteTableResponse, Field, GetRelationships200Response, GetTempTokenDBID200Response, ReportRunResponse, RunQueryRequest, RunQueryResponse, Table, UpdateTableRequest, Upsert200Response, Upsert207Response, UpsertRequest } from "../generated/models";
+
+                export interface QuickbaseClient {
+                  createApp: (params: { body: CreateAppRequest }) => Promise<CreateApp200Response>;
+                  getApp: (params: { appId: string }) => Promise<App>;
+                  getAppEvents: (params: { appId: string }) => Promise<any[]>;
+                  copyApp: (params: { appId: string; body: CopyAppRequest }) => Promise<CopyApp200Response>;
+                  getAppTables: (params: { appId: string }) => Promise<Table[]>;
+                  createTable: (params: { appId: string; body: any }) => Promise<Table>;
+                  getTable: (params: { tableId: string; appId: string }) => Promise<Table>;
+                  updateTable: (params: { tableId: string; appId: string; body: UpdateTableRequest }) => Promise<Table>;
+                  deleteTable: (params: { tableId: string; appId: string }) => Promise<DeleteTableResponse>;
+                  getRelationships: (params: { tableId: string; skip?: number }) => Promise<GetRelationships200Response>;
+                  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: { body: UpsertRequest }) => Promise<Upsert200Response | Upsert207Response>;
+                  deleteRecords: (params: { body: DeleteRecordsRequest }) => Promise<DeleteRecords200Response>;
+                  runQuery: (params: { body: RunQueryRequest }) => Promise<RunQueryResponse>;
+                  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 }>;
+                }
         - name: index.ts
           type: file
         - name: log-gen.ts
@@ -307,6 +396,324 @@ tree:
               type: file
         - name: quickbaseClient.ts
           type: file
+          contents: |
+            // 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 { TokenCache } from "./tokenCache.ts";
+
+            // Re-export all model types from generated/models
+            export * from "./generated/models";
+
+            const simplifyName = (name: string): string =>
+              name
+                .replace(/ById$/, "")
+                .replace(/Api$/, "")
+                .replace(/^(\w)/, (_, c) => c.toLowerCase());
+
+            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");
+
+            const extractDbid = (
+              params: Partial<TempTokenParams>,
+              errorMessage: string
+            ): string => {
+              const dbid = params.dbid || params.tableId || params.appId;
+              if (!dbid) {
+                throw new Error(errorMessage);
+              }
+              return dbid;
+            };
+
+            export function quickbase(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 any) as unknown;
+                      if (typeof boundMethod === "function" && boundMethod.length <= 2) {
+                        methodMap[simplifiedName] = {
+                          api,
+                          method: boundMethod as ApiMethod<typeof simplifiedName>,
+                          paramMap: getParamNames(method),
+                        };
+                      }
+                    });
+                }
+                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) {
+                  throw new Error(`Method ${methodName} not found`);
+                }
+
+                const args: [any, RequestInit | undefined] =
+                  methodInfo.paramMap.length === 1 &&
+                  methodInfo.paramMap[0] === "requestParameters"
+                    ? [{ requestParameters: params }, undefined]
+                    : [params, undefined];
+
+                let token =
+                  initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
+
+                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`
+                  );
+                  const cachedToken = tokenCache.get(dbid);
+                  if (cachedToken) {
+                    token = cachedToken;
+                  } 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]
+                      >;
+                    }
+                  }
+                  args[1] = {
+                    headers: {
+                      ...headers,
+                      Authorization: `QB-TEMP-TOKEN ${token}`,
+                    },
+                  };
+                }
+
+                try {
+                  const response = await methodInfo.method(...args);
+                  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);
+                    args[1] = {
+                      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();
+                      if (debug) {
+                        console.log(`Error response body for ${methodName}:`, errorBody);
+                      }
+                      errorMessage = errorBody.message || errorMessage;
+                    } catch (e) {
+                      // Silent fail on parse error
+                    }
+                    throw new Error(
+                      `API Error: ${errorMessage} (Status: ${error.response.status})`
+                    );
+                  }
+                  throw error;
+                }
+              };
+
+              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);
+                  }
+                  return undefined;
+                },
+              });
+
+              return proxy;
+            }
         - name: tokenCache.ts
           type: file
     - name: test-artifacts
@@ -332,1091 +739,18 @@ tree:
                   children:
                     - name: cacheSwitching.test.ts
                       type: file
-                      contents: |
-                        // tests/playwright/qb/auth/cacheSwitching.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } from "../../../../src/quickbaseClient.ts";
-                        import fetch from "node-fetch";
-                        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", () => {
-                          // Removed test.use({ context: ... })
-
-                          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;
-                            const username = process.env.QB_USERNAME;
-                            const password = process.env.QB_PASSWORD;
-
-                            if (!realm) throw new Error("QB_REALM is not defined in .env");
-                            if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-                            if (!tableId) throw new Error("QB_TABLE_ID is not defined in .env");
-                            if (!username) throw new Error("QB_USERNAME is not defined in .env");
-                            if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-                            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 browserFetch = async (url: string, init?: RequestInit) => {
-                              const response = await page.evaluate(
-                                async ([fetchUrl, fetchInit]) => {
-                                  const res = await fetch(fetchUrl, {
-                                    ...fetchInit,
-                                    credentials: "include",
-                                  });
-                                  const body = await res.text();
-                                  return {
-                                    ok: res.ok,
-                                    status: res.status,
-                                    statusText: res.statusText,
-                                    headers: Object.fromEntries(res.headers.entries()),
-                                    body,
-                                  };
-                                },
-                                [url, init] 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: 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;
-                            };
-
-                            const client = quickbase({
-                              realm,
-                              useTempTokens: true,
-                              debug: true,
-                              fetchApi: async (url, init) => {
-                                if (url.includes("/auth/temporary/")) {
-                                  return browserFetch(url, init);
-                                }
-                                console.log(`Fetching ${url} with init:`, init);
-                                const response = await fetch(url, init as RequestInit);
-                                const body = await response.text();
-
-                                console.log(`Raw response from ${url}:`, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  body,
-                                });
-
-                                const fetchResponse = new Response(body || null, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  headers: Object.fromEntries(response.headers.entries()),
-                                });
-
-                                fetchResponse.json = async () => {
-                                  if (!body) throw new Error("Empty response body from API");
-                                  try {
-                                    return JSON.parse(body);
-                                  } catch (e) {
-                                    throw new SyntaxError(`Invalid JSON response: ${body}`);
-                                  }
-                                };
-
-                                return fetchResponse;
-                              },
-                            });
-
-                            const appResult1 = await client.getApp({ appId });
-                            console.log("First getApp response:", appResult1);
-                            expect(appResult1.id).toBe(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.id).toBe(appId);
-                          });
-                        });
                     - name: fetchTempToken401.test.ts
                       type: file
-                      contents: |
-                        // tests/playwright/qb/auth/tokenInvalidation.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } from "../../../../src/quickbaseClient.ts";
-                        import fetch from "node-fetch";
-                        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}`);
-
-                              await page.goto(quickbaseUrl, { timeout: 60000 });
-                              await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-                              await page.fill("input[name='loginid']", username);
-                              await page.fill("input[name='password']", password);
-                              await page.click("#signin");
-                              await page.waitForURL(`https://*.quickbase.com/**`, {
-                                waitUntil: "networkidle",
-                                timeout: 60000,
-                              });
-
-                              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 - Token Invalidation with Cached Token", () => {
-                          test("retries with new token when cached token is unexpectedly invalidated", async ({
-                            page,
-                          }) => {
-                            const realm = process.env.QB_REALM;
-                            const appId = process.env.QB_APP_ID;
-                            const username = process.env.QB_USERNAME;
-                            const password = process.env.QB_PASSWORD;
-
-                            if (!realm) throw new Error("QB_REALM is not defined in .env");
-                            if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-                            if (!username) throw new Error("QB_USERNAME is not defined in .env");
-                            if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-                            // Login to QuickBase
-                            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.");
-                            }
-
-                            // Navigate to the app page to ensure session context
-                            await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-                              waitUntil: "networkidle",
-                              timeout: 60000,
-                            });
-                            console.log("Post-login URL after app navigation:", page.url());
-
-                            // Track tokens and call counts
-                            let callCount = 0;
-                            let getAppCallCount = 0;
-                            let initialToken: string | null = null;
-                            let retryToken: string | null = null;
-
-                            const browserFetch = async (url: string, init?: RequestInit) => {
-                              console.log(`browserFetch called for ${url}, callCount: ${callCount}`);
-                              const response = await page.evaluate(
-                                async ([fetchUrl, fetchInit]) => {
-                                  const res = await fetch(fetchUrl, {
-                                    ...fetchInit,
-                                    credentials: "include",
-                                  });
-                                  const body = await res.text();
-                                  return {
-                                    ok: res.ok,
-                                    status: res.status,
-                                    statusText: res.statusText,
-                                    headers: Object.fromEntries(res.headers.entries()),
-                                    body,
-                                  };
-                                },
-                                [url, init] 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: response.headers,
-                              });
-
-                              // Capture token from response
-                              if (url.includes("/auth/temporary/")) {
-                                const json = await fetchResponse.clone().json();
-                                const token = json.temporaryAuthorization;
-                                if (!initialToken) {
-                                  initialToken = token;
-                                  console.log(`Captured initial token: ${initialToken}`);
-                                } else if (!retryToken) {
-                                  retryToken = token;
-                                  console.log(`Captured retry token: ${retryToken}`);
-                                }
-                              }
-
-                              return fetchResponse;
-                            };
-
-                            const client = quickbase({
-                              realm,
-                              useTempTokens: true,
-                              debug: true,
-                              fetchApi: async (url, init) => {
-                                callCount++;
-                                console.log(`fetchApi called for ${url}, callCount: ${callCount}`);
-
-                                if (url.includes("/auth/temporary/")) {
-                                  return browserFetch(url, init); // Use browser fetch for temp tokens
-                                }
-
-                                if (url.includes(`/apps/${appId}`)) {
-                                  getAppCallCount++;
-                                  console.log(`getApp call count: ${getAppCallCount}`);
-                                  // Simulate 401 on the first getApp call to trigger retry
-                                  if (getAppCallCount === 1) {
-                                    console.log("Simulating 401 Unauthorized for first getApp call");
-                                    return new Response(JSON.stringify({ message: "Unauthorized" }), {
-                                      status: 401,
-                                      statusText: "Unauthorized",
-                                      headers: { "Content-Type": "application/json" },
-                                    });
-                                  }
-                                }
-
-                                // Use node-fetch for subsequent calls (including retries)
-                                console.log(`Fetching ${url} with init:`, init);
-                                const response = await fetch(url, init as RequestInit);
-                                const body = await response.text();
-
-                                console.log(`Raw response from ${url}:`, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  body,
-                                });
-
-                                return new Response(body || null, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  headers: Object.fromEntries(response.headers.entries()),
-                                });
-                              },
-                            });
-
-                            // Pre-fetch token to simulate cached token
-                            console.log("Pre-fetching initial token...");
-                            const preFetchResult = await client.getTempTokenDBID({ dbid: appId });
-                            console.log("Initial token pre-fetched and cached:", preFetchResult);
-
-                            // Call getApp, expecting a 401 followed by a retry with a new token
-                            const appResult = await client.getApp({ appId });
-                            console.log("App response after token invalidation and retry:", appResult);
-
-                            // Validate the app response
-                            expect(appResult).toHaveProperty("id", appId);
-                            expect(appResult).toHaveProperty("name");
-
-                            // Verify call counts and token behavior
-                            console.log(
-                              `Final callCount: ${callCount}, Final getAppCallCount: ${getAppCallCount}`
-                            );
-                            expect(callCount).toBe(4); // Pre-fetch, 401, token retry, getApp success
-                            expect(getAppCallCount).toBe(2); // Initial 401, retry success
-
-                            // Validate pre-fetch and retry tokens
-                            console.log(`Initial token: ${initialToken}`);
-                            console.log(`Retry token: ${retryToken}`);
-                            expect(initialToken).toBeDefined();
-                            expect(initialToken).toBe(preFetchResult.temporaryAuthorization); // Confirm pre-fetch token was used
-                            expect(retryToken).toBeDefined();
-                            expect(initialToken).not.toBe(retryToken); // Confirm retry used a new token
-                          });
-                        });
                     - name: getAppWithUserToken.test.ts
                       type: file
-                      contents: |
-                        // tests/integration/auth/getAppWithUserToken.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } 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}`);
-
-                              await page.goto(quickbaseUrl, { timeout: 60000 });
-                              await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-                              await page.fill("input[name='loginid']", username);
-                              await page.fill("input[name='password']", password);
-                              await page.click("#signin");
-                              await page.waitForURL(`https://*.quickbase.com/**`, {
-                                waitUntil: "networkidle",
-                                timeout: 60000,
-                              });
-
-                              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 - getApp with User Token", () => {
-                          test("uses user token for getApp in browser", async ({ page }) => {
-                            const realm = process.env.QB_REALM;
-                            const appId = process.env.QB_APP_ID;
-                            const username = process.env.QB_USERNAME;
-                            const password = process.env.QB_PASSWORD;
-                            const userToken = process.env.QB_USER_TOKEN;
-
-                            if (!realm) throw new Error("QB_REALM is not defined in .env");
-                            if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-                            if (!username) throw new Error("QB_USERNAME is not defined in .env");
-                            if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-                            if (!userToken) throw new Error("QB_USER_TOKEN is not defined in .env");
-
-                            // Login to Quickbase (optional, to mimic code page context)
-                            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.");
-                            }
-
-                            // Navigate to the app page to ensure session context (optional)
-                            await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-                              waitUntil: "networkidle",
-                              timeout: 60000,
-                            });
-
-                            const currentUrl = page.url();
-                            console.log("Post-login URL after app navigation:", currentUrl);
-
-                            // Create Quickbase client with user token
-                            const client = quickbase({
-                              realm,
-                              userToken, // Use user token instead of temp tokens
-                              debug: true,
-                              fetchApi: async (url, init) => {
-                                console.log(`Fetching ${url} with init:`, init);
-                                const response = await page.evaluate(
-                                  async ([fetchUrl, fetchInit]) => {
-                                    const res = await fetch(fetchUrl, {
-                                      ...fetchInit,
-                                      credentials: "omit", // No cookies needed with user token
-                                    });
-                                    const body = await res.text();
-                                    return {
-                                      ok: res.ok,
-                                      status: res.status,
-                                      statusText: res.statusText,
-                                      headers: Object.fromEntries(res.headers.entries()),
-                                      body,
-                                    };
-                                  },
-                                  [url, init] 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: 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;
-                              },
-                            });
-
-                            // Call getApp directly
-                            const appResult = await client.getApp({ appId });
-                            console.log("App response using user token:", appResult);
-
-                            // Validate the app response
-                            expect(appResult).toHaveProperty("id", appId);
-                            expect(appResult).toHaveProperty("name");
-                          });
-                        });
                     - name: getTempToken.test.ts
                       type: file
-                      contents: |
-                        // tests/integration/auth/getTempToken.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } from "../../../../src/quickbaseClient.ts";
-                        import fetch from "node-fetch";
-                        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}`);
-
-                              await page.goto(quickbaseUrl, { timeout: 60000 });
-                              await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-                              await page.fill("input[name='loginid']", username);
-                              await page.fill("input[name='password']", password);
-                              await page.click("#signin");
-                              await page.waitForURL(`https://*.quickbase.com/**`, {
-                                waitUntil: "networkidle",
-                                timeout: 60000,
-                              });
-
-                              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 - getApp with Temp Tokens", () => {
-                          test("uses temp tokens automatically for getApp in browser", async ({
-                            page,
-                          }) => {
-                            const realm = process.env.QB_REALM;
-                            const appId = process.env.QB_APP_ID;
-                            const username = process.env.QB_USERNAME;
-                            const password = process.env.QB_PASSWORD;
-
-                            if (!realm) throw new Error("QB_REALM is not defined in .env");
-                            if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-                            if (!username) throw new Error("QB_USERNAME is not defined in .env");
-                            if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-                            // Login to QuickBase
-                            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.");
-                            }
-
-                            // Navigate to the app page to ensure session context
-                            await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-                              waitUntil: "networkidle",
-                              timeout: 60000,
-                            });
-                            console.log("Post-login URL after app navigation:", page.url());
-
-                            // Define browser fetch function
-                            const browserFetch = async (url: string, init?: RequestInit) => {
-                              const response = await page.evaluate(
-                                async ([fetchUrl, fetchInit]) => {
-                                  const res = await fetch(fetchUrl, {
-                                    ...fetchInit,
-                                    credentials: "include",
-                                  });
-                                  const body = await res.text();
-                                  return {
-                                    ok: res.ok,
-                                    status: res.status,
-                                    statusText: res.statusText,
-                                    headers: Object.fromEntries(res.headers.entries()),
-                                    body,
-                                  };
-                                },
-                                [url, init] 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: 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;
-                            };
-
-                            // Single client with conditional fetch
-                            const client = quickbase({
-                              realm,
-                              useTempTokens: true,
-                              debug: true,
-                              fetchApi: async (url, init) => {
-                                if (url.includes("/auth/temporary/")) {
-                                  return browserFetch(url, init); // Use browser context for temp token
-                                }
-                                console.log(`Fetching ${url} with init:`, init);
-                                const response = await fetch(url, init as RequestInit); // Node-fetch for API calls
-                                const body = await response.text();
-
-                                console.log(`Raw response from ${url}:`, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  body,
-                                });
-
-                                const fetchResponse = new Response(body || null, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  headers: Object.fromEntries(response.headers.entries()),
-                                });
-
-                                fetchResponse.json = async () => {
-                                  if (!body) throw new Error("Empty response body from API");
-                                  try {
-                                    return JSON.parse(body);
-                                  } catch (e) {
-                                    throw new SyntaxError(`Invalid JSON response: ${body}`);
-                                  }
-                                };
-
-                                return fetchResponse;
-                              },
-                            });
-
-                            // Call getApp directly, letting the library handle temp token logic
-                            const appResult = await client.getApp({ appId });
-                            console.log("App response using auto-fetched temp token:", appResult);
-
-                            // Validate the app response
-                            expect(appResult).toHaveProperty("id", appId);
-                            expect(appResult).toHaveProperty("name");
-                          });
-                        });
                     - name: tokenPrefetch.test.ts
                       type: file
-                      contents: |
-                        // tests/playwright/qb/auth/tokenPrefetch.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } from "../../../../src/quickbaseClient.ts";
-                        import fetch from "node-fetch";
-                        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}`);
-
-                              await page.goto(quickbaseUrl, { timeout: 60000 });
-                              await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-                              await page.fill("input[name='loginid']", username);
-                              await page.fill("input[name='password']", password);
-                              await page.click("#signin");
-                              await page.waitForURL(`https://*.quickbase.com/**`, {
-                                waitUntil: "networkidle",
-                                timeout: 60000,
-                              });
-
-                              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 - Token Pre-Fetch and Cache Reuse", () => {
-                          test("pre-fetches token and reuses it for subsequent API calls", async ({
-                            page,
-                          }) => {
-                            const realm = process.env.QB_REALM;
-                            const appId = process.env.QB_APP_ID;
-                            const username = process.env.QB_USERNAME;
-                            const password = process.env.QB_PASSWORD;
-
-                            if (!realm) throw new Error("QB_REALM is not defined in .env");
-                            if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-                            if (!username) throw new Error("QB_USERNAME is not defined in .env");
-                            if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-                            // Login to QuickBase
-                            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.");
-                            }
-
-                            // Navigate to the app page to ensure session context
-                            await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-                              waitUntil: "networkidle",
-                              timeout: 60000,
-                            });
-                            console.log("Post-login URL after app navigation:", page.url());
-
-                            // Track tokens and call counts
-                            let callCount = 0;
-                            let cachedToken: string | null = null;
-
-                            const browserFetch = async (url: string, init?: RequestInit) => {
-                              console.log(`browserFetch called for ${url}, callCount: ${callCount}`);
-                              const response = await page.evaluate(
-                                async ([fetchUrl, fetchInit]) => {
-                                  const res = await fetch(fetchUrl, {
-                                    ...fetchInit,
-                                    credentials: "include",
-                                  });
-                                  const body = await res.text();
-                                  return {
-                                    ok: res.ok,
-                                    status: res.status,
-                                    statusText: res.statusText,
-                                    headers: Object.fromEntries(res.headers.entries()),
-                                    body,
-                                  };
-                                },
-                                [url, init] 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: response.headers,
-                              });
-
-                              // Capture token from response
-                              if (url.includes("/auth/temporary/")) {
-                                const json = await fetchResponse.clone().json();
-                                const token = json.temporaryAuthorization;
-                                cachedToken = token; // Store the pre-fetched token
-                                console.log(`Captured pre-fetched token: ${cachedToken}`);
-                              }
-
-                              return fetchResponse;
-                            };
-
-                            const client = quickbase({
-                              realm,
-                              useTempTokens: true,
-                              debug: true,
-                              fetchApi: async (url, init) => {
-                                callCount++;
-                                console.log(`fetchApi called for ${url}, callCount: ${callCount}`);
-
-                                if (url.includes("/auth/temporary/")) {
-                                  return browserFetch(url, init); // Use browser fetch for temp tokens
-                                }
-
-                                // Use node-fetch for app calls, ensuring we track reuse
-                                console.log(`Fetching ${url} with init:`, init);
-                                const response = await fetch(url, init as RequestInit);
-                                const body = await response.text();
-
-                                console.log(`Raw response from ${url}:`, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  body,
-                                });
-
-                                return new Response(body || null, {
-                                  status: response.status,
-                                  statusText: response.statusText,
-                                  headers: Object.fromEntries(response.headers.entries()),
-                                });
-                              },
-                            });
-
-                            // Step 1: Pre-fetch token
-                            console.log("Pre-fetching token...");
-                            const tokenResult = await client.getTempTokenDBID({ dbid: appId });
-                            console.log("Pre-fetched token result:", tokenResult);
-                            expect(tokenResult).toHaveProperty("temporaryAuthorization");
-                            expect(cachedToken).toBe(tokenResult.temporaryAuthorization);
-
-                            // Step 2: Call getApp, expecting it to reuse the cached token
-                            console.log("Calling getApp with pre-fetched token...");
-                            const appResult = await client.getApp({ appId });
-                            console.log("App response:", appResult);
-
-                            // Validate the app response
-                            expect(appResult).toHaveProperty("id", appId);
-                            expect(appResult).toHaveProperty("name");
-
-                            // Verify call count and token reuse
-                            console.log(`Final callCount: ${callCount}`);
-                            expect(callCount).toBe(2); // One for pre-fetch, one for getApp
-                            expect(cachedToken).toBeDefined();
-
-                            // Check that getApp reused the token by inspecting logs manually or adding a header check if needed
-                            console.log(`Pre-fetched token: ${cachedToken}`);
-                          });
-                        });
                     - name: tokenRenewal.test.ts
                       type: file
-                      contents: |
-                        // tests/playwright/qb/auth/tokenRenewal.test.ts
-                        import { test, expect } from "@playwright/test";
-                        import { quickbase } from "../../../../src/quickbaseClient.ts";
-                        import dotenv from "dotenv";
-
-                        dotenv.config();
-
-                        const loginToQuickbase = async (
-                          page,
-                          quickbaseUrl,
-                          username,
-                          password,
-                          appUrl
-                        ) => {
-                          console.log("Logging in to QuickBase");
-                          await page.goto(quickbaseUrl, { timeout: 60000 });
-                          await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-                          await page.fill("input[name='loginid']", username);
-                          await page.fill("input[name='password']", password);
-                          await page.click("#signin");
-                          await page.waitForURL(`https://*.quickbase.com/**`, {
-                            waitUntil: "networkidle",
-                            timeout: 60000,
-                          });
-                          console.log("Signed In to QuickBase.");
-                          await page.goto(appUrl, { waitUntil: "networkidle", timeout: 60000 });
-                          console.log("Navigated to app URL:", page.url());
-                        };
-
-                        test.describe("QuickbaseClient Integration - Temp Token Renewal", () => {
-                          test("renews temp token after 5 minutes with getApp → wait → getApp sequence", async ({
-                            page,
-                          }) => {
-                            const realm = process.env.QB_REALM!;
-                            const appId = process.env.QB_APP_ID!;
-                            const username = process.env.QB_USERNAME!;
-                            const password = process.env.QB_PASSWORD!;
-                            const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
-                            const appUrl = `https://${realm}.quickbase.com/db/${appId}`;
-
-                            await loginToQuickbase(page, quickbaseUrl, username, password, appUrl);
-
-                            const browserFetch = async (
-                              url: string,
-                              init: RequestInit
-                            ): Promise<Response> => {
-                              const response = await page.request.fetch(url, {
-                                method: init.method || "GET",
-                                headers: {
-                                  ...init.headers,
-                                  Referer: `https://${realm}.quickbase.com/db/${appId}`,
-                                  Origin: `https://${realm}.quickbase.com`,
-                                },
-                                data: init.body,
-                                credentials: "include",
-                              });
-                              const body = await response.text();
-                              console.log(
-                                "Response from:",
-                                url,
-                                "status:",
-                                response.status(),
-                                "body:",
-                                body
-                              );
-                              return new Response(body, {
-                                status: response.status(),
-                                statusText: response.statusText(),
-                                headers: response.headers(),
-                              });
-                            };
-
-                            const client = quickbase({
-                              realm,
-                              useTempTokens: true,
-                              debug: true,
-                              fetchApi: browserFetch,
-                            });
-
-                            console.log("Checking session state before getApp...");
-                            const cookies = await page.context().cookies();
-                            const sessionCookie = cookies.find(
-                              (c) => c.name === "TICKET" || c.name.startsWith("TICKET_")
-                            );
-                            console.log(
-                              "Session cookie present:",
-                              !!sessionCookie,
-                              "Cookies:",
-                              cookies
-                            );
-                            if (!sessionCookie) throw new Error("TICKET session cookie not found");
-
-                            await page.waitForTimeout(5000); // Debug delay
-                            console.log("Cookies after delay:", await page.context().cookies());
-
-                            const appResult1 = await client.getApp({ appId });
-                            console.log("First getApp response:", appResult1);
-                            expect(appResult1.id).toBe(appId);
-
-                            console.log("Waiting 5 minutes to test token expiration...");
-                            await new Promise((resolve) => setTimeout(resolve, 5 * 60 * 1000));
-
-                            await page.reload({ waitUntil: "load", timeout: 60000 });
-                            console.log("Refreshed page after 5 minutes, URL:", page.url());
-
-                            const appResult2 = await client.getApp({ appId });
-                            console.log("Second getApp response:", appResult2);
-                            expect(appResult2.id).toBe(appId);
-                          });
-                        });
         - name: setup.ts
           type: file
-          contents: |
-            // @tests/setup.ts
-            import { vi } from "vitest";
-            import { quickbase } from "../src/quickbaseClient.ts";
-            import type { QuickbaseConfig } from "../src/quickbaseClient.ts";
-
-            export const mockFetch = vi.fn();
-
-            export const createClient = (
-              fetchApi?: any,
-              config: Partial<QuickbaseConfig> = {}
-            ) => {
-              const client = quickbase({
-                realm: process.env.QB_REALM || "test-realm", // Match upsert.test.ts
-                userToken: process.env.QB_USER_TOKEN || "test-token", // Match upsert.test.ts
-                debug: true,
-                fetchApi,
-                ...config,
-              });
-              console.log("[createClient] Config:", config); // Debug config
-              console.log("[createClient] Returning:", client); // Debug client
-              return client;
-            };
-
-            // Mock env variables for consistency
-            vi.stubEnv("QB_REALM", "builderprogram-dbradford6815");
-            vi.stubEnv("QB_USER_TOKEN", "b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3");
-            vi.stubEnv("QB_APP_ID", "buwai2zpe");
         - name: vitest
           type: directory
           children:
@@ -1428,696 +762,37 @@ tree:
                   children:
                     - name: getApp.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - getApp > fetches real app data from QuickBase",
-                          { timeout: 10000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const getAppId = "buwai2zpe";
-
-                            console.log("Config used:", config);
-                            const result = await client.getApp({ appId: getAppId });
-                            console.log("Real API response:", result);
-
-                            expect(result).toEqual({
-                              id: getAppId,
-                              name: "qb-copy",
-                              created: expect.any(Date), // Matches Date object from client
-                              updated: expect.any(Date), // Matches Date object from client
-                              description: "",
-                              timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-                              dateFormat: "MM-DD-YYYY",
-                              hasEveryoneOnTheInternet: false,
-                              memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-                              securityProperties: {
-                                allowClone: false,
-                                allowExport: true,
-                                enableAppTokens: true,
-                                hideFromPublic: false,
-                                mustBeRealmApproved: false,
-                                useIPFilter: false,
-                              },
-                            });
-                          }
-                        );
                 - name: fields
                   type: directory
                   children:
                     - name: getFields.test.ts
                       type: file
-                      contents: |
-                        import { describe, it, expect } from "vitest";
-                        import { createClient } from "../../../setup.ts";
-
-                        describe("QuickbaseClient Integration - getFields", () => {
-                          const client = createClient();
-
-                          it(
-                            "fetches real field data from QuickBase",
-                            async () => {
-                              const tableId = "buwai2z3s";
-                              if (!tableId) throw new Error("Table ID is not defined");
-                              if (!process.env.QB_REALM)
-                                throw new Error("QB_REALM is not defined in .env");
-                              if (!process.env.QB_USER_TOKEN)
-                                throw new Error("QB_USER_TOKEN is not defined in .env");
-
-                              console.log("Config used:", {
-                                realm: process.env.QB_REALM,
-                                userToken: process.env.QB_USER_TOKEN,
-                                tableId,
-                              });
-                              const result = await client.getFields({
-                                tableId,
-                                includeFieldPerms: true,
-                              });
-                              console.log("Real API response:", result);
-                              expect(result).toEqual(
-                                expect.arrayContaining([
-                                  expect.objectContaining({
-                                    id: 1,
-                                    label: "Date Created",
-                                    fieldType: "timestamp",
-                                    noWrap: true,
-                                    bold: false,
-                                    required: false,
-                                    appearsByDefault: false,
-                                    findEnabled: false,
-                                    unique: false,
-                                    doesDataCopy: false,
-                                    fieldHelp: "",
-                                    audited: false,
-                                    properties: expect.objectContaining({
-                                      primaryKey: false,
-                                      foreignKey: false,
-                                      sortAsGiven: true,
-                                      carryChoices: true,
-                                      allowNewChoices: false,
-                                      formula: "",
-                                      defaultValue: "",
-                                    }),
-                                    permissions: expect.arrayContaining([
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Viewer",
-                                        roleId: 10,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Participant",
-                                        roleId: 11,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Administrator",
-                                        roleId: 12,
-                                      }),
-                                    ]),
-                                  }),
-                                  expect.objectContaining({
-                                    id: 2,
-                                    label: "Date Modified",
-                                    fieldType: "timestamp",
-                                    noWrap: true,
-                                    bold: false,
-                                    required: false,
-                                    appearsByDefault: false,
-                                    findEnabled: false,
-                                    unique: false,
-                                    doesDataCopy: false,
-                                    fieldHelp: "",
-                                    audited: false,
-                                    properties: expect.objectContaining({
-                                      primaryKey: false,
-                                      foreignKey: false,
-                                      sortAsGiven: true,
-                                      carryChoices: true,
-                                      allowNewChoices: false,
-                                      formula: "",
-                                      defaultValue: "",
-                                    }),
-                                    permissions: expect.arrayContaining([
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Viewer",
-                                        roleId: 10,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Participant",
-                                        roleId: 11,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Administrator",
-                                        roleId: 12,
-                                      }),
-                                    ]),
-                                  }),
-                                  expect.objectContaining({
-                                    id: 3,
-                                    label: "Record ID#",
-                                    fieldType: "recordid",
-                                    noWrap: true,
-                                    bold: false,
-                                    required: false,
-                                    appearsByDefault: false,
-                                    findEnabled: false,
-                                    unique: true,
-                                    doesDataCopy: false,
-                                    fieldHelp: "",
-                                    audited: false,
-                                    properties: expect.objectContaining({
-                                      primaryKey: true,
-                                      foreignKey: false,
-                                      sortAsGiven: true,
-                                      carryChoices: true,
-                                      allowNewChoices: false,
-                                      formula: "",
-                                      defaultValue: "",
-                                    }),
-                                    permissions: expect.arrayContaining([
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Viewer",
-                                        roleId: 10,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Participant",
-                                        roleId: 11,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Administrator",
-                                        roleId: 12,
-                                      }),
-                                    ]),
-                                  }),
-                                  expect.objectContaining({
-                                    id: 4,
-                                    label: "Record Owner",
-                                    fieldType: "user",
-                                    noWrap: true,
-                                    bold: false,
-                                    required: false,
-                                    appearsByDefault: false,
-                                    findEnabled: true,
-                                    unique: false,
-                                    doesDataCopy: false,
-                                    fieldHelp: "",
-                                    audited: false,
-                                    properties: expect.objectContaining({
-                                      primaryKey: false,
-                                      foreignKey: false,
-                                      sortAsGiven: true,
-                                      carryChoices: true,
-                                      allowNewChoices: true,
-                                      formula: "",
-                                      defaultValue: "",
-                                    }),
-                                    permissions: expect.arrayContaining([
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Viewer",
-                                        roleId: 10,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Participant",
-                                        roleId: 11,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Administrator",
-                                        roleId: 12,
-                                      }),
-                                    ]),
-                                  }),
-                                  expect.objectContaining({
-                                    id: 5,
-                                    label: "Last Modified By",
-                                    fieldType: "user",
-                                    noWrap: true,
-                                    bold: false,
-                                    required: false,
-                                    appearsByDefault: false,
-                                    findEnabled: true,
-                                    unique: false,
-                                    doesDataCopy: false,
-                                    fieldHelp: "",
-                                    audited: false,
-                                    properties: expect.objectContaining({
-                                      primaryKey: false,
-                                      foreignKey: false,
-                                      sortAsGiven: true,
-                                      carryChoices: true,
-                                      allowNewChoices: true,
-                                      formula: "",
-                                      defaultValue: "",
-                                    }),
-                                    permissions: expect.arrayContaining([
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Viewer",
-                                        roleId: 10,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Participant",
-                                        roleId: 11,
-                                      }),
-                                      expect.objectContaining({
-                                        permissionType: "Modify",
-                                        role: "Administrator",
-                                        roleId: 12,
-                                      }),
-                                    ]),
-                                  }),
-                                ])
-                              );
-                            },
-                            { timeout: 10000 }
-                          );
-                        });
                 - name: index.ts
                   type: file
-                  contents: |
-                    // Optional: Only add if you need to export tests
-                    export * from "./apps/getApp.test.ts";
-                    export * from "./fields/getFields.test.ts";
-                    export * from "./tables/getAppTables.test.ts";
                 - name: records
                   type: directory
                   children:
                     - name: deleteRecords.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/qb/records/deleteRecords.test.ts
-                        import { describe, test, expect, beforeEach, afterEach } from "vitest";
-                        import { quickbase } from "@/quickbaseClient.ts";
-
-                        const TABLE_ID = "buwai2zws";
-                        const UNIQUE_FIELD_ID = 3; // Record ID field
-                        const MARKER_FIELD_ID = 6; // Text field for marking test records
-
-                        describe("QuickbaseClient - DeleteRecords Integration", () => {
-                          const qb = quickbase({
-                            realm: "builderprogram-dbradford6815",
-                            userToken: process.env.QB_USER_TOKEN,
-                            debug: true,
-                          });
-
-                          beforeEach(async () => {
-                            try {
-                              await qb.deleteRecords({
-                                body: {
-                                  from: TABLE_ID,
-                                  where: `{${MARKER_FIELD_ID}.CT.'test-marker-delete'}`,
-                                },
-                              });
-                            } catch (e) {
-                              // Ignore if no records exist
-                            }
-                          });
-
-                          afterEach(async () => {
-                            try {
-                              await qb.deleteRecords({
-                                body: {
-                                  from: TABLE_ID,
-                                  where: `{${MARKER_FIELD_ID}.CT.'test-marker-delete'}`,
-                                },
-                              });
-                            } catch (e) {}
-                          });
-
-                          test(
-                            "deletes a newly upserted record",
-                            async () => {
-                              const upsertResponse = await qb.upsert({
-                                body: {
-                                  to: TABLE_ID,
-                                  data: [{ [MARKER_FIELD_ID]: { value: "test-marker-delete" } }],
-                                  fieldsToReturn: [UNIQUE_FIELD_ID], // Return record ID
-                                },
-                              });
-                              const recordId = upsertResponse.metadata.createdRecordIds[0];
-                              expect(recordId).toBeDefined();
-                              expect(upsertResponse.data[0][UNIQUE_FIELD_ID].value).toBe(recordId);
-
-                              const deleteResponse = await qb.deleteRecords({
-                                body: { from: TABLE_ID, where: `{${UNIQUE_FIELD_ID}.EX.${recordId}}` },
-                              });
-
-                              expect(deleteResponse).toEqual({ numberDeleted: 1 });
-
-                              const checkResponse = await qb.deleteRecords({
-                                body: { from: TABLE_ID, where: `{${UNIQUE_FIELD_ID}.EX.${recordId}}` },
-                              });
-                              expect(checkResponse.numberDeleted).toBe(0);
-                            },
-                            { timeout: 10000 }
-                          );
-
-                          test(
-                            "handles empty result when no records match",
-                            async () => {
-                              const response = await qb.deleteRecords({
-                                body: { from: TABLE_ID, where: "{3.EX.'999999'}" },
-                              });
-                              expect(response).toEqual({ numberDeleted: 0 });
-                            },
-                            { timeout: 10000 }
-                          );
-                        });
+                    - name: runQuery.test.ts
+                      type: file
                     - name: upsert.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/qb/records/upsert.test.ts
-                        import { describe, test, expect, beforeEach, afterEach } from "vitest";
-                        import { quickbase } from "@/quickbaseClient.ts";
-
-                        const TABLE_ID = "buwai2zws";
-                        const MARKER_FIELD_ID = 6; // Text field for marking test records
-
-                        describe("QuickbaseClient - Upsert Integration", () => {
-                          const qb = quickbase({
-                            realm: "builderprogram-dbradford6815",
-                            userToken: process.env.QB_USER_TOKEN,
-                            debug: true,
-                          });
-
-                          beforeEach(async () => {
-                            try {
-                              await qb.deleteRecords({
-                                body: {
-                                  from: TABLE_ID,
-                                  where: `{${MARKER_FIELD_ID}.CT.'test-marker-upsert'}`,
-                                },
-                              });
-                            } catch (e) {
-                              // Ignore if no records exist
-                            }
-                          });
-
-                          afterEach(async () => {
-                            try {
-                              await qb.deleteRecords({
-                                body: {
-                                  from: TABLE_ID,
-                                  where: `{${MARKER_FIELD_ID}.CT.'test-marker-upsert'}`,
-                                },
-                              });
-                            } catch (e) {}
-                          });
-
-                          test(
-                            "creates a new record successfully",
-                            async () => {
-                              const response = await qb.upsert({
-                                body: {
-                                  to: TABLE_ID,
-                                  data: [{ [MARKER_FIELD_ID]: { value: "test-marker-upsert" } }],
-                                  fieldsToReturn: [MARKER_FIELD_ID, 3], // Return marker and record ID
-                                },
-                              });
-
-                              expect(response.metadata.createdRecordIds.length).toBe(1);
-                              expect(response.data).toHaveLength(1);
-                              expect(response.data[0][MARKER_FIELD_ID].value).toBe(
-                                "test-marker-upsert"
-                              );
-                              expect(response.data[0][3].value).toBeDefined(); // Record ID assigned by QuickBase
-                              expect(response.metadata.totalNumberOfRecordsProcessed).toBe(1);
-                            },
-                            { timeout: 10000 }
-                          );
-
-                          test(
-                            "handles empty data gracefully",
-                            async () => {
-                              await expect(
-                                qb.upsert({
-                                  body: { to: TABLE_ID, data: [] },
-                                })
-                              ).rejects.toThrow("API Error: Bad Request (Status: 400)");
-                            },
-                            { timeout: 10000 }
-                          );
-                        });
                 - name: tables
                   type: directory
                   children:
                     - name: createTable.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - createTable > creates a new table in QuickBase",
-                          { timeout: 10000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const appId = "buwai2zpe";
-
-                            const tableName = `TestTable_${Date.now()}`;
-                            const createBody = {
-                              name: tableName,
-                              description: "Test table creation",
-                              singleRecordName: "TestRecord",
-                              pluralRecordName: "TestRecords",
-                            };
-
-                            console.log("Config used:", config);
-                            console.log("Creating table with:", createBody);
-                            const response = await client.createTable({ appId, body: createBody });
-
-                            expect(response).toBeDefined();
-                            expect(response.id).toBeDefined();
-                            expect(response.name).toBe(tableName);
-                            expect(response.description).toBe(createBody.description);
-                            expect(response.singleRecordName).toBe(createBody.singleRecordName);
-                            expect(response.pluralRecordName).toBe(createBody.pluralRecordName);
-                            expect(response.alias).toMatch(/^_DBID_/);
-                            expect(response.created).toBeInstanceOf(Date);
-                            expect(response.updated).toBeInstanceOf(Date);
-                            expect(response.nextRecordId).toBeGreaterThanOrEqual(1);
-                            expect(response.nextFieldId).toBeGreaterThanOrEqual(1);
-                            expect(response.defaultSortFieldId).toBeGreaterThanOrEqual(0);
-                            expect(response.keyFieldId).toBeGreaterThanOrEqual(1);
-                            expect(response.sizeLimit).toMatch(/^\d+\sMB$/); // e.g., "500 MB"
-                            expect(response.spaceUsed).toMatch(/^\d+\s(KB|MB)$/); // e.g., "0 KB"
-                            expect(response.spaceRemaining).toMatch(/^\d+\sMB$/); // e.g., "500 MB"
-
-                            console.log("Real API response:", response);
-
-                            // Cleanup: Delete the table to avoid clutter
-                            const deleteResponse = await client.deleteTable({
-                              tableId: response.id,
-                              appId,
-                            });
-                            expect(deleteResponse.deletedTableId).toBe(response.id);
-                            console.log("Cleanup - Deleted table:", deleteResponse);
-                          }
-                        );
                     - name: deleteTable.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - deleteTable > deletes a table in QuickBase",
-                          { timeout: 20000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const appId = "buwai2zpe";
-
-                            // Step 1: Create a temporary table to delete
-                            const tableName = `DeleteTest_${Date.now()}`;
-                            const createBody = {
-                              name: tableName,
-                              description: "Temporary table for delete test",
-                              singleRecordName: "DeleteTest",
-                              pluralRecordName: "DeleteTests",
-                            };
-                            console.log("Creating temporary table with:", createBody);
-                            const createResponse = await client.createTable({
-                              appId,
-                              body: createBody,
-                            });
-                            expect(createResponse.id).toBeDefined();
-                            expect(createResponse.name).toBe(tableName);
-                            console.log("Created table:", createResponse);
-                            const tableId = createResponse.id;
-
-                            // Step 2: Delete the table
-                            console.log("Deleting table:", { tableId, appId });
-                            const deleteResponse = await client.deleteTable({ tableId, appId });
-                            expect(deleteResponse).toBeDefined();
-                            expect(deleteResponse.deletedTableId).toBe(tableId);
-                            console.log("Delete API response:", deleteResponse);
-
-                            // Step 3: Verify the table is gone
-                            try {
-                              await client.getTable({ tableId, appId });
-                              throw new Error("Table should not exist after deletion");
-                            } catch (error) {
-                              expect(error.message).toMatch(/404|not found/i); // Expect a 404 error
-                              console.log("Verified table deletion:", error.message);
-                            }
-                          }
-                        );
                     - name: getAppTables.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - getAppTables > fetches real table data from QuickBase",
-                          { timeout: 10000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const tablesAppId = "buwai2zpe";
-
-                            console.log("Config used:", config);
-                            const result = await client.getAppTables({ appId: tablesAppId });
-                            console.log("Real API response:", result);
-
-                            expect(result).toBeDefined();
-                            expect(result).toBeInstanceOf(Array);
-                            expect(result.length).toBeGreaterThan(0);
-                            expect(result).toEqual(
-                              expect.arrayContaining([
-                                expect.objectContaining({
-                                  id: "buwai2zr4",
-                                  alias: "_DBID_ROOT",
-                                  name: expect.any(String), // Allow dynamic name due to updateTable
-                                  description: expect.any(String), // Allow dynamic description
-                                  created: expect.any(Date),
-                                  updated: expect.any(Date), // Allow varying timestamps
-                                  nextRecordId: expect.any(Number),
-                                  nextFieldId: expect.any(Number),
-                                  defaultSortFieldId: expect.any(Number),
-                                  defaultSortOrder: "DESC",
-                                  keyFieldId: expect.any(Number),
-                                  singleRecordName: "Root",
-                                  pluralRecordName: "Roots",
-                                  sizeLimit: "500 MB",
-                                  spaceUsed: expect.any(String),
-                                  spaceRemaining: "500 MB",
-                                }),
-                              ])
-                            );
-                          }
-                        );
+                    - name: getRelationships.test.ts
+                      type: file
                     - name: getTable.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - getTable > fetches real table data from QuickBase",
-                          { timeout: 10000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const tableId = "buwai2zr4";
-                            const appId = "buwai2zpe";
-
-                            console.log("Config used:", config);
-                            const response = await client.getTable({ tableId, appId });
-                            expect(response).toBeDefined();
-                            expect(response.id).toBe(tableId);
-                            expect(response.name).toBe("Root"); // Expect original name
-                            expect(response.alias).toBe("_DBID_ROOT");
-                            expect(response.created).toBeInstanceOf(Date);
-                            console.log("Real API response:", response);
-                          }
-                        );
                     - name: updateTable.test.ts
                       type: file
-                      contents: |
-                        import { test, expect } from "vitest";
-                        import { quickbase } from "../../../../src/quickbaseClient";
-
-                        test(
-                          "QuickbaseClient Integration - updateTable > updates real table data in QuickBase",
-                          { timeout: 10000 },
-                          async () => {
-                            const config = {
-                              realm: process.env.QB_REALM || "",
-                              userToken: process.env.QB_USER_TOKEN || "",
-                              debug: true,
-                            };
-                            const client = quickbase(config);
-                            const appId = "buwai2zpe";
-                            const tableId = "buwai2zr4";
-                            const updatedBody = {
-                              name: "Root Updated " + Date.now(),
-                              description: "Integration test update",
-                            };
-                            const originalBody = {
-                              name: "Root",
-                              description: "",
-                            };
-
-                            console.log("Config used:", config);
-                            // Update the table
-                            const response = await client.updateTable({
-                              tableId,
-                              appId,
-                              body: updatedBody,
-                            });
-                            expect(response).toBeDefined();
-                            expect(response.id).toBe(tableId);
-                            expect(response.name).toBe(updatedBody.name);
-                            expect(response.description).toBe(updatedBody.description);
-                            console.log("Real API response:", response);
-
-                            // Cleanup: Revert the table to original state
-                            const cleanupResponse = await client.updateTable({
-                              tableId,
-                              appId,
-                              body: originalBody,
-                            });
-                            expect(cleanupResponse.name).toBe(originalBody.name);
-                            expect(cleanupResponse.description).toBe(originalBody.description);
-                            console.log("Cleanup API response:", cleanupResponse);
-                          }
-                        );
             - name: unit
               type: directory
               children:
@@ -2127,14 +802,22 @@ tree:
                     - name: getApp.test.ts
                       type: file
                       contents: |
+                        // tests/vitest/unit/apps/getApp.test.ts
                         import { describe, it, expect, beforeEach } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - getApp (Unit)", () => {
-                          const client = createClient(mockFetch);
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - getApp", () => {
+                          let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
                             mockFetch.mockClear();
+                            client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
                           });
 
                           it("initializes without errors", () => {
@@ -2153,7 +836,7 @@ tree:
                                 status: 200,
                                 json: () =>
                                   Promise.resolve({
-                                    id: process.env.QB_APP_ID,
+                                    id: QB_APP_ID,
                                     name: "qb-copy",
                                     created: "2025-02-13T18:22:33Z",
                                     updated: "2025-03-04T04:25:51Z",
@@ -2174,12 +857,9 @@ tree:
                               } as Response);
                             });
 
-                            const getAppId = process.env.QB_APP_ID;
-                            if (!getAppId) throw new Error("QB_APP_ID is not defined in .env");
-                            console.log("Test appId:", getAppId);
-                            const result = await client.getApp({ appId: getAppId });
+                            const result = await client.getApp({ appId: QB_APP_ID });
                             expect(result).toEqual({
-                              id: getAppId,
+                              id: QB_APP_ID,
                               name: "qb-copy",
                               created: new Date("2025-02-13T18:22:33Z"),
                               updated: new Date("2025-03-04T04:25:51Z"),
@@ -2198,11 +878,11 @@ tree:
                               },
                             });
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/apps/${getAppId}`,
+                              `https://api.quickbase.com/v1/apps/${QB_APP_ID}`,
                               expect.objectContaining({
                                 headers: expect.objectContaining({
-                                  Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                 }),
                               })
                             );
@@ -2214,10 +894,16 @@ tree:
                     - name: fetchTempToken401.test.ts
                       type: file
                       contents: |
+                        // tests/vitest/unit/auth/fetchTempToken401.test.ts
                         import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - 401 with fetchTempToken 401", () => {
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -2226,7 +912,6 @@ tree:
                           });
 
                           it("fails without infinite loop when fetchTempToken returns 401 after initial 401", async () => {
-                            const mockDbid = "mockDbid123";
                             let callCount = 0;
 
                             mockFetch.mockImplementation((url) => {
@@ -2259,11 +944,31 @@ tree:
                             });
 
                             const consoleSpy = vi.spyOn(console, "log");
-                            await expect(client.getFields({ tableId: mockDbid })).rejects.toThrow(
+                            await expect(client.getFields({ tableId: QB_TABLE_ID_1 })).rejects.toThrow(
                               "API Error: Unauthorized in fetchTempToken (Status: 401)"
                             );
 
                             expect(mockFetch).toHaveBeenCalledTimes(3);
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              1,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+                              expect.any(Object)
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              2,
+                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                }),
+                              })
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              3,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+                              expect.any(Object)
+                            );
+
                             expect(consoleSpy).toHaveBeenCalledWith(
                               "Authorization error for getFields, refreshing token:",
                               expect.any(String)
@@ -2277,10 +982,16 @@ tree:
                     - name: getTempToken.test.ts
                       type: file
                       contents: |
+                        // tests/vitest/unit/auth/getTempTokenDBID.test.ts
                         import { describe, it, expect, beforeEach } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - getTempTokenDBID (Unit)", () => {
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - getTempTokenDBID", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -2297,7 +1008,6 @@ tree:
                           });
 
                           it("fetches and caches temp token on first call", async () => {
-                            const mockDbid = "mockDbid123";
                             const mockToken = "b123xyz_temp_token";
 
                             mockFetch.mockResolvedValueOnce({
@@ -2306,14 +1016,14 @@ tree:
                               json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
                             });
 
-                            const result = await client.getTempTokenDBID({ dbid: mockDbid });
+                            const result = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
                             expect(result).toEqual({ temporaryAuthorization: mockToken });
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${mockDbid}`,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
                               expect.objectContaining({
                                 method: "GET",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
                                   "Content-Type": "application/json",
                                 }),
                                 credentials: "include",
@@ -2322,7 +1032,6 @@ tree:
                           });
 
                           it("reuses cached temp token on second call", async () => {
-                            const mockDbid = "mockDbid123";
                             const mockToken = "b123xyz_temp_token";
 
                             mockFetch.mockResolvedValueOnce({
@@ -2331,41 +1040,56 @@ tree:
                               json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
                             });
 
-                            const firstResult = await client.getTempTokenDBID({ dbid: mockDbid });
+                            const firstResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
                             expect(firstResult).toEqual({ temporaryAuthorization: mockToken });
                             expect(mockFetch).toHaveBeenCalledTimes(1);
 
                             mockFetch.mockClear();
-                            const secondResult = await client.getTempTokenDBID({ dbid: mockDbid });
+                            const secondResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
                             expect(secondResult).toEqual({ temporaryAuthorization: mockToken });
                             expect(mockFetch).not.toHaveBeenCalled();
                           });
 
                           it("handles API error", async () => {
-                            const mockDbid = "mockDbid123";
-
                             mockFetch.mockResolvedValueOnce({
                               ok: false,
                               status: 401,
                               json: () => Promise.resolve({ message: "Unauthorized" }),
                             });
 
-                            await expect(client.getTempTokenDBID({ dbid: mockDbid })).rejects.toSatisfy(
-                              (error: Error) => {
-                                expect(error).toBeInstanceOf(Error);
-                                expect(error.message).toBe("API Error: Unauthorized (Status: 401)");
-                                return true;
-                              }
+                            await expect(
+                              client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 })
+                            ).rejects.toSatisfy((error: Error) => {
+                              expect(error).toBeInstanceOf(Error);
+                              expect(error.message).toBe("API Error: Unauthorized (Status: 401)");
+                              return true;
+                            });
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+                              expect.objectContaining({
+                                method: "GET",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  "Content-Type": "application/json",
+                                }),
+                                credentials: "include",
+                              })
                             );
                           });
                         });
                     - name: retryOn401.test.ts
                       type: file
                       contents: |
+                        // tests/vitest/unit/auth/retryOn401.test.ts
                         import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - 401 Retry Creates New Token", () => {
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - 401 Retry Creates New Token", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -2374,7 +1098,6 @@ tree:
                           });
 
                           it("creates a new token on 401 and retries successfully", async () => {
-                            const mockDbid = "mockDbid123";
                             const mockToken = "new_token_456";
                             const mockFields = [{ id: 1, label: "Field1" }];
                             let callCount = 0;
@@ -2415,16 +1138,45 @@ tree:
                             });
 
                             const consoleSpy = vi.spyOn(console, "log");
-                            const result = await client.getFields({ tableId: mockDbid });
+                            const result = await client.getFields({ tableId: QB_TABLE_ID_1 });
 
                             expect(result).toEqual(mockFields);
                             expect(mockFetch).toHaveBeenCalledTimes(4);
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              1,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+                              expect.any(Object)
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              2,
+                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                }),
+                              })
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              3,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+                              expect.any(Object)
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              4,
+                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                }),
+                              })
+                            );
+
                             expect(consoleSpy).toHaveBeenCalledWith(
                               "Authorization error for getFields, refreshing token:",
                               expect.any(String)
                             );
                             expect(consoleSpy).toHaveBeenCalledWith(
-                              "Fetched and cached new token for dbid: mockDbid123",
+                              `Fetched and cached new token for dbid: ${QB_TABLE_ID_1}`,
                               mockToken + "_retry",
                               expect.any(String)
                             );
@@ -2520,10 +1272,17 @@ tree:
                     - name: getFields.test.ts
                       type: file
                       contents: |
+                        // tests/vitest/unit/fields/getFields.test.ts
                         import { describe, it, expect } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - getFields (Unit)", () => {
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - getFields", () => {
                           it("calls getFields successfully", async () => {
                             mockFetch.mockImplementation((url: string, options: any) => {
                               console.log("Mock fetch for getFields:", url, options);
@@ -2569,9 +1328,9 @@ tree:
                               } as Response);
                             });
 
-                            const client = createClient(mockFetch);
+                            const client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
                             const result = await client.getFields({
-                              tableId: "dummyTableId",
+                              tableId: QB_TABLE_ID_1,
                               includeFieldPerms: true,
                             });
                             console.log("getFields response:", result);
@@ -2625,11 +1384,11 @@ tree:
                               ])
                             );
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/fields?tableId=dummyTableId&includeFieldPerms=true`,
+                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}&includeFieldPerms=true`,
                               expect.objectContaining({
                                 headers: expect.objectContaining({
-                                  Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                 }),
                               })
                             );
@@ -2649,20 +1408,24 @@ tree:
                       type: file
                       contents: |
                         // tests/vitest/unit/records/deleteRecords.test.ts
-                        import { describe, expect, test, beforeEach } from "vitest"; // Added 'describe'
-                        import { createClient, mockFetch } from "@tests/setup.ts";
+                        import { describe, expect, test, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - deleteRecords", () => {
+                          let qb: ReturnType<typeof createClient>;
 
-                        describe("QuickbaseClient - deleteRecords (Unit)", () => {
                           beforeEach(() => {
-                            mockFetch.mockClear(); // Clear mock state between tests
+                            mockFetch.mockClear();
+                            qb = createClient(mockFetch, { debug: true }); // Use debug: true for consistency with other tests
                           });
 
-                          test("deleteRecords - sends correct DELETE request and handles success", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                            });
-
+                          test("sends correct DELETE request and handles success", async () => {
                             mockFetch.mockResolvedValueOnce({
                               ok: true,
                               status: 200,
@@ -2671,7 +1434,7 @@ tree:
 
                             const result = await qb.deleteRecords({
                               body: {
-                                from: "test-table-id",
+                                from: QB_TABLE_ID_1,
                                 where: "{3.EX.'5'}", // Simulate deleting Record ID 5
                               },
                             });
@@ -2681,22 +1444,17 @@ tree:
                               expect.objectContaining({
                                 method: "DELETE",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
-                                body: JSON.stringify({ from: "test-table-id", where: "{3.EX.'5'}" }),
+                                body: JSON.stringify({ from: QB_TABLE_ID_1, where: "{3.EX.'5'}" }),
                               })
                             );
                             expect(result).toEqual({ numberDeleted: 1 });
                           });
 
-                          test("deleteRecords - handles no records deleted", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                            });
-
+                          test("handles no records deleted", async () => {
                             mockFetch.mockResolvedValueOnce({
                               ok: true,
                               status: 200,
@@ -2705,7 +1463,7 @@ tree:
 
                             const result = await qb.deleteRecords({
                               body: {
-                                from: "test-table-id",
+                                from: QB_TABLE_ID_1,
                                 where: "{3.EX.'999999'}", // Non-existent Record ID
                               },
                             });
@@ -2715,12 +1473,12 @@ tree:
                               expect.objectContaining({
                                 method: "DELETE",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
                                 body: JSON.stringify({
-                                  from: "test-table-id",
+                                  from: QB_TABLE_ID_1,
                                   where: "{3.EX.'999999'}",
                                 }),
                               })
@@ -2728,12 +1486,7 @@ tree:
                             expect(result).toEqual({ numberDeleted: 0 });
                           });
 
-                          test("deleteRecords - throws error on API failure", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                            });
-
+                          test("throws error on API failure", async () => {
                             mockFetch.mockResolvedValueOnce({
                               ok: false,
                               status: 400,
@@ -2743,25 +1496,130 @@ tree:
                             await expect(() =>
                               qb.deleteRecords({
                                 body: {
-                                  from: "test-table-id",
+                                  from: QB_TABLE_ID_1,
                                   where: "{3.EX.'invalid'}",
                                 },
                               })
                             ).rejects.toThrow("API Error: Invalid query (Status: 400)");
 
                             expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
+                              "https://api.quickbase.com/v1/records",
+                              expect.objectContaining({
+                                method: "DELETE",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
+                                }),
+                                body: JSON.stringify({
+                                  from: QB_TABLE_ID_1,
+                                  where: "{3.EX.'invalid'}",
+                                }),
+                              })
+                            );
+                          });
+                        });
+                    - name: runQuery.test.ts
+                      type: file
+                      contents: |
+                        // tests/vitest/unit/records/runQuery.test.ts
+                        import { describe, test, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+                        import { RunQueryRequest, RunQueryResponse } from "@/generated";
+
+                        describe("QuickbaseClient Unit - runQuery", () => {
+                          let client: ReturnType<typeof createClient>;
+
+                          beforeEach(() => {
+                            mockFetch.mockClear();
+                            client = createClient(mockFetch, { debug: true });
+                          });
+
+                          test("sends correct POST request and handles successful query response", async () => {
+                            const queryRequest: RunQueryRequest = {
+                              from: QB_TABLE_ID_1,
+                              select: [3, 6, 7],
+                              where: "{6.EX.'Task 1'}",
+                              sortBy: [{ fieldId: 6, order: "ASC" }],
+                              groupBy: [{ fieldId: 7, grouping: "equal-values" }],
+                              options: { skip: 0, top: 100, compareWithAppLocalTime: false },
+                            };
+
+                            const mockResponse: RunQueryResponse = {
+                              data: [
+                                { "3": { value: 1 }, "6": { value: "Task 1" }, "7": { value: "High" } },
+                              ],
+                              fields: [
+                                { id: 3, label: "Record ID#", type: "recordid" },
+                                { id: 6, label: "Task Name", type: "text" },
+                                { id: 7, label: "Priority", type: "text" },
+                              ],
+                              metadata: {
+                                numFields: 3,
+                                numRecords: 1,
+                                skip: 0,
+                                top: 100,
+                                totalRecords: 1,
+                              },
+                            };
+
+                            mockFetch.mockResolvedValueOnce({
+                              ok: true,
+                              status: 200,
+                              json: () => Promise.resolve(mockResponse),
+                            });
+
+                            const result = await client.runQuery({ body: queryRequest });
+
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              "https://api.quickbase.com/v1/records/query",
+                              expect.objectContaining({
+                                method: "POST",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
+                                }),
+                                body: JSON.stringify(queryRequest),
+                              })
+                            );
+
+                            expect(result).toEqual(mockResponse);
+                          });
+
+                          test("handles API error with invalid query", async () => {
+                            const invalidQueryRequest = {
+                              from: QB_TABLE_ID_1,
+                              select: [3],
+                              where: "{999.EX.'Invalid'}", // Invalid field ID
+                            };
+
+                            mockFetch.mockResolvedValueOnce({
+                              ok: false,
+                              status: 400,
+                              json: () => Promise.resolve({ message: "Invalid query" }),
+                            });
+
+                            await expect(
+                              client.runQuery({ body: invalidQueryRequest })
+                            ).rejects.toThrow("API Error: Invalid query (Status: 400)");
+
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              "https://api.quickbase.com/v1/records/query",
                               expect.objectContaining({
-                                method: "DELETE",
+                                method: "POST",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
-                                body: JSON.stringify({
-                                  from: "test-table-id",
-                                  where: "{3.EX.'invalid'}",
-                                }),
+                                body: JSON.stringify(invalidQueryRequest),
                               })
                             );
                           });
@@ -2771,22 +1629,24 @@ tree:
                       contents: |
                         // tests/vitest/unit/records/upsert.test.ts
                         import { describe, expect, test, beforeEach } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
                         import { vi } from "vitest";
 
                         // Note: Type augmentation moved to src/types.d.ts
-                        describe("QuickbaseClient - upsert (Unit)", () => {
+                        describe("QuickbaseClient Unit - upsert", () => {
                           beforeEach(() => {
                             vi.resetModules(); // Reset module cache
                             mockFetch.mockClear();
                           });
 
                           test("sends correct POST request and handles successful upsert", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                              debug: true,
-                            });
+                            const qb = createClient(mockFetch, { debug: true });
 
                             mockFetch.mockResolvedValueOnce({
                               ok: true,
@@ -2804,10 +1664,10 @@ tree:
                             });
 
                             console.log("[Test] Calling qb.upsert with:", {
-                              body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
                             });
                             const result = await qb.upsert({
-                              body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
                             });
 
                             console.log("[Test] mockFetch calls:", mockFetch.mock.calls);
@@ -2816,12 +1676,12 @@ tree:
                               expect.objectContaining({
                                 method: "POST",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
                                 body: JSON.stringify({
-                                  to: "test-table-id",
+                                  to: QB_TABLE_ID_1,
                                   data: [{ "6": { value: "value1" } }],
                                 }),
                               })
@@ -2839,11 +1699,7 @@ tree:
                           });
 
                           test("handles API error with invalid data", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                              debug: true,
-                            });
+                            const qb = createClient(mockFetch, { debug: true });
 
                             mockFetch.mockResolvedValueOnce({
                               ok: false,
@@ -2853,7 +1709,7 @@ tree:
 
                             await expect(
                               qb.upsert({
-                                body: { to: "test-table-id", data: [{ "999": { value: "invalid" } }] },
+                                body: { to: QB_TABLE_ID_1, data: [{ "999": { value: "invalid" } }] },
                               })
                             ).rejects.toThrow("API Error: Invalid data format (Status: 400)");
 
@@ -2862,12 +1718,12 @@ tree:
                               expect.objectContaining({
                                 method: "POST",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
                                 body: JSON.stringify({
-                                  to: "test-table-id",
+                                  to: QB_TABLE_ID_1,
                                   data: [{ "999": { value: "invalid" } }],
                                 }),
                               })
@@ -2875,11 +1731,7 @@ tree:
                           });
 
                           test("handles upsert with temp token", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              useTempTokens: true,
-                              debug: true,
-                            });
+                            const qb = createClient(mockFetch, { useTempTokens: true, debug: true });
 
                             mockFetch
                               .mockResolvedValueOnce({
@@ -2903,18 +1755,18 @@ tree:
                               });
 
                             const result = await qb.upsert({
-                              body: { to: "test-table-id", data: [{ "7": { value: "value2" } }] },
-                              dbid: "test-dbid",
+                              body: { to: QB_TABLE_ID_1, data: [{ "7": { value: "value2" } }] },
+                              dbid: QB_TABLE_ID_1, // Use QB_TABLE_ID_1 as dbid for temp token
                             } as any); // Temporary type assertion until types.d.ts is applied
 
                             expect(mockFetch).toHaveBeenCalledTimes(2);
                             expect(mockFetch).toHaveBeenNthCalledWith(
                               1,
-                              "https://api.quickbase.com/v1/auth/temporary/test-dbid",
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
                               expect.objectContaining({
                                 method: "GET",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
                                   "Content-Type": "application/json",
                                 }),
                                 credentials: "include",
@@ -2926,12 +1778,12 @@ tree:
                               expect.objectContaining({
                                 method: "POST",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
                                   Authorization: "QB-TEMP-TOKEN temp-token",
                                   "Content-Type": "application/json",
                                 }),
                                 body: JSON.stringify({
-                                  to: "test-table-id",
+                                  to: QB_TABLE_ID_1,
                                   data: [{ "7": { value: "value2" } }],
                                 }),
                               })
@@ -2949,11 +1801,7 @@ tree:
                           });
 
                           test("sends correct POST request with data fields", async () => {
-                            const qb = createClient(mockFetch, {
-                              realm: "test-realm",
-                              userToken: "test-token",
-                              debug: true,
-                            });
+                            const qb = createClient(mockFetch, { debug: true });
 
                             mockFetch.mockResolvedValueOnce({
                               ok: true,
@@ -2971,7 +1819,7 @@ tree:
                             });
 
                             const result = await qb.upsert({
-                              body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
                             });
 
                             expect(mockFetch).toHaveBeenCalledWith(
@@ -2979,12 +1827,12 @@ tree:
                               expect.objectContaining({
                                 method: "POST",
                                 headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": "test-realm.quickbase.com",
-                                  Authorization: "QB-USER-TOKEN test-token",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                   "Content-Type": "application/json",
                                 }),
                                 body: JSON.stringify({
-                                  to: "test-table-id",
+                                  to: QB_TABLE_ID_1,
                                   data: [{ "6": { value: "value1" } }],
                                 }),
                               })
@@ -3003,10 +1851,17 @@ tree:
                     - name: createTable.test.ts
                       type: file
                       contents: |
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - createTable (Unit)", () => {
+                        // tests/vitest/unit/records/createTable.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - createTable", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -3015,7 +1870,6 @@ tree:
                           });
 
                           it("calls createTable successfully with user token", async () => {
-                            const appId = "buwai2zpe";
                             const mockBody = {
                               name: "TestTable",
                               description: "Unit test table",
@@ -3023,7 +1877,7 @@ tree:
                               pluralRecordName: "Tests",
                             };
                             const mockResponse = {
-                              id: "buya8h9iz",
+                              id: "newly-created-table-id-1234567890", // Changed from "buya8h9iz"
                               name: "TestTable",
                               alias: "_DBID_TESTTABLE",
                               description: "Unit test table",
@@ -3047,18 +1901,20 @@ tree:
                               json: () => Promise.resolve(mockResponse),
                             });
 
-                            const response = await client.createTable({ appId, body: mockBody });
+                            const response = await client.createTable({
+                              appId: QB_APP_ID,
+                              body: mockBody,
+                            });
                             expect(response).toEqual(mockResponse);
                             expect(mockFetch).toHaveBeenCalledTimes(1);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables?appId=${appId}`,
+                              `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
                               expect.objectContaining({
                                 method: "POST",
                                 headers: expect.objectContaining({
                                   "Content-Type": "application/json",
-                                  "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
-                                  Authorization:
-                                    "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                 }),
                                 body: JSON.stringify(mockBody),
                               })
@@ -3068,10 +1924,18 @@ tree:
                     - name: deleteTable.test.ts
                       type: file
                       contents: |
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - deleteTable (Unit)", () => {
+                        // tests/vitest/unit/records/deleteTable.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_TABLE_ID_1,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - deleteTable", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -3080,10 +1944,8 @@ tree:
                           });
 
                           it("calls deleteTable successfully with user token", async () => {
-                            const appId = "buwai2zpe";
-                            const tableId = "buya8h9iz";
                             const mockResponse = {
-                              deletedTableId: tableId,
+                              deletedTableId: QB_TABLE_ID_1,
                             };
 
                             mockFetch.mockResolvedValueOnce({
@@ -3092,27 +1954,26 @@ tree:
                               json: () => Promise.resolve(mockResponse),
                             });
 
-                            const response = await client.deleteTable({ tableId, appId });
+                            const response = await client.deleteTable({
+                              tableId: QB_TABLE_ID_1,
+                              appId: QB_APP_ID,
+                            });
                             expect(response).toEqual(mockResponse);
                             expect(mockFetch).toHaveBeenCalledTimes(1);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
                               expect.objectContaining({
                                 method: "DELETE",
                                 headers: expect.objectContaining({
                                   "Content-Type": "application/json",
-                                  "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
-                                  Authorization:
-                                    "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                 }),
                               })
                             );
                           });
 
                           it("handles 404 error for non-existent table", async () => {
-                            const appId = "buwai2zpe";
-                            const tableId = "nonexistent";
-
                             mockFetch.mockResolvedValueOnce({
                               ok: false,
                               status: 404,
@@ -3123,15 +1984,19 @@ tree:
                                 }),
                             });
 
-                            await expect(client.deleteTable({ tableId, appId })).rejects.toThrow(
-                              "API Error: Invalid DBID (Status: 404)"
-                            );
+                            await expect(
+                              client.deleteTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
+                            ).rejects.toThrow("API Error: Invalid DBID (Status: 404)");
                             expect(mockFetch).toHaveBeenCalledTimes(1);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
                               expect.objectContaining({
                                 method: "DELETE",
-                                headers: expect.any(Object),
+                                headers: expect.objectContaining({
+                                  "Content-Type": "application/json",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                }),
                               })
                             );
                           });
@@ -3139,10 +2004,24 @@ tree:
                     - name: getAppTables.test.ts
                       type: file
                       contents: |
-                        import { describe, it, expect } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
+                        // tests/vitest/unit/tables/getAppTables.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - getAppTables", () => {
+                          let client: ReturnType<typeof createClient>;
+
+                          beforeEach(() => {
+                            mockFetch.mockClear();
+                            client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
+                          });
 
-                        describe("QuickbaseClient - getAppTables (Unit)", () => {
                           it("calls getAppTables successfully", async () => {
                             mockFetch.mockImplementation((url: string, options: any) => {
                               console.log("Mock fetch for getAppTables:", url, options);
@@ -3152,84 +2031,352 @@ tree:
                                 json: () =>
                                   Promise.resolve([
                                     {
+                                      id: "buwai2zr4",
+                                      name: "Root",
                                       alias: "_DBID_ROOT",
-                                      created: "2025-02-13T18:22:33Z",
+                                      description: "",
+                                      created: new Date("2025-02-13T18:22:33.000Z"),
+                                      updated: new Date("2025-02-13T18:22:34.000Z"),
+                                      nextRecordId: 1,
+                                      nextFieldId: 6,
                                       defaultSortFieldId: 2,
                                       defaultSortOrder: "DESC",
-                                      description: "",
-                                      id: "buwai2zr4",
                                       keyFieldId: 3,
-                                      name: "Root",
-                                      nextFieldId: 6,
-                                      nextRecordId: 1,
-                                      pluralRecordName: "Roots",
                                       singleRecordName: "Root",
+                                      pluralRecordName: "Roots",
                                       sizeLimit: "500 MB",
-                                      spaceRemaining: "500 MB",
                                       spaceUsed: "0 KB",
-                                      updated: "2025-02-13T18:22:34Z",
+                                      spaceRemaining: "500 MB",
                                     },
                                   ]),
                               } as Response);
                             });
 
-                            const client = createClient(mockFetch);
-                            const tablesAppId = process.env.QB_APP_ID;
-                            if (!tablesAppId) throw new Error("QB_APP_ID is not defined in .env");
-                            const result = await client.getAppTables({ appId: tablesAppId });
+                            const result = await client.getAppTables({ appId: QB_APP_ID });
                             console.log("getAppTables response:", result);
                             expect(result).toEqual(
                               expect.arrayContaining([
                                 expect.objectContaining({
+                                  id: "buwai2zr4",
+                                  name: "Root",
                                   alias: "_DBID_ROOT",
-                                  created: new Date("2025-02-13T18:22:33Z"),
+                                  description: "",
+                                  created: new Date("2025-02-13T18:22:33.000Z"),
+                                  updated: new Date("2025-02-13T18:22:34.000Z"),
+                                  nextRecordId: 1,
+                                  nextFieldId: 6,
                                   defaultSortFieldId: 2,
                                   defaultSortOrder: "DESC",
-                                  description: "",
-                                  id: "buwai2zr4",
                                   keyFieldId: 3,
-                                  name: "Root",
-                                  nextFieldId: 6,
-                                  nextRecordId: 1,
-                                  pluralRecordName: "Roots",
                                   singleRecordName: "Root",
+                                  pluralRecordName: "Roots",
                                   sizeLimit: "500 MB",
-                                  spaceRemaining: "500 MB",
                                   spaceUsed: "0 KB",
-                                  updated: new Date("2025-02-13T18:22:34Z"),
+                                  spaceRemaining: "500 MB",
                                 }),
                               ])
                             );
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables?appId=${tablesAppId}`,
+                              `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
                               expect.objectContaining({
+                                method: "GET",
                                 headers: expect.objectContaining({
-                                  Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
                                 }),
                               })
                             );
                           });
                         });
-                    - name: getTable.test.ts
+                    - name: getRelationships.test.ts
                       type: file
                       contents: |
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
+                        // tests/vitest/unit/relationships/getRelationships.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                          QB_TABLE_ID_2,
+                        } from "@tests/setup.ts";
+                        import { GetRelationships200Response } from "/home/drew/Projects/quickbase-js/src/generated/models";
+
+                        describe("QuickbaseClient Unit - getRelationships", () => {
+                          let client: ReturnType<typeof createClient>;
+
+                          beforeEach(() => {
+                            mockFetch.mockClear();
+                            client = createClient(mockFetch, { debug: true }); // Consistent with output
+                          });
+
+                          it("initializes without errors", () => {
+                            expect(client).toBeDefined();
+                          });
+
+                          it("has getRelationships method", () => {
+                            expect(typeof client.getRelationships).toBe("function");
+                          });
+
+                          it("sends correct GET request and handles successful response", async () => {
+                            const mockResponse: GetRelationships200Response = {
+                              metadata: {
+                                numRelationships: 1,
+                                skip: 0,
+                                totalRelationships: 1,
+                              },
+                              relationships: [
+                                {
+                                  id: 6,
+                                  parentTableId: QB_TABLE_ID_1, // Parent table
+                                  childTableId: QB_TABLE_ID_2, // Child table
+                                  foreignKeyField: {
+                                    id: 6,
+                                    label: "Related record",
+                                    type: "numeric",
+                                  },
+                                  isCrossApp: false,
+                                  lookupFields: [
+                                    {
+                                      id: 3,
+                                      label: "Name",
+                                      type: "text",
+                                    },
+                                  ],
+                                  summaryFields: [
+                                    {
+                                      id: 8,
+                                      label: "my summary field",
+                                      type: "numeric",
+                                    },
+                                  ],
+                                },
+                              ],
+                            };
+
+                            mockFetch.mockResolvedValueOnce({
+                              ok: true,
+                              status: 200,
+                              json: () => Promise.resolve(mockResponse),
+                            });
+
+                            const result = await client.getRelationships({
+                              tableId: QB_TABLE_ID_2,
+                              skip: 0,
+                            });
+
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
+                              expect.objectContaining({
+                                method: "GET",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
+                                }),
+                              })
+                            );
+
+                            expect(result).toEqual(mockResponse);
+                            expect(result.metadata.numRelationships).toBe(1);
+                            expect(result.relationships).toHaveLength(1);
+                            expect(result.relationships[0].id).toBe(6);
+                            expect(result.relationships[0].foreignKeyField.label).toBe(
+                              "Related record"
+                            );
+                          });
+
+                          it("handles request without skip parameter", async () => {
+                            const mockResponse: GetRelationships200Response = {
+                              metadata: {
+                                numRelationships: 1,
+                                skip: 0,
+                                totalRelationships: 1,
+                              },
+                              relationships: [
+                                {
+                                  id: 6,
+                                  parentTableId: QB_TABLE_ID_1,
+                                  childTableId: QB_TABLE_ID_2,
+                                  foreignKeyField: {
+                                    id: 6,
+                                    label: "Related record",
+                                    type: "numeric",
+                                  },
+                                  isCrossApp: false,
+                                  lookupFields: [],
+                                  summaryFields: [],
+                                },
+                              ],
+                            };
 
-                        describe("QuickbaseClient - getTable (Unit)", () => {
+                            mockFetch.mockResolvedValueOnce({
+                              ok: true,
+                              status: 200,
+                              json: () => Promise.resolve(mockResponse),
+                            });
+
+                            const result = await client.getRelationships({
+                              tableId: QB_TABLE_ID_2, // Corrected from QB_TABLE_ID_1
+                            });
+
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships`,
+                              expect.objectContaining({
+                                method: "GET",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
+                                }),
+                              })
+                            );
+
+                            expect(result).toEqual(mockResponse);
+                          });
+
+                          it("handles API error response", async () => {
+                            mockFetch.mockResolvedValueOnce({
+                              ok: false,
+                              status: 404,
+                              json: () => Promise.resolve({ message: "Table not found" }),
+                            });
+
+                            await expect(
+                              client.getRelationships({
+                                tableId: QB_TABLE_ID_2, // Corrected from QB_TABLE_ID_1
+                                skip: 0,
+                              })
+                            ).rejects.toThrow("API Error: Table not found (Status: 404)");
+
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
+                              expect.objectContaining({
+                                method: "GET",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                  "Content-Type": "application/json",
+                                }),
+                              })
+                            );
+                          });
+
+                          it("retries with temp token after 401", async () => {
+                            const mockResponse: GetRelationships200Response = {
+                              metadata: {
+                                numRelationships: 1,
+                                skip: 0,
+                                totalRelationships: 1,
+                              },
+                              relationships: [
+                                {
+                                  id: 6,
+                                  parentTableId: QB_TABLE_ID_1,
+                                  childTableId: QB_TABLE_ID_2,
+                                  foreignKeyField: {
+                                    id: 6,
+                                    label: "Related record",
+                                    type: "numeric",
+                                  },
+                                  isCrossApp: false,
+                                },
+                              ],
+                            };
+
+                            mockFetch
+                              .mockResolvedValueOnce({
+                                ok: true,
+                                status: 200,
+                                json: () =>
+                                  Promise.resolve({ temporaryAuthorization: "initial_token" }),
+                              })
+                              .mockResolvedValueOnce({
+                                ok: false,
+                                status: 401,
+                                json: () => Promise.resolve({ message: "Unauthorized" }),
+                              })
+                              .mockResolvedValueOnce({
+                                ok: true,
+                                status: 200,
+                                json: () => Promise.resolve({ temporaryAuthorization: "new_token" }),
+                              })
+                              .mockResolvedValueOnce({
+                                ok: true,
+                                status: 200,
+                                json: () => Promise.resolve(mockResponse),
+                              });
+
+                            const tempClient = createClient(mockFetch, {
+                              useTempTokens: true,
+                              debug: true,
+                            });
+                            const result = await tempClient.getRelationships({
+                              tableId: QB_TABLE_ID_2,
+                              skip: 0,
+                            });
+
+                            expect(mockFetch).toHaveBeenCalledTimes(4);
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              1,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_2}`,
+                              expect.any(Object)
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              2,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  Authorization: "QB-TEMP-TOKEN initial_token",
+                                }),
+                              })
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              3,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_2}`,
+                              expect.any(Object)
+                            );
+                            expect(mockFetch).toHaveBeenNthCalledWith(
+                              4,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  Authorization: "QB-TEMP-TOKEN new_token",
+                                }),
+                              })
+                            );
+
+                            expect(result).toEqual(mockResponse);
+                          });
+                        });
+                    - name: getTable.test.ts
+                      type: file
+                      contents: |
+                        // tests/vitest/unit/tables/getTable.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_TABLE_ID_1,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - getTable", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
                             mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true });
                           });
 
                           it("calls getTable successfully with user token", async () => {
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "buwai2zr4";
+                            client = createClient(mockFetch, { debug: true });
+
                             const mockResponse = {
-                              id: mockTableId,
+                              id: QB_TABLE_ID_1,
                               name: "Root",
                               alias: "_DBID_ROOT",
                               description: "",
@@ -3254,17 +2401,17 @@ tree:
                             });
 
                             const response = await client.getTable({
-                              tableId: mockTableId,
-                              appId: mockAppId,
+                              tableId: QB_TABLE_ID_1,
+                              appId: QB_APP_ID,
                             });
                             expect(response).toEqual(mockResponse);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${mockTableId}?appId=${mockAppId}`,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
                               expect.objectContaining({
                                 method: "GET",
                                 headers: expect.objectContaining({
-                                  Authorization:
-                                    "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
                                 }),
                               })
                             );
@@ -3272,10 +2419,9 @@ tree:
 
                           it("calls getTable successfully with temp token", async () => {
                             client = createClient(mockFetch, { debug: true, useTempTokens: true });
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "buwai2zr4";
+
                             const mockResponse = {
-                              id: mockTableId,
+                              id: QB_TABLE_ID_1,
                               name: "Root",
                               alias: "_DBID_ROOT",
                               description: "",
@@ -3306,19 +2452,20 @@ tree:
                               });
 
                             const response = await client.getTable({
-                              tableId: mockTableId,
-                              appId: mockAppId,
+                              tableId: QB_TABLE_ID_1,
+                              appId: QB_APP_ID,
                             });
                             expect(response).toEqual(mockResponse);
                             expect(mockFetch).toHaveBeenCalledTimes(2);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${mockTableId}`,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
                               expect.any(Object)
                             );
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${mockTableId}?appId=${mockAppId}`,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
                               expect.objectContaining({
                                 headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
                                   Authorization: "QB-TEMP-TOKEN temp_token",
                                 }),
                               })
@@ -3327,10 +2474,9 @@ tree:
 
                           it("retries successfully after 401 with temp token", async () => {
                             client = createClient(mockFetch, { debug: true, useTempTokens: true });
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "buwai2zr4";
+
                             const mockResponse = {
-                              id: mockTableId,
+                              id: QB_TABLE_ID_1,
                               name: "Root",
                               alias: "_DBID_ROOT",
                               description: "",
@@ -3372,17 +2518,23 @@ tree:
                               });
 
                             const response = await client.getTable({
-                              tableId: mockTableId,
-                              appId: mockAppId,
+                              tableId: QB_TABLE_ID_1,
+                              appId: QB_APP_ID,
                             });
                             expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(4); // Initial token, 401, retry token, success
+                            expect(mockFetch).toHaveBeenCalledTimes(4);
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+                              expect.objectContaining({
+                                headers: expect.objectContaining({
+                                  Authorization: "QB-TEMP-TOKEN new_token",
+                                }),
+                              })
+                            );
                           });
 
                           it("handles 401 with failed temp token retry", async () => {
                             client = createClient(mockFetch, { debug: true, useTempTokens: true });
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "buwai2zr4";
 
                             mockFetch
                               .mockResolvedValueOnce({
@@ -3404,7 +2556,7 @@ tree:
                               });
 
                             await expect(
-                              client.getTable({ tableId: mockTableId, appId: mockAppId })
+                              client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
                             ).rejects.toThrow(
                               "API Error: Unauthorized in fetchTempToken (Status: 401)"
                             );
@@ -3412,8 +2564,7 @@ tree:
                           });
 
                           it("handles 404 Not Found", async () => {
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "invalidTableId";
+                            client = createClient(mockFetch, { debug: true });
 
                             mockFetch.mockResolvedValueOnce({
                               ok: false,
@@ -3422,17 +2573,33 @@ tree:
                             });
 
                             await expect(
-                              client.getTable({ tableId: mockTableId, appId: mockAppId })
+                              client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
                             ).rejects.toThrow("API Error: Table not found (Status: 404)");
+                            expect(mockFetch).toHaveBeenCalledWith(
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+                              expect.objectContaining({
+                                method: "GET",
+                                headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+                                }),
+                              })
+                            );
                           });
                         });
                     - name: updateTable.test.ts
                       type: file
                       contents: |
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - updateTable (Unit)", () => {
+                        // tests/vitest/unit/records/updateTable.test.ts
+                        import { describe, it, expect, beforeEach } from "vitest";
+                        import {
+                          createClient,
+                          mockFetch,
+                          QB_APP_ID,
+                          QB_TABLE_ID_1,
+                        } from "@tests/setup.ts";
+
+                        describe("QuickbaseClient Unit - updateTable", () => {
                           let client: ReturnType<typeof createClient>;
 
                           beforeEach(() => {
@@ -3442,14 +2609,13 @@ tree:
 
                           it("calls updateTable successfully with temp token", async () => {
                             client = createClient(mockFetch, { debug: true, useTempTokens: true });
-                            const mockAppId = "buwai2zpe";
-                            const mockTableId = "buwai2zr4";
+
                             const mockBody = {
                               name: "Updated Root",
                               description: "Updated description",
                             };
                             const mockResponse = {
-                              id: mockTableId,
+                              id: QB_TABLE_ID_1,
                               name: "Updated Root",
                               alias: "_DBID_ROOT",
                               description: "Updated description",
@@ -3480,21 +2646,22 @@ tree:
                               });
 
                             const response = await client.updateTable({
-                              tableId: mockTableId,
-                              appId: mockAppId,
+                              tableId: QB_TABLE_ID_1,
+                              appId: QB_APP_ID,
                               body: mockBody,
                             });
                             expect(response).toEqual(mockResponse);
                             expect(mockFetch).toHaveBeenCalledTimes(2);
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${mockTableId}`,
+                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
                               expect.any(Object)
                             );
                             expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${mockTableId}?appId=${mockAppId}`,
+                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
                               expect.objectContaining({
-                                method: "POST", // Updated to match QuickBase API spec
+                                method: "POST",
                                 headers: expect.objectContaining({
+                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
                                   Authorization: "QB-TEMP-TOKEN temp_token",
                                   "Content-Type": "application/json",
                                 }),