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

package/src/log-gen.ts

@@ -13,11 +13,15 @@ const excludeDirs: string[] = ["node_modules", ".git", "specs"];
 // prettier-ignore
 const includeFolders: string[] = [
   // "src/code-generation",
+  // "src/code-generation/definitions",
+  // "src/code-generation/paths",
 ];
 
 // prettier-ignore
 const includeRecursiveFolders: string[] = [
   "tests",
+  "tests/vitest/unit",
+  "tests/vitest/qb"
 ];
 
 // prettier-ignore
@@ -73,8 +77,8 @@ const pipelineOverview: string[] = [
   "getTempTokenDBID() method is wrapped to enhance temporary token generation reuse interacting with a token cache.",
   "#",
   "npm run fix-spec: Generates quickbase-fixed.json from the latest QuickBase_RESTful*.json file.",
-  "npm run regenerate: Generates raw TypeScript-fetch files in src/generated/.",
-  "npm run generate-unified: Generates a unified QuickbaseClient.ts interface in src/generated-unified/.",
+  "npm run regenerate:openapi Generates raw TypeScript-fetch files in src/generated/.",
+  "npm run generate:unified: Generates a unified QuickbaseClient.ts interface in src/generated-unified/.",
 ];
 
 interface TreeNode {

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/fields/createField.test.ts

@@ -0,0 +1,78 @@
+// tests/vitest/qb/fields/createField.test.ts (updated)
+import { describe, it, expect, afterAll } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - createField", () => {
+  const client = createClient();
+
+  const createdFieldIds: number[] = [];
+
+  afterAll(async () => {
+    if (createdFieldIds.length > 0) {
+      try {
+        const response = await client.deleteFields({
+          tableId: QB_TABLE_ID_1,
+          body: { fieldIds: createdFieldIds },
+        });
+        console.log(
+          `Cleaned up fields: ${JSON.stringify(response.deletedFieldIds)}`,
+          response.errors && response.errors.length > 0
+            ? `Errors: ${response.errors}`
+            : ""
+        );
+      } catch (error) {
+        console.error("Cleanup failed:", error);
+        console.log(`Fields left in table: ${createdFieldIds}`);
+      }
+    } else {
+      console.log("No fields to clean up.");
+    }
+  });
+
+  it("creates a field with user token", async () => {
+    const uniqueLabel = `TestField_${Date.now()}`;
+    const response = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: uniqueLabel,
+        fieldType: "text",
+        fieldHelp: "Created via integration test",
+        addToForms: true,
+      },
+    });
+
+    expect(response.id).toBeDefined();
+    expect(response.label).toBe(uniqueLabel);
+    expect(response.fieldType).toBe("text");
+    expect(response.fieldHelp).toBe("Created via integration test");
+
+    createdFieldIds.push(response.id);
+    console.log(`Created field ${uniqueLabel} with ID ${response.id}`);
+  });
+
+  it("fails with invalid field type", async () => {
+    const uniqueLabel = `InvalidField_${Date.now()}`;
+    await expect(
+      client.createField({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          label: uniqueLabel,
+          fieldType: "invalid_type" as "text", // Type assertion to bypass compile-time check
+          fieldHelp: "Should fail",
+        },
+      })
+    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
+  });
+
+  it("fails with missing label", async () => {
+    await expect(
+      client.createField({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          label: "",
+          fieldType: "text",
+        },
+      })
+    ).rejects.toThrow("API Error: Invalid input (Status: 400)");
+  });
+});

package/tests/vitest/qb/fields/deleteFields.test.ts

@@ -0,0 +1,89 @@
+// tests/vitest/qb/fields/deleteFields.test.ts
+import { describe, it, expect, beforeAll } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - deleteFields", () => {
+  const client = createClient();
+
+  let fieldIdsToDelete: number[] = [];
+
+  beforeAll(async () => {
+    try {
+      // Create test fields to delete
+      const fieldLabels = ["DeleteTest1", "DeleteTest2"];
+      for (const label of fieldLabels) {
+        const response = await client.createField({
+          tableId: QB_TABLE_ID_1,
+          body: {
+            label,
+            fieldType: "text",
+            fieldHelp: "Test field for deletion",
+          },
+        });
+        fieldIdsToDelete.push(response.id);
+        console.log(`Created field ${label} with ID ${response.id}`);
+      }
+      if (fieldIdsToDelete.length !== 2) {
+        throw new Error("Failed to create all test fields");
+      }
+    } catch (error) {
+      console.error("beforeAll failed:", error);
+      throw error; // Fail the suite if setup fails
+    }
+  });
+
+  it("deletes fields successfully with user token", async () => {
+    try {
+      const response = await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          fieldIds: fieldIdsToDelete,
+        },
+      });
+
+      console.log("deleteFields response:", JSON.stringify(response, null, 2));
+
+      expect(response).toBeDefined();
+      expect(response.deletedFieldIds).toEqual(
+        expect.arrayContaining(fieldIdsToDelete)
+      );
+      expect(response.errors ?? []).toHaveLength(0); // Handle undefined errors
+    } catch (error) {
+      console.error("deleteFields failed:", error);
+      throw error; // Re-throw to fail the test with details
+    }
+  });
+
+  it("handles partial success with errors", async () => {
+    const newField = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: "DeleteTest3",
+        fieldType: "text",
+      },
+    });
+    console.log(`Created field DeleteTest3 with ID ${newField.id}`);
+
+    const invalidFieldId = 999999; // Assume this ID doesn’t exist
+    const fieldIds = [newField.id, invalidFieldId];
+
+    const response = await client.deleteFields({
+      tableId: QB_TABLE_ID_1,
+      body: { fieldIds },
+    });
+
+    expect(response.deletedFieldIds).toContain(newField.id);
+    expect(response.deletedFieldIds).not.toContain(invalidFieldId);
+    expect(response.errors).toHaveLength(1);
+    expect(response.errors[0]).toMatch(/Field: 999999 was not found/i);
+  });
+
+  it("fails with invalid request (empty fieldIds)", async () => {
+    await expect(
+      client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [] },
+      })
+    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
+  });
+});

package/tests/vitest/qb/fields/getField.test.ts

@@ -0,0 +1,85 @@
+// tests/vitest/qb/fields/getField.test.ts
+import { describe, it, expect } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - getField", () => {
+  const client = createClient();
+
+  it("retrieves an existing field with user token", async () => {
+    // Create a field to ensure we have a known field ID to retrieve
+    const uniqueLabel = `TestField_${Date.now()}`;
+    const createResponse = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: uniqueLabel,
+        fieldType: "text",
+        fieldHelp: "Created for getField integration test",
+        addToForms: true,
+      },
+    });
+
+    expect(createResponse.id).toBeDefined();
+    const fieldId = createResponse.id;
+    console.log(`Created field ${uniqueLabel} with ID ${fieldId} for testing`);
+
+    // Test getField with the created field
+    const response = await client.getField({
+      fieldId: fieldId,
+      tableId: QB_TABLE_ID_1,
+      includeFieldPerms: true,
+    });
+
+    expect(response.id).toBe(fieldId);
+    expect(response.label).toBe(uniqueLabel);
+    expect(response.fieldType).toBe("text");
+    expect(response.fieldHelp).toBe("Created for getField integration test");
+    expect(response.permissions).toBeDefined();
+    expect(Array.isArray(response.permissions)).toBe(true);
+    console.log(`Retrieved field ${response.label} with ID ${response.id}`);
+
+    // Clean up the created field
+    try {
+      const deleteResponse = await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [fieldId] },
+      });
+      console.log(
+        `Cleaned up field ${fieldId}: ${JSON.stringify(deleteResponse)}`
+      );
+    } catch (error) {
+      console.error(`Failed to clean up field ${fieldId}:`, error);
+    }
+  }, 10000); // Increase timeout to 10 seconds
+
+  it("fails with non-existent field ID", async () => {
+    const nonExistentFieldId = 999999; // Assuming this ID doesn’t exist
+    await expect(
+      client.getField({
+        fieldId: nonExistentFieldId,
+        tableId: QB_TABLE_ID_1,
+      })
+    ).rejects.toMatchObject({
+      message: expect.stringContaining(
+        "API Error: No such field (Status: 404)"
+      ),
+    });
+    console.log(
+      `Confirmed 404 for non-existent field ID ${nonExistentFieldId}`
+    );
+  });
+
+  it("fails with invalid table ID", async () => {
+    const invalidTableId = "invalid_dbid";
+    await expect(
+      client.getField({
+        fieldId: 1, // Arbitrary field ID
+        tableId: invalidTableId,
+      })
+    ).rejects.toMatchObject({
+      message: expect.stringContaining(
+        "API Error: Invalid request (Status: 400)"
+      ),
+    });
+    console.log(`Confirmed 400 for invalid table ID ${invalidTableId}`);
+  });
+});