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

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/mockQuickbaseServer.ts

@@ -0,0 +1,60 @@
+// tests/vitest/qb/auth/mockQuickbaseServer.ts
+import express from "express";
+
+export function startMockQuickbaseServer(port: number = 3000) {
+  const app = express();
+  app.use(express.json());
+  let failNextCall = false;
+
+  app.post("/v1/auth/oauth/token", (req, res) => {
+    const { subject_token } = req.body;
+    console.log("[Mock Server] Received SSO token request:", req.body);
+    if (!subject_token) {
+      return res.status(400).json({ message: "Missing SAML token" });
+    }
+    res.json({
+      access_token: "mock-temp-token",
+      token_type: "Bearer",
+    });
+  });
+
+  app.get("/v1/apps/:appId", (req, res) => {
+    const authHeader = req.headers.authorization;
+    console.log(
+      "[Mock Server] Received getApp request:",
+      req.params,
+      "Auth:",
+      authHeader
+    );
+    if (!authHeader || !authHeader.startsWith("QB-TEMP-TOKEN")) {
+      return res.status(401).json({ message: "Unauthorized" });
+    }
+    if (failNextCall) {
+      failNextCall = false;
+      return res.status(401).json({ message: "Token expired" });
+    }
+    res.json({
+      id: req.params.appId,
+      name: "Mock App",
+      created: "2025-03-19T12:00:00Z",
+      updated: "2025-03-19T12:00:00Z",
+    });
+  });
+
+  app.post("/mock/toggle-fail", (req, res) => {
+    failNextCall = true;
+    console.log("[Mock Server] Toggling next getApp call to fail with 401");
+    res.sendStatus(200);
+  });
+
+  const server = app.listen(port, () => {
+    console.log(`Mock QuickBase server running on port ${port}`);
+  });
+
+  return {
+    server,
+    close: () => server.close(),
+    toggleFail: () =>
+      fetch(`http://localhost:${port}/mock/toggle-fail`, { method: "POST" }),
+  };
+}

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

@@ -0,0 +1,73 @@
+import { describe, it, vi, expect, beforeEach } from "vitest";
+import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient";
+
+describe("QuickbaseClient Integration - User Token Retry on 401", () => {
+  let client: QuickbaseClient;
+
+  beforeEach(() => {
+    const userToken = process.env.QB_USER_TOKEN;
+    const realm = process.env.QB_REALM;
+    const tableId = process.env.QB_TABLE_ID_1; // Consistent env var name
+
+    if (!userToken) {
+      throw new Error(
+        "QB_USER_TOKEN environment variable is required for integration test"
+      );
+    }
+    if (!tableId) {
+      throw new Error(
+        "QB_TABLE_ID_1 environment variable is required for integration test"
+      );
+    }
+
+    const config = {
+      realm,
+      userToken,
+      debug: true,
+    };
+    console.log("[quickbaseTest] Config:", {
+      realm,
+      userToken: userToken.substring(0, 10) + "...",
+      tableId, // Log to confirm
+      debug: true,
+    });
+    client = quickbase(config);
+  });
+
+  it(
+    "successfully retrieves fields with user token, retrying on transient 401 if needed",
+    async () => {
+      const consoleSpy = vi.spyOn(console, "log");
+
+      const tableId = process.env.QB_TABLE_ID_1!; // Match beforeEach
+      let fields;
+      try {
+        fields = await client.getFields({ tableId });
+      } catch (error) {
+        console.error("[integrationTest] Failed to retrieve fields:", error);
+        throw error;
+      }
+
+      expect(fields).toBeInstanceOf(Array);
+      expect(fields.length).toBeGreaterThan(0);
+      expect(fields[0]).toHaveProperty("id");
+      expect(fields[0]).toHaveProperty("label");
+
+      console.log("[integrationTest] Fields retrieved:", fields.length);
+
+      const retryLog = consoleSpy.mock.calls.some((call) =>
+        call[0].includes("Retrying getFields with existing user token")
+      );
+      if (retryLog) {
+        console.log("[integrationTest] Retry on 401 detected");
+      } else {
+        console.log(
+          "[integrationTest] No 401 retries observed (expected if no transient failure)"
+        );
+      }
+
+      consoleSpy.mockRestore();
+    },
+    { timeout: 10000 }
+  );
+});

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

@@ -0,0 +1,65 @@
+// tests/vitest/qb/auth/ssoTokenIntegrationWithServer.test.ts
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest"; // Add 'vi' to imports
+import { quickbase } from "../../../../src/quickbaseClient";
+import { startMockQuickbaseServer } from "./mockQuickbaseServer";
+
+describe("QuickbaseClient Integration - SSO with Mock Server", () => {
+  let mockServer: ReturnType<typeof startMockQuickbaseServer>;
+  const mockBaseUrl = "http://localhost:3000";
+
+  beforeAll(async () => {
+    mockServer = startMockQuickbaseServer(3000);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    console.log("Server setup complete, port 3000 should be listening");
+  });
+
+  afterAll(() => {
+    mockServer.close();
+    console.log("Server closed");
+  });
+
+  it(
+    "uses SSO token from mock server and retries on 401",
+    { timeout: 10000 }, // Move timeout to second argument
+    async () => {
+      const consoleSpy = vi.spyOn(console, "log"); // Spy on console.log to capture logs
+      const client = quickbase({
+        realm: "testrealm",
+        samlToken: "mock-saml-token",
+        useSso: true,
+        fetchApi: (url, options) => {
+          const rewrittenUrl = url.replace(
+            "https://api.quickbase.com/v1",
+            mockBaseUrl + "/v1"
+          );
+          console.log(
+            "[fetchApi] Requesting:",
+            rewrittenUrl,
+            "Options:",
+            options
+          );
+          return fetch(rewrittenUrl, options);
+        },
+        debug: true,
+      });
+
+      await mockServer.toggleFail();
+      const response = await client.getApp({ appId: "mockappid" });
+
+      expect(response).toBeDefined();
+      expect(response.id).toBe("mockappid");
+      expect(response.name).toBe("Mock App");
+
+      // Verify retry happened
+      const retryLog = consoleSpy.mock.calls.some((call) =>
+        call[0].includes(
+          "Authorization error for getApp (SSO), refreshing token"
+        )
+      );
+      expect(retryLog).toBe(true); // Ensure retry logic was triggered
+
+      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/getFieldUsage.test.ts

@@ -1,166 +1,72 @@
-// tests/vitest/qb/fields/getFieldUsage.test.ts
-import { describe, it, expect, afterAll } from "vitest";
-import {
-  createClient,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "../../../setup.ts";
+// tests/vitest/qb/fields/getFieldsUsage.test.ts
+
+import { describe, it, expect } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
 import { FieldUsage } from "@/generated/models";
 
-describe("QuickbaseClient Integration - getFieldUsage", () => {
+describe("QuickbaseClient Integration - getFieldsUsage", () => {
   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, retrieves its usage statistics, and deletes it",
-    async () => {
-      // Step 1: Create a field
-      const uniqueLabel = `TestField_${Date.now()}`;
-      console.log("Creating field with label:", uniqueLabel);
-      const createResponse = await client.createField({
-        tableId: QB_TABLE_ID_1,
-        body: {
-          label: uniqueLabel,
-          fieldType: "text",
-          fieldHelp: "Created for getFieldUsage integration test",
-          addToForms: true,
-        },
-      });
-
-      expect(createResponse.id).toBeDefined();
-      const fieldId = createResponse.id;
-      createdFieldIds.push(fieldId);
-      console.log(`Created field ${uniqueLabel} with ID ${fieldId}`);
-
-      // Brief delay to ensure field is registered
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
-      // Step 2: Get field usage with raw response logging
-      console.log("Fetching field usage for:", {
-        tableId: QB_TABLE_ID_1,
-        fieldId,
-      });
-      const rawResponse = await fetch(
-        `https://api.quickbase.com/v1/fields/usage/${fieldId}?tableId=${QB_TABLE_ID_1}`,
-        {
-          method: "GET",
-          headers: {
-            "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-            Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-            "Content-Type": "application/json",
-          },
-        }
-      );
-      const rawBody = await rawResponse.text();
-      console.log("Raw API response:", {
-        status: rawResponse.status,
-        statusText: rawResponse.statusText,
-        body: rawBody,
-      });
-
-      const responseArray: FieldUsage[] = await client.getFieldUsage({
-        fieldId,
-        tableId: QB_TABLE_ID_1,
-      });
-      console.log("Parsed API response (array):", responseArray);
 
-      // Validate response structure (unwrap the array)
-      expect(responseArray).toBeDefined();
-      expect(responseArray).toHaveLength(1); // Expect a single-item array
-      const response = responseArray[0];
-
-      expect(response).toBeDefined();
-      expect(response.field).toHaveProperty("id", fieldId);
-      expect(response.field).toHaveProperty("name", uniqueLabel);
-      expect(response.field).toHaveProperty("type", "text");
-      expect(typeof response.field.name).toBe("string");
-      expect(typeof response.field.type).toBe("string");
+  it("retrieves field usage statistics for a valid table", async () => {
+    console.log("Starting retrieval of full field usage list");
+    const response = await client.getFieldsUsage({
+      tableId: QB_TABLE_ID_1,
+    });
 
-      expect(response.usage).toBeDefined();
-      expect(typeof response.usage).toBe("object");
-      expect(response.usage).toHaveProperty("actions");
-      expect(response.usage.actions).toHaveProperty("count");
-      expect(typeof response.usage.actions.count).toBe("number");
-      expect(response.usage).toHaveProperty("appHomePages");
-      expect(response.usage).toHaveProperty("dashboards");
-      expect(response.usage).toHaveProperty("defaultReports");
-      expect(response.usage).toHaveProperty("exactForms");
-      expect(response.usage).toHaveProperty("fields");
-      expect(response.usage).toHaveProperty("forms");
-      expect(response.usage).toHaveProperty("notifications");
-      expect(response.usage).toHaveProperty("personalReports");
-      expect(response.usage).toHaveProperty("pipelines");
-      expect(response.usage).toHaveProperty("relationships");
-      expect(response.usage).toHaveProperty("reminders");
-      expect(response.usage).toHaveProperty("reports");
-      expect(response.usage).toHaveProperty("roles");
-      expect(response.usage).toHaveProperty("tableImports");
-      expect(response.usage).toHaveProperty("tableRules");
-      expect(response.usage).toHaveProperty("webhooks");
+    expect(response).toBeInstanceOf(Array);
+    expect(response.length).toBeGreaterThan(0); // Assumes the table has fields
+    response.forEach((usage: FieldUsage) => {
+      expect(usage.field).toHaveProperty("id");
+      expect(usage.field).toHaveProperty("name");
+      expect(usage.field).toHaveProperty("type");
+      expect(usage.usage).toHaveProperty("actions");
+      expect(usage.usage.actions).toHaveProperty("count");
+      expect(typeof usage.usage.actions.count).toBe("number");
+      expect(usage.usage).toHaveProperty("dashboards");
+      expect(usage.usage).toHaveProperty("forms");
+      expect(usage.usage).toHaveProperty("reports");
+    });
+    console.log(
+      `Retrieved ${response.length} field usage entries for table ${QB_TABLE_ID_1}`
+    );
+  }, 15000); // 15-second timeout
 
-      // Since it’s a new field, expect minimal usage
-      expect(response.usage.forms.count).toBeGreaterThanOrEqual(0); // May be 1 if addToForms worked
-    },
-    { timeout: 30000 } // 30-second timeout for create + get + delete
-  );
+  it("retrieves field usage with skip and top parameters", async () => {
+    console.log(
+      "Starting retrieval of full field usage list for skip/top test"
+    );
+    const fullResponse = await client.getFieldsUsage({
+      tableId: QB_TABLE_ID_1,
+    });
+    console.log(`Full list retrieved: ${fullResponse.length} fields`);
 
-  it("fails with non-existent field ID", { timeout: 15000 }, async () => {
-    const nonExistentFieldId = 999999;
+    const totalFields = fullResponse.length;
+    if (totalFields <= 1) {
+      console.log("Skipping skip/top test: table has too few fields");
+      return; // Skip if not enough fields to test pagination
+    }
 
-    console.log("Attempting to fetch usage for non-existent field:", {
+    console.log("Starting retrieval with skip=1 and top=1");
+    const response = await client.getFieldsUsage({
       tableId: QB_TABLE_ID_1,
-      fieldId: nonExistentFieldId,
-    });
-    await expect(
-      client.getFieldUsage({
-        fieldId: nonExistentFieldId,
-        tableId: QB_TABLE_ID_1,
-      })
-    ).rejects.toMatchObject({
-      message: expect.stringContaining(
-        "API Error: No such field (Status: 404)"
-      ),
+      skip: 1,
+      top: 1,
     });
 
+    expect(response).toBeInstanceOf(Array);
+    expect(response.length).toBe(1); // Should return exactly 1 field
+    expect(response[0].field.id).not.toBe(fullResponse[0].field.id); // Should skip the first field
     console.log(
-      `Confirmed 404 for non-existent field ID ${nonExistentFieldId}`
+      `Retrieved ${response.length} field usage entries with skip=1 and top=1`
     );
-  });
+  }, 15000); // 15-second timeout
 
-  it("fails with invalid table ID", { timeout: 15000 }, async () => {
+  it("fails with invalid table ID", async () => {
     const invalidTableId = "invalid_dbid";
-    const fieldId = 6;
-
-    console.log("Attempting to fetch usage with invalid table ID:", {
-      tableId: invalidTableId,
-      fieldId,
-    });
+    console.log(`Starting retrieval with invalid table ID ${invalidTableId}`);
+    const startTime = Date.now();
     await expect(
-      client.getFieldUsage({
-        fieldId,
+      client.getFieldsUsage({
         tableId: invalidTableId,
       })
     ).rejects.toMatchObject({
@@ -168,7 +74,9 @@ describe("QuickbaseClient Integration - getFieldUsage", () => {
         "API Error: Access denied (Status: 401)"
       ),
     });
-
-    console.log(`Confirmed 401 for invalid table ID ${invalidTableId}`);
-  });
+    const duration = Date.now() - startTime;
+    console.log(
+      `Confirmed 401 for invalid table ID ${invalidTableId} in ${duration}ms`
+    );
+  }, 30000); // Increased to 30-second timeout
 });

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;
+    }
+  });
+});