quickbase-js 0.1.0-beta.13 → 0.1.0-beta.14

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

@@ -1,73 +0,0 @@
-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/ssoTokenConcurrency.test.ts

@@ -1,68 +0,0 @@
-// tests/vitest/qb/auth/ssoTokenConcurrency.test.ts
-import { test, expect, vi } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-import { startMockQuickbaseServer } from "./mockQuickbaseServer";
-import { QB_APP_ID, QB_REALM } from "@tests/setup.ts";
-
-test(
-  "QuickbaseClient Integration - getApp with SsoTokenStrategy Concurrency",
-  async () => {
-    const mockServer = startMockQuickbaseServer(3000);
-
-    // Spy on console.log before any actions
-    const consoleSpy = vi.spyOn(console, "log");
-
-    try {
-      const client = quickbase({
-        realm: QB_REALM,
-        useSso: true,
-        samlToken: "mock-saml-token",
-        debug: true,
-        baseUrl: "http://localhost:3000/v1",
-      });
-
-      const concurrentRequests = [
-        client.getApp({ appId: QB_APP_ID }),
-        client.getApp({ appId: QB_APP_ID }),
-        client.getApp({ appId: QB_APP_ID }),
-      ];
-
-      const results = await Promise.all(concurrentRequests);
-
-      expect(results).toHaveLength(3);
-      results.forEach((result) =>
-        expect(result).toEqual({
-          id: QB_APP_ID,
-          name: "Mock App",
-          created: expect.any(Date),
-          updated: expect.any(Date),
-        })
-      );
-
-      // Verify token fetch and waits using console logs
-      const logs = consoleSpy.mock.calls;
-      const tokenFetchLogs = logs.filter((call) =>
-        call[0].includes("[fetchSsoToken] Fetched token")
-      );
-      expect(tokenFetchLogs).toHaveLength(1); // Single fetch with synchronization
-
-      const waitLogs = logs.filter((call) =>
-        call[0].includes("Waiting for existing SSO fetch")
-      );
-      expect(waitLogs.length).toBeGreaterThanOrEqual(2); // At least two waits
-
-      const appRequestLogs = logs.filter((call) =>
-        call[0].includes("Received getApp request")
-      );
-      expect(appRequestLogs).toHaveLength(3);
-
-      console.log(
-        "SsoTokenStrategy: Single token fetch with concurrent waits confirmed."
-      );
-    } finally {
-      mockServer.close();
-      consoleSpy.mockRestore();
-    }
-  },
-  { timeout: 20000 }
-);

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

@@ -1,65 +0,0 @@
-// 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/auth/userTokenConcurrency.test.ts

@@ -1,63 +0,0 @@
-// tests/vitest/qb/auth/userTokenConcurrency.test.ts
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - getApp with UserToken Concurrency",
-  async () => {
-    const realm = process.env.QB_REALM || "";
-    const appId = process.env.QB_APP_ID || "";
-    const userToken = process.env.QB_USER_TOKEN || "";
-
-    if (!realm || !appId || !userToken) {
-      throw new Error(
-        "QB_REALM, QB_APP_ID, and QB_USER_TOKEN must be set in .env"
-      );
-    }
-
-    const client = quickbase({
-      realm,
-      userToken,
-      debug: true,
-    });
-
-    const concurrentRequests = [
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-    ];
-
-    const results = await Promise.all(concurrentRequests);
-
-    const expectedAppData = {
-      id: appId,
-      name: "qb-copy",
-      created: expect.any(Date),
-      updated: expect.any(Date),
-      description: "",
-      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-      dateFormat: "MM-DD-YYYY",
-      hasEveryoneOnTheInternet: false,
-      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-      securityProperties: {
-        allowClone: false,
-        allowExport: true,
-        enableAppTokens: true,
-        hideFromPublic: false,
-        mustBeRealmApproved: false,
-        useIPFilter: false,
-      },
-      ancestorId: undefined,
-      dataClassification: undefined,
-      variables: [{ name: "TestVar", value: "TestValue" }],
-    };
-
-    expect(results).toHaveLength(3);
-    results.forEach((result) => expect(result).toEqual(expectedAppData));
-
-    console.log(
-      "UserTokenStrategy: All concurrent requests used static token."
-    );
-  },
-  { timeout: 20000 }
-);

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

@@ -1,77 +0,0 @@
-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)");
-  }, 10000); // Increased timeout to 10 seconds
-
-  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

@@ -1,83 +0,0 @@
-// 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 {
-      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;
-    }
-  });
-
-  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);
-    } catch (error) {
-      console.error("deleteFields failed:", error);
-      throw error;
-    }
-  });
-
-  it("handles partial success with errors", { timeout: 10000 }, 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;
-    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);
-    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

@@ -1,85 +0,0 @@
-// 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}`);
-  });
-});

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

@@ -1,82 +0,0 @@
-// 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 - getFieldsUsage", () => {
-  const client = createClient();
-
-  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).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
-
-  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`);
-
-    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("Starting retrieval with skip=1 and top=1");
-    const response = await client.getFieldsUsage({
-      tableId: QB_TABLE_ID_1,
-      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(
-      `Retrieved ${response.length} field usage entries with skip=1 and top=1`
-    );
-  }, 15000); // 15-second timeout
-
-  it("fails with invalid table ID", async () => {
-    const invalidTableId = "invalid_dbid";
-    console.log(`Starting retrieval with invalid table ID ${invalidTableId}`);
-    const startTime = Date.now();
-    await expect(
-      client.getFieldsUsage({
-        tableId: invalidTableId,
-      })
-    ).rejects.toMatchObject({
-      message: expect.stringContaining(
-        "API Error: Access denied (Status: 401)"
-      ),
-    });
-    const duration = Date.now() - startTime;
-    console.log(
-      `Confirmed 401 for invalid table ID ${invalidTableId} in ${duration}ms`
-    );
-  }, 30000); // Increased to 30-second timeout
-});