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

package/src/generated-unified/QuickbaseClient.ts

@@ -1,17 +1,18 @@
-// Generated on 2025-03-11T14:12:45.650Z
-import { App, CreateApp200Response, CreateAppRequest, DeleteRecords200Response, DeleteRecordsRequest, DeleteTableResponse, Field, GetTempTokenDBID200Response, ReportRunResponse, RunQueryRequest, RunQueryResponse, Table, UpdateTableRequest, Upsert200Response, Upsert207Response, UpsertRequest } from "../generated/models";
+// Generated on 2025-03-11T21:50:08.483Z
+import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, DeleteApp200Response, DeleteAppRequest, 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>;
+  deleteApp: (params: { appId: string; body: DeleteAppRequest }) => Promise<DeleteApp200Response>;
   getAppEvents: (params: { appId: string }) => Promise<any[]>;
-  copyApp: (params: { appId: string; generated?: any }) => Promise<{ [key: string]: 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: { skip?: number; tableId: string }) => Promise<{ [key: string]: any }>;
+  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 }>;

package/src/log-gen.ts

@@ -17,7 +17,9 @@ const includeFolders: string[] = [
 
 // prettier-ignore
 const includeRecursiveFolders: string[] = [
-  "tests",
+  // "tests",
+  "tests/vitest/unit",
+  // "tests/vitest/qb"
 ];
 
 // prettier-ignore
@@ -28,8 +30,8 @@ const includeFiles: string[] = [
   // "vitest.config.ts",
   // "src/utils.ts",
   // "src/tokenCache.ts",
-  // "src/generated-unified/QuickbaseClient.ts",
-  // "src/quickbaseClient.ts",
+  "src/generated-unified/QuickbaseClient.ts",
+  "src/quickbaseClient.ts",
 ];
 
 const projectGoals: string[] = [

package/src/quickbaseClient.ts

@@ -79,15 +79,15 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
 
   const tokenCache = new TokenCache();
 
-  const headers: HTTPHeaders = {
+  const baseHeaders: HTTPHeaders = {
     "QB-Realm-Hostname": `${realm}.quickbase.com`,
     "Content-Type": "application/json",
   };
 
   if (initialTempToken) {
-    headers["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
+    baseHeaders["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
   } else if (userToken && !useTempTokens) {
-    headers["Authorization"] = `QB-USER-TOKEN ${userToken}`;
+    baseHeaders["Authorization"] = `QB-USER-TOKEN ${userToken}`;
   }
 
   const defaultFetch: typeof fetch | undefined =
@@ -96,7 +96,7 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
       : undefined;
   const configuration = new Configuration({
     basePath: baseUrl,
-    headers: { ...headers },
+    headers: { ...baseHeaders },
     fetchApi: fetchApi || defaultFetch,
     credentials: useTempTokens ? "include" : "omit",
   });
@@ -162,7 +162,7 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
       `https://api.quickbase.com/v1/auth/temporary/${dbid}`,
       {
         method: "GET",
-        headers: { ...headers },
+        headers: { ...baseHeaders },
         credentials: "include",
       }
     );
@@ -194,23 +194,24 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
     return token;
   };
 
-  const invokeMethod = async <K extends keyof QuickbaseClient>(
+  async function invokeMethod<K extends keyof QuickbaseClient>(
     methodName: K,
     params: Parameters<QuickbaseClient[K]>[0] & Partial<TempTokenParams>,
     retryCount: number = 0
-  ): Promise<ReturnType<QuickbaseClient[K]>> => {
+  ): Promise<ReturnType<QuickbaseClient[K]>> {
     const methodInfo = methodMap[methodName];
     if (!methodInfo) {
       throw new Error(`Method ${methodName} not found`);
     }
 
-    const args: [any, RequestInit | undefined] =
+    const requestParameters =
       methodInfo.paramMap.length === 1 &&
       methodInfo.paramMap[0] === "requestParameters"
-        ? [{ requestParameters: params }, undefined]
-        : [params, undefined];
+        ? { requestParameters: params }
+        : params;
+    let requestOptions: RequestInit = {};
 
-    let token =
+    const selectedToken =
       initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
 
     if (methodName === "getTempTokenDBID" && useTempTokens) {
@@ -223,43 +224,38 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
       }
     }
 
-    if (useTempTokens && !token) {
+    let authorizationToken = selectedToken;
+    if (useTempTokens && !authorizationToken) {
       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]
-          >;
-        }
+      authorizationToken = cachedToken || (await fetchTempToken(dbid));
+      if (methodName === "getTempTokenDBID") {
+        return { temporaryAuthorization: authorizationToken } as ReturnType<
+          QuickbaseClient[K]
+        >;
       }
-      args[1] = {
-        headers: {
-          ...headers,
-          Authorization: `QB-TEMP-TOKEN ${token}`,
-        },
+      requestOptions.headers = {
+        ...baseHeaders,
+        Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
+      };
+    } else if (authorizationToken) {
+      requestOptions.headers = {
+        ...baseHeaders,
+        Authorization: `QB-USER-TOKEN ${authorizationToken}`,
       };
     }
 
     try {
-      const response = await methodInfo.method(...args);
-      return response;
+      return await methodInfo.method(requestParameters, requestOptions);
     } catch (error) {
       if (
         error instanceof ResponseError &&
         error.response.status === 401 &&
-        retryCount < 1
+        retryCount < 1 &&
+        useTempTokens
       ) {
         if (debug) {
           console.log(
@@ -271,12 +267,10 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
           params,
           `No dbid to refresh token after authorization error`
         );
-        token = await fetchTempToken(dbid);
-        args[1] = {
-          headers: {
-            ...headers,
-            Authorization: `QB-TEMP-TOKEN ${token}`,
-          },
+        authorizationToken = await fetchTempToken(dbid);
+        requestOptions.headers = {
+          ...baseHeaders,
+          Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
         };
         if (debug) {
           console.log(`Retrying ${methodName} with new token`);
@@ -300,7 +294,7 @@ export function quickbase(config: QuickbaseConfig): QuickbaseClient {
       }
       throw error;
     }
-  };
+  }
 
   const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, {
     get: (_, prop: string): ((params: any) => Promise<any>) | undefined => {

package/tests/setup.ts

@@ -13,13 +13,17 @@ export const QB_REALM = process.env.QB_REALM || "test-realm";
 export const QB_USER_TOKEN =
   process.env.QB_USER_TOKEN || "user-token-1234567890";
 export const QB_APP_ID = process.env.QB_APP_ID || "app-id-1234567890";
-export const QB_TABLE_ID_1 = process.env.QB_TABLE_ID_1 || "table-id-1234567890";
+export const QB_TABLE_ID_1 =
+  process.env.QB_TABLE_ID_1 || "table-id-1-1234567890";
+export const QB_TABLE_ID_2 =
+  process.env.QB_TABLE_ID_2 || "table-id-2-1234567890";
 
 // Mock env variables for consistency, using .env values if available
 vi.stubEnv("QB_REALM", QB_REALM);
 vi.stubEnv("QB_USER_TOKEN", QB_USER_TOKEN);
 vi.stubEnv("QB_APP_ID", QB_APP_ID);
 vi.stubEnv("QB_TABLE_ID_1", QB_TABLE_ID_1);
+vi.stubEnv("QB_TABLE_ID_2", QB_TABLE_ID_2);
 
 export const createClient = (
   fetchApi?: any,

package/tests/vitest/qb/apps/copyApp.test.ts

@@ -0,0 +1,76 @@
+// tests/vitest/qb/apps/copyApp.test.ts
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - copyApp > creates a new copied app in QuickBase",
+  { timeout: 30000 }, // Increased to 30 seconds
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+    };
+    const client = quickbase(config);
+    const appId = process.env.QB_APP_ID || ""; // The source app ID to copy from
+
+    const copyAppName = `CopiedApp_${Date.now()}`; // Unique name to avoid conflicts
+    const copyBody = {
+      name: copyAppName,
+      description: "Test copied app",
+      properties: {
+        keepData: false,
+        excludeFiles: true,
+        usersAndRoles: false,
+        assignUserToken: true,
+      },
+    };
+
+    console.log("Config used:", {
+      ...config,
+      userToken: config.userToken ? "[REDACTED]" : "", // Avoid logging sensitive token
+    });
+    console.log("Copying app with:", copyBody);
+    const startTime = Date.now();
+    let response;
+    try {
+      response = await client.copyApp({ appId, body: copyBody });
+      const duration = Date.now() - startTime;
+      console.log(`copyApp completed in ${duration}ms`);
+      console.log("Real API response:", response);
+
+      expect(response).toBeDefined();
+      expect(response.id).toBeDefined();
+      expect(response.name).toBe(copyAppName);
+      expect(response.description).toBe(copyBody.description);
+      expect(response.created).toBeInstanceOf(Date);
+      expect(response.updated).toBeInstanceOf(Date);
+      expect(response.dateFormat).toMatch(/^\w{2}-\w{2}-\w{4}$/); // e.g., "MM-DD-YYYY"
+      expect(typeof response.timeZone).toBe("string"); // Simplified check
+      expect(typeof response.hasEveryoneOnTheInternet).toBe("boolean");
+      expect(response.ancestorId).toBe(appId); // Should match the source app ID
+      expect(
+        response.dataClassification === undefined ||
+          typeof response.dataClassification === "string"
+      ).toBe(true); // Allow undefined or string
+      expect(
+        response.variables === undefined || Array.isArray(response.variables)
+      ).toBe(true); // Allow undefined or array
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      console.error(`copyApp failed after ${duration}ms:`, error);
+      throw error; // Re-throw to fail the test
+    }
+
+    // Cleanup: Delete the copied app using deleteApp
+    const deleteStartTime = Date.now();
+    const deleteResponse = await client.deleteApp({
+      appId: response.id,
+      body: { name: copyAppName },
+    });
+    const deleteDuration = Date.now() - deleteStartTime;
+    console.log(`deleteApp completed in ${deleteDuration}ms`);
+    console.log("Cleanup - Deleted app:", deleteResponse);
+    expect(deleteResponse.deletedAppId).toBe(response.id);
+  }
+);

package/tests/vitest/qb/apps/createApp.test.ts

@@ -0,0 +1,64 @@
+// tests/vitest/qb/apps/createApp.test.ts
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - createApp > creates a new app in QuickBase",
+  { timeout: 30000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+      useTempTokens: false,
+    };
+    const client = quickbase(config);
+
+    const appName = `TestApp_${Date.now()}`;
+    const createBody = {
+      name: appName,
+      description: "Test app creation",
+      assignToken: true,
+    };
+
+    console.log("Config used:", {
+      ...config,
+      userToken: config.userToken ? "[REDACTED]" : "",
+    });
+    console.log("Creating app with:", createBody);
+    const createStartTime = Date.now();
+    let response;
+    try {
+      response = await client.createApp({ body: createBody });
+      const createDuration = Date.now() - createStartTime;
+      console.log(`createApp completed in ${createDuration}ms`);
+      console.log("Real API response:", response);
+
+      expect(response).toBeDefined();
+      expect(response.id).toBeDefined();
+      expect(response.name).toBe(appName);
+      expect(response.description).toBe(createBody.description);
+      expect(response.created).toBeInstanceOf(Date);
+      expect(response.updated).toBeInstanceOf(Date);
+      expect(response.dateFormat).toMatch(/^\w{2}-\w{2}-\w{4}$/);
+      expect(typeof response.timeZone).toBe("string");
+      expect(typeof response.hasEveryoneOnTheInternet).toBe("boolean");
+      expect(
+        response.dataClassification === undefined ||
+          typeof response.dataClassification === "string"
+      ).toBe(true);
+      expect(
+        response.variables === undefined || Array.isArray(response.variables)
+      ).toBe(true);
+
+      // Cleanup: Delete the app after assertions
+      const deleteBody = { name: appName };
+      await client.deleteApp({ appId: response.id, body: deleteBody });
+      console.log("Cleanup: App deleted:", response.id);
+    } catch (error) {
+      const createDuration = Date.now() - createStartTime;
+      console.error(`createApp failed after ${createDuration}ms:`, error);
+      throw error;
+    }
+  }
+);

package/tests/vitest/qb/apps/deleteApp.test.ts

@@ -0,0 +1,76 @@
+// tests/vitest/qb/apps/deleteApp.test.ts
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - deleteApp > deletes an app in QuickBase",
+  { timeout: 30000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+      useTempTokens: false,
+    };
+    const client = quickbase(config);
+
+    const appName = `TempApp_${Date.now()}`;
+    const createBody = {
+      name: appName,
+      description: "Temporary app for deleteApp test",
+      assignToken: true, // Match createApp.test.ts
+    };
+
+    console.log("Config used:", {
+      ...config,
+      userToken: config.userToken ? "[REDACTED]" : "",
+    });
+    console.log("Creating temporary app with:", createBody);
+    const createStartTime = Date.now();
+    let createResponse;
+    try {
+      createResponse = await client.createApp({ body: createBody });
+      const createDuration = Date.now() - createStartTime;
+      console.log(`createApp completed in ${createDuration}ms`);
+      console.log("Created app response:", createResponse);
+
+      expect(createResponse).toBeDefined();
+      expect(createResponse.id).toBeDefined();
+      expect(createResponse.name).toBe(appName);
+    } catch (error) {
+      const createDuration = Date.now() - createStartTime;
+      console.error(`createApp failed after ${createDuration}ms:`, error);
+      throw error;
+    }
+
+    const deleteBody = {
+      name: appName,
+    };
+    console.log("Deleting app with:", deleteBody);
+    const deleteStartTime = Date.now();
+    try {
+      const deleteResponse = await client.deleteApp({
+        appId: createResponse.id,
+        body: deleteBody,
+      });
+      const deleteDuration = Date.now() - deleteStartTime;
+      console.log(`deleteApp completed in ${deleteDuration}ms`);
+      console.log("Delete app response:", deleteResponse);
+
+      expect(deleteResponse).toBeDefined();
+      expect(deleteResponse.deletedAppId).toBe(createResponse.id);
+    } catch (error) {
+      const deleteDuration = Date.now() - deleteStartTime;
+      console.error(`deleteApp failed after ${deleteDuration}ms:`, error);
+      if (error instanceof Error && "response" in error) {
+        try {
+          const errorBody = await (error as any).response.json();
+          console.error("Full deleteApp error response:", errorBody);
+        } catch (e) {
+          console.error("Could not parse error response:", e);
+        }
+      }
+      throw error;
+    }
+  }
+);

package/tests/vitest/qb/records/deleteRecords.test.ts

@@ -1,6 +1,10 @@
 // tests/vitest/qb/records/deleteRecords.test.ts
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { quickbase } from "@/quickbaseClient.ts";
+import {
+  Upsert200Response,
+  Upsert207Response,
+} from "/home/drew/Projects/quickbase-js/src/generated/models";
 
 const TABLE_ID = "buwai2zws";
 const UNIQUE_FIELD_ID = 3; // Record ID field
@@ -40,16 +44,44 @@ describe("QuickbaseClient - DeleteRecords Integration", () => {
   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 upsertResponse: Upsert200Response | Upsert207Response =
+        await qb.upsert({
+          body: {
+            to: TABLE_ID,
+            data: [{ [MARKER_FIELD_ID]: { value: "test-marker-delete" } }],
+            fieldsToReturn: [UNIQUE_FIELD_ID], // Return record ID
+          },
+        });
+
+      // Check metadata and createdRecordIds
+      expect(
+        upsertResponse.metadata,
+        "Expected metadata to be defined"
+      ).toBeDefined();
+      expect(
+        upsertResponse.metadata?.createdRecordIds,
+        "Expected createdRecordIds to be defined"
+      ).toBeDefined();
+
+      const createdRecordIds = upsertResponse.metadata?.createdRecordIds;
+      if (!createdRecordIds || createdRecordIds.length === 0) {
+        throw new Error("Expected at least one created record ID");
+      }
+
+      const recordId = createdRecordIds[0];
+      expect(recordId, "Expected recordId to be defined").toBeDefined();
+
+      // Check data
+      expect(upsertResponse.data, "Expected data to be defined").toBeDefined();
+      if (!upsertResponse.data || upsertResponse.data.length === 0) {
+        throw new Error("Expected at least one data entry");
+      }
+
+      const recordData = upsertResponse.data[0];
+      expect(
+        recordData[UNIQUE_FIELD_ID]?.value,
+        "Expected record ID in data to match created record ID"
+      ).toBe(recordId);
 
       const deleteResponse = await qb.deleteRecords({
         body: { from: TABLE_ID, where: `{${UNIQUE_FIELD_ID}.EX.${recordId}}` },

package/tests/vitest/qb/records/runQuery.test.ts

@@ -1,7 +1,17 @@
 // tests/vitest/qb/records/runQuery.test.ts
 import { describe, it, expect } from "vitest";
-import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts"; // Import QB_TABLE_ID_1
-import { RunQueryRequest, RunQueryResponse } from "@/generated/models";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+import {
+  RunQueryRequest,
+  RunQueryResponse,
+  Upsert200Response,
+  Upsert207Response,
+} from "@/generated/models";
+
+// Define a type for field data with a value property (matches generated Record type)
+interface FieldData {
+  value: any; // Adjust type based on your needs (e.g., string | number)
+}
 
 describe("QuickbaseClient Integration - runQuery", () => {
   let createdRecordId: number;
@@ -12,18 +22,39 @@ describe("QuickbaseClient Integration - runQuery", () => {
       const client = createClient();
 
       // Upsert a test record to query later
-      const upsertResponse = await client.upsert({
-        body: {
-          to: QB_TABLE_ID_1,
-          data: [
-            {
-              "6": { value: "Test Task " + Date.now() }, // Assuming field 6 is a text field
-            },
-          ],
-          fieldsToReturn: [3, 6], // Record ID# and the text field
-        },
-      });
-      createdRecordId = upsertResponse.metadata.createdRecordIds[0];
+      const upsertResponse: Upsert200Response | Upsert207Response =
+        await client.upsert({
+          body: {
+            to: QB_TABLE_ID_1,
+            data: [
+              {
+                "6": { value: "Test Task " + Date.now() }, // Assuming field 6 is a text field
+              },
+            ],
+            fieldsToReturn: [3, 6], // Record ID# and the text field
+          },
+        });
+
+      // Check metadata and createdRecordIds with null safety
+      expect(
+        upsertResponse.metadata,
+        "Expected metadata to be defined"
+      ).toBeDefined();
+      expect(
+        upsertResponse.metadata?.createdRecordIds,
+        "Expected createdRecordIds to be defined"
+      ).toBeDefined();
+
+      const createdRecordIds = upsertResponse.metadata?.createdRecordIds;
+      if (!createdRecordIds || createdRecordIds.length === 0) {
+        throw new Error("Expected at least one created record ID from upsert");
+      }
+
+      createdRecordId = createdRecordIds[0];
+      expect(
+        createdRecordId,
+        "Expected createdRecordId to be defined"
+      ).toBeDefined();
       console.log("Created test record with ID:", createdRecordId);
 
       // Query the record
@@ -46,10 +77,35 @@ describe("QuickbaseClient Integration - runQuery", () => {
       });
       console.log("Real API response:", response);
 
-      // Assertions
+      // Assertions with safety checks and type assertion
+      expect(
+        response.data,
+        "Expected response.data to be defined"
+      ).toBeDefined();
+      if (!response.data || response.data.length === 0) {
+        throw new Error(
+          "Expected response.data to contain at least one record"
+        );
+      }
+
       expect(response.data).toHaveLength(1);
-      expect(response.data[0]["3"].value).toBe(createdRecordId);
-      expect(response.data[0]["6"].value).toContain("Test Task");
+      const record = response.data[0] as { [key: string]: FieldData };
+      expect(
+        record["3"]?.value,
+        "Expected field 3 to match createdRecordId"
+      ).toBe(createdRecordId);
+      expect(
+        record["6"]?.value,
+        "Expected field 6 to contain 'Test Task'"
+      ).toContain("Test Task");
+
+      expect(
+        response.fields,
+        "Expected response.fields to be defined"
+      ).toBeDefined();
+      if (!response.fields) {
+        throw new Error("Expected response.fields to contain field metadata");
+      }
       expect(response.fields).toContainEqual({
         id: 3,
         label: expect.any(String),
@@ -60,6 +116,14 @@ describe("QuickbaseClient Integration - runQuery", () => {
         label: expect.any(String),
         type: expect.any(String),
       });
+
+      expect(
+        response.metadata,
+        "Expected response.metadata to be defined"
+      ).toBeDefined();
+      if (!response.metadata) {
+        throw new Error("Expected response.metadata to be present");
+      }
       expect(response.metadata).toMatchObject({
         numFields: 2,
         numRecords: 1,