quickbase-js 0.1.0-beta.10

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

@@ -0,0 +1,50 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - deleteTable > deletes a table in QuickBase",
+  { timeout: 20000 },
+  async () => {
+    const config = {
+      realm: process.env.QB_REALM || "",
+      userToken: process.env.QB_USER_TOKEN || "",
+      debug: true,
+    };
+    const client = quickbase(config);
+    const appId = "buwai2zpe";
+
+    // Step 1: Create a temporary table to delete
+    const tableName = `DeleteTest_${Date.now()}`;
+    const createBody = {
+      name: tableName,
+      description: "Temporary table for delete test",
+      singleRecordName: "DeleteTest",
+      pluralRecordName: "DeleteTests",
+    };
+    console.log("Creating temporary table with:", createBody);
+    const createResponse = await client.createTable({
+      appId,
+      body: createBody,
+    });
+    expect(createResponse.id).toBeDefined();
+    expect(createResponse.name).toBe(tableName);
+    console.log("Created table:", createResponse);
+    const tableId = createResponse.id;
+
+    // Step 2: Delete the table
+    console.log("Deleting table:", { tableId, appId });
+    const deleteResponse = await client.deleteTable({ tableId, appId });
+    expect(deleteResponse).toBeDefined();
+    expect(deleteResponse.deletedTableId).toBe(tableId);
+    console.log("Delete API response:", deleteResponse);
+
+    // Step 3: Verify the table is gone
+    try {
+      await client.getTable({ tableId, appId });
+      throw new Error("Table should not exist after deletion");
+    } catch (error) {
+      expect(error.message).toMatch(/404|not found/i); // Expect a 404 error
+      console.log("Verified table deletion:", error.message);
+    }
+  }
+);

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

@@ -0,0 +1,46 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getAppTables > fetches real table data 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 tablesAppId = "buwai2zpe";
+
+    console.log("Config used:", config);
+    const result = await client.getAppTables({ appId: tablesAppId });
+    console.log("Real API response:", result);
+
+    expect(result).toBeDefined();
+    expect(result).toBeInstanceOf(Array);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "buwai2zr4",
+          alias: "_DBID_ROOT",
+          name: expect.any(String), // Allow dynamic name due to updateTable
+          description: expect.any(String), // Allow dynamic description
+          created: expect.any(Date),
+          updated: expect.any(Date), // Allow varying timestamps
+          nextRecordId: expect.any(Number),
+          nextFieldId: expect.any(Number),
+          defaultSortFieldId: expect.any(Number),
+          defaultSortOrder: "DESC",
+          keyFieldId: expect.any(Number),
+          singleRecordName: "Root",
+          pluralRecordName: "Roots",
+          sizeLimit: "500 MB",
+          spaceUsed: expect.any(String),
+          spaceRemaining: "500 MB",
+        }),
+      ])
+    );
+  }
+);

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

@@ -0,0 +1,80 @@
+// tests/vitest/qb/tables/getRelationships.test.ts
+import { describe, test, expect } from "vitest";
+import { quickbase } from "/home/drew/Projects/quickbase-js/src/quickbaseClient.ts";
+import { QB_TABLE_ID_1 } from "/home/drew/Projects/quickbase-js/tests/setup.ts";
+import { GetRelationships200Response } from "/home/drew/Projects/quickbase-js/src/generated/models";
+
+describe("QuickbaseClient Integration - getRelationships", () => {
+  const qb = quickbase({
+    realm: process.env.QB_REALM || "builderprogram-dbradford6815",
+    userToken: process.env.QB_USER_TOKEN || "",
+    debug: true,
+  });
+
+  test("fetches real relationships from QuickBase", async () => {
+    // Ensure environment variables are set
+    if (!process.env.QB_REALM)
+      throw new Error("QB_REALM is not defined in .env");
+    if (!process.env.QB_USER_TOKEN)
+      throw new Error("QB_USER_TOKEN is not defined in .env");
+
+    console.log("Config used:", {
+      realm: process.env.QB_REALM,
+      userToken: process.env.QB_USER_TOKEN,
+      tableId: QB_TABLE_ID_1,
+    });
+
+    const response: GetRelationships200Response = await qb.getRelationships({
+      tableId: QB_TABLE_ID_1, // Query relationships for QB_TABLE_ID_1 (e.g., "buwai2zws")
+      skip: 0,
+    });
+
+    console.log("Real API response:", JSON.stringify(response, null, 2));
+
+    // Basic structure validation
+    expect(response).toBeDefined();
+    expect(response.metadata).toBeDefined();
+    expect(response.metadata).toHaveProperty(
+      "numRelationships",
+      expect.any(Number)
+    );
+    expect(response.metadata).toHaveProperty("skip", 0);
+    expect(response.metadata).toHaveProperty(
+      "totalRelationships",
+      expect.any(Number)
+    );
+    expect(response.relationships).toBeDefined();
+    expect(Array.isArray(response.relationships)).toBe(true);
+
+    // If relationships exist, validate the first one
+    if (response.relationships.length > 0) {
+      const relationship = response.relationships[0];
+      expect(relationship).toHaveProperty("id", expect.any(Number));
+      expect(relationship).toHaveProperty("parentTableId", expect.any(String));
+      expect(relationship).toHaveProperty("childTableId", QB_TABLE_ID_1);
+      expect(relationship).toHaveProperty("foreignKeyField");
+      expect(relationship.foreignKeyField).toHaveProperty(
+        "id",
+        expect.any(Number)
+      );
+      expect(relationship.foreignKeyField).toHaveProperty(
+        "label",
+        expect.any(String)
+      );
+      expect(relationship.foreignKeyField).toHaveProperty(
+        "type",
+        expect.any(String)
+      );
+      expect(relationship).toHaveProperty("isCrossApp", expect.any(Boolean));
+      expect(relationship).toHaveProperty("lookupFields", expect.any(Array));
+
+      // summaryFields is optional; only validate if present
+      if (
+        "summaryFields" in relationship &&
+        relationship.summaryFields !== undefined
+      ) {
+        expect(Array.isArray(relationship.summaryFields)).toBe(true);
+      }
+    }
+  }, 10000); // Timeout as second argument
+});

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

@@ -0,0 +1,26 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getTable > fetches real table data 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 tableId = "buwai2zr4";
+    const appId = "buwai2zpe";
+
+    console.log("Config used:", config);
+    const response = await client.getTable({ tableId, appId });
+    expect(response).toBeDefined();
+    expect(response.id).toBe(tableId);
+    expect(response.name).toBe("Root"); // Expect original name
+    expect(response.alias).toBe("_DBID_ROOT");
+    expect(response.created).toBeInstanceOf(Date);
+    console.log("Real API response:", response);
+  }
+);

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

@@ -0,0 +1,250 @@
+// tests/vitest/qb/tables/updateRelationship.test.ts
+
+import { describe, it, expect } 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;
+
+  // No beforeAll/afterAll since we'll create and delete within the test
+
+  it("creates, updates, deletes, and verifies a relationship", async () => {
+    // Validate environment variables
+    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");
+    if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+    if (!QB_TABLE_ID_2) throw new Error("QB_TABLE_ID_2 is not defined in .env");
+
+    // Initialize client
+    client = createClient(fetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    // Step 1: Create fields for the relationship update
+    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}`
+    );
+
+    // Step 2: Create a new relationship
+    const uniqueLabel = `TestRelationship_${Date.now()}`;
+    const createRequestBody = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: uniqueLabel },
+      lookupFieldIds: [6], // Assuming field 6 exists in QB_TABLE_ID_1
+      summaryFields: [
+        {
+          summaryFid: 6, // Assuming field 6 in QB_TABLE_ID_2 is numeric
+          label: `Sum_${uniqueLabel}`,
+          accumulationType: "SUM",
+        },
+      ],
+    };
+
+    console.log("Creating relationship with:", createRequestBody);
+    const createResponse = await client.createRelationship({
+      tableId: QB_TABLE_ID_2,
+      body: createRequestBody,
+    });
+    console.log(
+      "Created relationship response:",
+      JSON.stringify(createResponse, null, 2)
+    );
+
+    expect(createResponse).toBeDefined();
+    expect(createResponse.id).toBeDefined();
+    expect(createResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(createResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(createResponse.foreignKeyField?.label).toBe(uniqueLabel);
+
+    relationshipId = createResponse.id;
+
+    // Step 3: Update the relationship - Add a lookup field
+    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 updateLookupRequest: UpdateRelationshipRequest = {
+      lookupFieldIds: [newLookupFieldId!],
+    };
+    console.log(
+      "Adding lookup field request:",
+      JSON.stringify(updateLookupRequest, null, 2)
+    );
+
+    const updateLookupResponse = await client.updateRelationship({
+      tableId,
+      relationshipId,
+      body: updateLookupRequest,
+    });
+    console.log(
+      "Update lookup response:",
+      JSON.stringify(updateLookupResponse, null, 2)
+    );
+
+    const newLookup = updateLookupResponse.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(updateLookupResponse.id).toBe(relationshipId);
+    expect(updateLookupResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateLookupResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(
+      updateLookupResponse.lookupFields.some((f) =>
+        f.label.includes("Test Lookup Field")
+      )
+    ).toBe(true);
+
+    // Step 4: Update the relationship - Add a summary field
+    const currentSummaryFields = (updateLookupResponse.summaryFields || []).map(
+      (f) => f.id
+    );
+    console.log("Current summaryFields before update:", currentSummaryFields);
+
+    const updateSummaryRequest: UpdateRelationshipRequest = {
+      summaryFields: [
+        {
+          summaryFid: newChildFieldId!,
+          label: "Test Summary Field",
+          accumulationType: "SUM",
+        },
+      ],
+    };
+    console.log(
+      "Adding summary field request:",
+      JSON.stringify(updateSummaryRequest, null, 2)
+    );
+
+    const updateSummaryResponse = await client.updateRelationship({
+      tableId,
+      relationshipId,
+      body: updateSummaryRequest,
+    });
+    console.log(
+      "Update summary response:",
+      JSON.stringify(updateSummaryResponse, null, 2)
+    );
+
+    const newSummary = updateSummaryResponse.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(updateSummaryResponse.id).toBe(relationshipId);
+    expect(updateSummaryResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateSummaryResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(
+      updateSummaryResponse.summaryFields.some((f) =>
+        f.label.includes("Test Summary Field")
+      )
+    ).toBe(true);
+
+    // Step 5: Delete the relationship
+    console.log("Deleting relationship with ID:", relationshipId);
+    const deleteResponse = await client.deleteRelationship({
+      tableId: QB_TABLE_ID_2,
+      relationshipId,
+    });
+    console.log(
+      "Delete relationship response:",
+      JSON.stringify(deleteResponse, null, 2)
+    );
+
+    expect(deleteResponse).toBeDefined();
+    expect(deleteResponse.relationshipId).toBe(relationshipId);
+
+    // Step 6: Verify deletion
+    const relationships = await client.getRelationships({
+      tableId: QB_TABLE_ID_2,
+    });
+    console.log(
+      "Relationships after deletion:",
+      JSON.stringify(relationships, null, 2)
+    );
+    const deletedRelationship = relationships.relationships.find(
+      (r) => r.id === relationshipId
+    );
+    expect(deletedRelationship).toBeUndefined(); // Confirm relationship is gone
+
+    // Cleanup remaining fields from setup
+    if (newLookupFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [newLookupFieldId] },
+      });
+      console.log(
+        `Deleted lookup field ${newLookupFieldId} from ${QB_TABLE_ID_1}`
+      );
+    }
+    if (newChildFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_2,
+        body: { fieldIds: [newChildFieldId] },
+      });
+      console.log(
+        `Deleted child field ${newChildFieldId} from ${QB_TABLE_ID_2}`
+      );
+    }
+  }, 60000);
+});

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

@@ -0,0 +1,48 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - updateTable > updates real table 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";
+    const tableId = "buwai2zr4";
+    const updatedBody = {
+      name: "Root Updated " + Date.now(),
+      description: "Integration test update",
+    };
+    const originalBody = {
+      name: "Root",
+      description: "",
+    };
+
+    console.log("Config used:", config);
+    // Update the table
+    const response = await client.updateTable({
+      tableId,
+      appId,
+      body: updatedBody,
+    });
+    expect(response).toBeDefined();
+    expect(response.id).toBe(tableId);
+    expect(response.name).toBe(updatedBody.name);
+    expect(response.description).toBe(updatedBody.description);
+    console.log("Real API response:", response);
+
+    // Cleanup: Revert the table to original state
+    const cleanupResponse = await client.updateTable({
+      tableId,
+      appId,
+      body: originalBody,
+    });
+    expect(cleanupResponse.name).toBe(originalBody.name);
+    expect(cleanupResponse.description).toBe(originalBody.description);
+    console.log("Cleanup API response:", cleanupResponse);
+  }
+);

package/tests/vitest/unit/ThrottleBucket.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi } from "vitest";
+import { ThrottleBucket } from "@/ThrottleBucket"; // Adjust path as needed
+
+describe("ThrottleBucket Unit Tests", () => {
+  it("allows burst capacity immediately", async () => {
+    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const startTime = Date.now();
+
+    await Promise.all([bucket.acquire(), bucket.acquire(), bucket.acquire()]);
+
+    const duration = Date.now() - startTime;
+    expect(duration).toBeLessThan(50); // All 3 should be instant (within 50ms)
+  });
+
+  it("delays calls beyond burst at correct rate", async () => {
+    const bucket = new ThrottleBucket(5, 3); // rate: 5 tokens/sec, burst: 3
+    const timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all([
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(), // 4th call should delay
+    ]);
+
+    const durations = timings.map((t) => t - startTime);
+    expect(durations.length).toBe(4);
+    expect(durations[0]).toBeLessThan(50); // 1st call instant
+    expect(durations[1]).toBeLessThan(50); // 2nd call instant
+    expect(durations[2]).toBeLessThan(50); // 3rd call instant
+    expect(durations[3]).toBeGreaterThanOrEqual(180); // 4th call delayed ~200ms
+    expect(durations[3]).toBeLessThan(250); // Shouldn’t exceed 250ms
+  });
+
+  it("maintains rate over sustained calls", async () => {
+    const bucket = new ThrottleBucket(2, 2); // rate: 2 tokens/sec, burst: 2
+    const timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all([
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(), // 5 calls total
+    ]);
+
+    const durations = timings.map((t) => t - startTime);
+    expect(durations.length).toBe(5);
+    expect(durations[0]).toBeLessThan(50); // 1st instant
+    expect(durations[1]).toBeLessThan(50); // 2nd instant
+    expect(durations[2]).toBeGreaterThanOrEqual(450); // 3rd delayed ~500ms (1/2 sec)
+    expect(durations[2]).toBeLessThan(550);
+    expect(durations[3]).toBeGreaterThanOrEqual(950); // 4th delayed ~1000ms
+    expect(durations[3]).toBeLessThan(1050);
+    expect(durations[4]).toBeGreaterThanOrEqual(1450); // 5th delayed ~1500ms
+    expect(durations[4]).toBeLessThan(1550);
+  });
+
+  it("handles high concurrency without exceeding burst", async () => {
+    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all(
+      Array(10)
+        .fill(null)
+        .map(() => recordTime())
+    ); // 10 concurrent calls
+
+    const durations = timings.map((t) => t - startTime);
+    expect(durations.length).toBe(10);
+    // First 3 should be instant
+    expect(durations.slice(0, 3).every((d) => d < 50)).toBe(true);
+    // Next calls should be staggered at ~200ms intervals
+    for (let i = 3; i < 10; i++) {
+      const expectedDelay = (i - 2) * 200; // After burst, 200ms per token
+      expect(durations[i]).toBeGreaterThanOrEqual(expectedDelay - 50);
+      expect(durations[i]).toBeLessThan(expectedDelay + 50);
+    }
+  });
+});