quickbase-js 0.1.0-beta.7 → 0.1.0-beta.8

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

@@ -1,3 +1,4 @@
+// tests/vitest/qb/apps/getApp.test.ts
 import { test, expect } from "vitest";
 import { quickbase } from "../../../../src/quickbaseClient";
 
@@ -20,8 +21,8 @@ test(
     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
+      created: expect.any(Date),
+      updated: expect.any(Date),
       description: "",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       dateFormat: "MM-DD-YYYY",
@@ -35,6 +36,9 @@ test(
         mustBeRealmApproved: false,
         useIPFilter: false,
       },
+      ancestorId: undefined,
+      dataClassification: undefined,
+      variables: [{ name: "TestVar", value: "TestValue" }],
     });
   }
 );

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

@@ -0,0 +1,67 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getAppEvents > fetches real app events 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 appId = "buwai2zpe"; // Same app ID as getApp test
+
+    console.log("Config used:", config);
+    const result = await client.getAppEvents({ appId });
+    console.log("Real API response:", result);
+
+    // Validate the response is an array of events
+    expect(result).toBeInstanceOf(Array);
+
+    // Check that each event has the required properties
+    result.forEach((event) => {
+      expect(event).toHaveProperty("type");
+      expect([
+        "qb-action",
+        "webhook",
+        "email-notification",
+        "subscription",
+        "reminder",
+        "automation",
+      ]).toContain(event.type);
+
+      expect(event).toHaveProperty("owner");
+      expect(event.owner).toHaveProperty("email");
+      expect(typeof event.owner.email).toBe("string");
+      expect(event.owner).toHaveProperty("id");
+      expect(typeof event.owner.id).toBe("string");
+      expect(event.owner).toHaveProperty("name");
+      expect(typeof event.owner.name).toBe("string");
+      // userName is optional, so we don't enforce it
+
+      expect(event).toHaveProperty("isActive");
+      expect(typeof event.isActive).toBe("boolean");
+
+      expect(event).toHaveProperty("tableId");
+      expect(typeof event.tableId).toBe("string");
+
+      // Name is present for all types except automation
+      if (event.type !== "automation") {
+        expect(event).toHaveProperty("name");
+        expect(typeof event.name).toBe("string");
+      } else {
+        expect(event.name).toBeUndefined();
+      }
+
+      // URL is only present for automation
+      if (event.type === "automation") {
+        expect(event).toHaveProperty("url");
+        expect(typeof event.url).toBe("string");
+      } else {
+        expect(event.url).toBeUndefined();
+      }
+    });
+  }
+);

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

@@ -0,0 +1,58 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - updateApp > updates real app 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"; // Same app ID as before
+
+    // Original app data (to restore later if needed)
+    const originalApp = await client.getApp({ appId });
+    console.log("Original app data:", originalApp);
+
+    // Update request
+    const updateRequest = {
+      name: "qb-copy-updated",
+      description: "Updated via integration test",
+      variables: [{ name: "TestVar", value: "TestValue" }],
+    };
+
+    console.log("Config used:", config);
+    console.log("Update request:", updateRequest);
+    const result = await client.updateApp({ appId, body: updateRequest });
+    console.log("Real API response:", result);
+
+    // Validate the response
+    expect(result).toHaveProperty("id", appId);
+    expect(result).toHaveProperty("name", "qb-copy-updated");
+    expect(result).toHaveProperty(
+      "description",
+      "Updated via integration test"
+    );
+    expect(result).toHaveProperty("variables");
+    expect(result.variables).toContainEqual({
+      name: "TestVar",
+      value: "TestValue",
+    });
+    expect(result).toHaveProperty("created");
+    expect(result.created).toBeInstanceOf(Date);
+    expect(result).toHaveProperty("updated");
+    expect(result.updated).toBeInstanceOf(Date);
+
+    // Optional: Restore original name to avoid permanent changes
+    const restoreRequest = {
+      name: originalApp.name,
+      description: originalApp.description,
+      variables: originalApp.variables,
+    };
+    await client.updateApp({ appId, body: restoreRequest });
+    console.log("Restored app to:", originalApp.name);
+  }
+);

package/tests/vitest/qb/auth/retryUserToken401.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, vi, expect, beforeEach } from "vitest";
+import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient";
+import { ResponseError } from "../../../../src/generated/runtime";
+
+describe("QuickbaseClient Integration - User Token Retry on 401", () => {
+  let client: QuickbaseClient;
+  const mockFetch = vi.fn();
+
+  beforeEach(() => {
+    const config = {
+      realm: process.env.QB_REALM || "builderprogram-dbradford6815",
+      userToken: "mock-user-token",
+      debug: true,
+      fetchApi: mockFetch,
+    };
+    console.log("[quickbaseTest] Config:", config);
+    client = quickbase(config);
+  });
+
+  it("retries on transient 401 with user token and succeeds", async () => {
+    const consoleSpy = vi.spyOn(console, "log");
+
+    mockFetch
+      .mockImplementationOnce(() => {
+        const response = new Response(null, {
+          status: 401,
+          statusText: "Unauthorized",
+        });
+        console.log("[mockFetch] Throwing 401 ResponseError");
+        return Promise.reject(new ResponseError(response));
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: async () => [{ id: 1, label: "Mock Field", fieldType: "text" }],
+      });
+
+    const fields = await client.getFields({ tableId: "mock-table-id" });
+
+    expect(fields).toBeInstanceOf(Array);
+    expect(fields.length).toBeGreaterThan(0);
+    expect(fields[0]).toHaveProperty("id");
+    expect(fields[0]).toHaveProperty("label");
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Authorization error for getFields (user token), retrying with same token:",
+      "" // Matches empty ResponseError message from mock
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Retrying getFields with user token"
+    );
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    consoleSpy.mockRestore();
+  });
+});

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

@@ -1,4 +1,3 @@
-// tests/vitest/qb/fields/createField.test.ts (updated)
 import { describe, it, expect, afterAll } from "vitest";
 import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
 
@@ -62,7 +61,7 @@ describe("QuickbaseClient Integration - createField", () => {
         },
       })
     ).rejects.toThrow("API Error: Bad Request (Status: 400)");
-  });
+  }, 10000); // Increased timeout to 10 seconds
 
   it("fails with missing label", async () => {
     await expect(

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

@@ -4,12 +4,10 @@ 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({
@@ -28,7 +26,7 @@ describe("QuickbaseClient Integration - deleteFields", () => {
       }
     } catch (error) {
       console.error("beforeAll failed:", error);
-      throw error; // Fail the suite if setup fails
+      throw error;
     }
   });
 
@@ -36,41 +34,37 @@ describe("QuickbaseClient Integration - deleteFields", () => {
     try {
       const response = await client.deleteFields({
         tableId: QB_TABLE_ID_1,
-        body: {
-          fieldIds: fieldIdsToDelete,
-        },
+        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
+      expect(response.errors ?? []).toHaveLength(0);
     } catch (error) {
       console.error("deleteFields failed:", error);
-      throw error; // Re-throw to fail the test with details
+      throw error;
     }
   });
 
-  it("handles partial success with errors", async () => {
+  it("handles partial success with errors", { timeout: 10000 }, async () => {
     const newField = await client.createField({
       tableId: QB_TABLE_ID_1,
-      body: {
-        label: "DeleteTest3",
-        fieldType: "text",
-      },
+      body: { label: "DeleteTest3", fieldType: "text" },
     });
     console.log(`Created field DeleteTest3 with ID ${newField.id}`);
 
-    const invalidFieldId = 999999; // Assume this ID doesn’t exist
+    const invalidFieldId = 999999;
     const fieldIds = [newField.id, invalidFieldId];
 
+    console.log("Sending deleteFields request at:", new Date());
     const response = await client.deleteFields({
       tableId: QB_TABLE_ID_1,
       body: { fieldIds },
     });
+    console.log("deleteFields response received at:", new Date());
+    console.log("Response:", JSON.stringify(response, null, 2));
 
     expect(response.deletedFieldIds).toContain(newField.id);
     expect(response.deletedFieldIds).not.toContain(invalidFieldId);

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

@@ -0,0 +1,93 @@
+// tests/vitest/qb/fields/updateField.test.ts
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - updateField", () => {
+  const client = createClient();
+  let fieldIdToUpdate: number;
+
+  // Setup: Create a test field to update
+  beforeAll(async () => {
+    try {
+      const response = await client.createField({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          label: "UpdateTestField",
+          fieldType: "text",
+          fieldHelp: "Test field for updating",
+        },
+      });
+      fieldIdToUpdate = response.id;
+      console.log(`Created field UpdateTestField with ID ${fieldIdToUpdate}`);
+    } catch (error) {
+      console.error("beforeAll failed:", error);
+      throw error; // Fail the suite if setup fails
+    }
+  });
+
+  // Teardown: Delete the test field
+  afterAll(async () => {
+    try {
+      if (fieldIdToUpdate) {
+        const response = await client.deleteFields({
+          tableId: QB_TABLE_ID_1,
+          body: { fieldIds: [fieldIdToUpdate] },
+        });
+        console.log(
+          `Deleted field ${fieldIdToUpdate}:`,
+          JSON.stringify(response, null, 2)
+        );
+      }
+    } catch (error) {
+      console.error("afterAll cleanup failed:", error);
+      // Don’t throw here to avoid masking test results
+    }
+  });
+
+  it(
+    "updates a field successfully with user token",
+    { timeout: 10000 },
+    async () => {
+      try {
+        const updatedLabel = "UpdatedTestField";
+        console.log("Sending updateField request at:", new Date());
+        const response = await client.updateField({
+          tableId: QB_TABLE_ID_1,
+          fieldId: fieldIdToUpdate,
+          body: {
+            label: updatedLabel,
+            fieldHelp: "Updated help text",
+          },
+        });
+        console.log("updateField response received at:", new Date());
+        console.log("Response:", JSON.stringify(response, null, 2));
+
+        // Verify the update was successful
+        expect(response).toBeDefined();
+        expect(response.id).toBe(fieldIdToUpdate);
+        expect(response.label).toBe(updatedLabel);
+        expect(response.fieldHelp).toBe("Updated help text");
+      } catch (error) {
+        console.error("updateField failed:", error);
+        throw error; // Re-throw to fail the test with details
+      }
+    }
+  );
+
+  it("fails with invalid field ID", { timeout: 10000 }, async () => {
+    try {
+      await expect(
+        client.updateField({
+          tableId: QB_TABLE_ID_1,
+          fieldId: 999999, // Invalid field ID
+          body: {
+            label: "InvalidUpdate",
+          },
+        })
+      ).rejects.toThrow("API Error: Item not found (Status: 404)"); // Updated to match actual error
+    } catch (error) {
+      console.error("updateField with invalid ID failed unexpectedly:", error);
+      throw error;
+    }
+  });
+});

package/tests/vitest/qb/index.ts

@@ -26,3 +26,4 @@ export * from "./tables/getAppTables.test.ts";
 export * from "./tables/getRelationships.test.ts";
 export * from "./tables/getTable.test.ts";
 export * from "./tables/updateTable.test.ts";
+export * from "./tables/updateRelationship.test.ts";

package/tests/vitest/qb/tables/updateRelationship.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
+import {
+  createClient,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+  QB_TABLE_ID_2,
+} from "@tests/setup.ts";
+import {
+  UpdateRelationshipRequest,
+  CreateFieldRequest,
+} from "@/generated/models";
+
+describe("QuickbaseClient Integration - updateRelationship", () => {
+  let client: ReturnType<typeof createClient>;
+  let relationshipId: number;
+  let newLookupFieldId: number | undefined;
+  let newChildFieldId: number | undefined;
+  let generatedLookupFieldId: number | undefined;
+  let generatedSummaryFieldId: number | undefined;
+
+  beforeAll(async () => {
+    client = createClient(fetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
+    if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+
+    const relationshipsResponse = await client.getRelationships({
+      tableId: QB_TABLE_ID_2,
+      skip: 0,
+    });
+    console.log(
+      "Initial relationships response:",
+      JSON.stringify(relationshipsResponse, null, 2)
+    );
+    const relationship = relationshipsResponse.relationships.find(
+      (r) => r.parentTableId === QB_TABLE_ID_1
+    );
+    if (!relationship) {
+      throw new Error(
+        `No relationship found between parent ${QB_TABLE_ID_1} and child ${QB_TABLE_ID_2}`
+      );
+    }
+    relationshipId = relationship.id;
+    console.log(`Identified relationshipId: ${relationshipId}`);
+
+    const lookupFieldRequest: CreateFieldRequest = {
+      label: `Test Lookup Field_${Date.now()}`,
+      fieldType: "text",
+    };
+    const lookupResponse = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: lookupFieldRequest,
+    });
+    newLookupFieldId = lookupResponse.id;
+    if (!newLookupFieldId) {
+      throw new Error("Failed to retrieve ID for newly created lookup field");
+    }
+    console.log(
+      `Created lookup field with ID ${newLookupFieldId} in parent table ${QB_TABLE_ID_1}`
+    );
+
+    const childFieldRequest: CreateFieldRequest = {
+      label: `Test Child Numeric_${Date.now()}`,
+      fieldType: "numeric",
+    };
+    const childResponse = await client.createField({
+      tableId: QB_TABLE_ID_2,
+      body: childFieldRequest,
+    });
+    newChildFieldId = childResponse.id;
+    if (!newChildFieldId) {
+      throw new Error("Failed to retrieve ID for newly created child field");
+    }
+    console.log(
+      `Created child field with ID ${newChildFieldId} in child table ${QB_TABLE_ID_2}`
+    );
+
+    console.log(
+      `Setup complete: relationshipId=${relationshipId}, lookupFieldId=${newLookupFieldId}, childFieldId=${newChildFieldId}`
+    );
+  }, 30000);
+
+  afterAll(async () => {
+    if (newLookupFieldId) {
+      try {
+        const deleteLookupResponse = await client.deleteFields({
+          tableId: QB_TABLE_ID_1,
+          body: { fieldIds: [newLookupFieldId] },
+        });
+        console.log(
+          `Deleted original lookup field ${newLookupFieldId} from ${QB_TABLE_ID_1}:`,
+          JSON.stringify(deleteLookupResponse, null, 2)
+        );
+      } catch (error) {
+        console.error(
+          `Failed to delete original lookup field ${newLookupFieldId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    if (newChildFieldId) {
+      try {
+        const deleteChildResponse = await client.deleteFields({
+          tableId: QB_TABLE_ID_2,
+          body: { fieldIds: [newChildFieldId] },
+        });
+        console.log(
+          `Deleted original child field ${newChildFieldId} from ${QB_TABLE_ID_2}:`,
+          JSON.stringify(deleteChildResponse, null, 2)
+        );
+      } catch (error) {
+        console.error(
+          `Failed to delete original child field ${newChildFieldId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    if (generatedLookupFieldId) {
+      try {
+        const deleteGeneratedLookupResponse = await client.deleteFields({
+          tableId: QB_TABLE_ID_2,
+          body: { fieldIds: [generatedLookupFieldId] },
+        });
+        console.log(
+          `Deleted generated lookup field ${generatedLookupFieldId} from ${QB_TABLE_ID_2}:`,
+          JSON.stringify(deleteGeneratedLookupResponse, null, 2)
+        );
+      } catch (error) {
+        console.error(
+          `Failed to delete generated lookup field ${generatedLookupFieldId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    if (generatedSummaryFieldId) {
+      try {
+        const deleteGeneratedSummaryResponse = await client.deleteFields({
+          tableId: QB_TABLE_ID_1,
+          body: { fieldIds: [generatedSummaryFieldId] },
+        });
+        console.log(
+          `Deleted generated summary field ${generatedSummaryFieldId} from ${QB_TABLE_ID_1}:`,
+          JSON.stringify(deleteGeneratedSummaryResponse, null, 2)
+        );
+      } catch (error) {
+        console.error(
+          `Failed to delete generated summary field ${generatedSummaryFieldId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+  }, 30000);
+
+  beforeEach(async () => {
+    const relationshipsResponse = await client.getRelationships({
+      tableId: QB_TABLE_ID_2,
+    });
+    const relationship = relationshipsResponse.relationships.find(
+      (r) => r.id === relationshipId
+    );
+    if (!relationship) {
+      throw new Error(`Relationship ${relationshipId} not found before test`);
+    }
+    console.log(
+      "Relationship state before test:",
+      JSON.stringify(relationship, null, 2)
+    );
+  }, 30000);
+
+  it("adds a lookup field to the relationship", async ({ expect }) => {
+    const tableId = QB_TABLE_ID_2;
+    const initialResponse = await client.getRelationships({ tableId });
+    const initialRelationship = initialResponse.relationships.find(
+      (r) => r.id === relationshipId
+    );
+    const currentLookupFields = (initialRelationship?.lookupFields || []).map(
+      (f) => f.id
+    );
+    console.log("Current lookupFields before update:", currentLookupFields);
+
+    const request: UpdateRelationshipRequest = {
+      lookupFieldIds: [newLookupFieldId!],
+    };
+    console.log(
+      "Adding lookup field request:",
+      JSON.stringify(request, null, 2)
+    );
+
+    const updateResponse = await client.updateRelationship({
+      tableId,
+      relationshipId,
+      body: request,
+    });
+    console.log("Update response:", JSON.stringify(updateResponse, null, 2));
+
+    const newLookup = updateResponse.lookupFields.find(
+      (f) =>
+        f.label.includes("Test Lookup Field") &&
+        !currentLookupFields.includes(f.id)
+    );
+    generatedLookupFieldId = newLookup?.id;
+    console.log(
+      `Captured generated lookup field ID: ${generatedLookupFieldId}`
+    );
+
+    expect(updateResponse.id).toBe(relationshipId);
+    expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(
+      updateResponse.lookupFields.some((f) =>
+        f.label.includes("Test Lookup Field")
+      )
+    ).toBe(true);
+    expect(updateResponse.lookupFields.some((f) => f.id === 19)).toBe(true);
+  }, 30000);
+
+  it("adds a summary field to the parent table", async ({ expect }) => {
+    const tableId = QB_TABLE_ID_2;
+    const initialResponse = await client.getRelationships({ tableId });
+    const initialRelationship = initialResponse.relationships.find(
+      (r) => r.id === relationshipId
+    );
+    const currentSummaryFields = (initialRelationship?.summaryFields || []).map(
+      (f) => f.id
+    );
+    console.log("Current summaryFields before update:", currentSummaryFields);
+
+    const request: UpdateRelationshipRequest = {
+      summaryFields: [
+        {
+          summaryFid: newChildFieldId!,
+          label: "Test Summary Field",
+          accumulationType: "SUM",
+        },
+      ],
+    };
+    console.log(
+      "Adding summary field request:",
+      JSON.stringify(request, null, 2)
+    );
+
+    const updateResponse = await client.updateRelationship({
+      tableId,
+      relationshipId,
+      body: request,
+    });
+    console.log("Update response:", JSON.stringify(updateResponse, null, 2));
+
+    const newSummary = updateResponse.summaryFields.find(
+      (f) =>
+        f.label.includes("Test Summary Field") &&
+        !currentSummaryFields.includes(f.id)
+    );
+    generatedSummaryFieldId = newSummary?.id;
+    console.log(
+      `Captured generated summary field ID: ${generatedSummaryFieldId}`
+    );
+
+    expect(updateResponse.id).toBe(relationshipId);
+    expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(
+      updateResponse.summaryFields.some((f) =>
+        f.label.includes("Test Summary Field")
+      )
+    ).toBe(true);
+  }, 30000);
+});