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

package/tests/vitest/qb/formulas/runFormula.test.ts

@@ -0,0 +1,96 @@
+// tests/vitest/qb/formulas/runFormula.test.ts
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import {
+  createClient,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+import {
+  RunFormulaRequest,
+  RunFormula200Response,
+  Upsert200Response,
+} from "@/generated/models";
+
+describe("QuickbaseClient Integration - runFormula", () => {
+  let client: ReturnType<typeof createClient>;
+  let testRecordId: number;
+
+  beforeAll(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");
+
+    // Initialize client with user token only
+    client = createClient(undefined, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    // Upsert a test record to ensure we have a valid rid
+    const upsertResponse: Upsert200Response = await client.upsert({
+      body: {
+        to: QB_TABLE_ID_1,
+        data: [
+          {
+            "6": { value: `Test Record ${Date.now()}` }, // Assuming field 6 is a text field (e.g., "Task Name")
+          },
+        ],
+        fieldsToReturn: [3], // Return Record ID# (field ID 3)
+      },
+    });
+
+    // Extract the created record ID
+    testRecordId = upsertResponse.data[0]["3"].value as number;
+    console.log(`Upserted test record with ID: ${testRecordId}`);
+  });
+
+  afterAll(async () => {
+    // Clean up the test record
+    if (testRecordId) {
+      await client.deleteRecords({
+        body: {
+          from: QB_TABLE_ID_1,
+          where: `{3.EX.${testRecordId}}`, // Delete by Record ID#
+        },
+      });
+      console.log(`Cleaned up test record with ID: ${testRecordId}`);
+    }
+  });
+
+  it("runs simple formula without rid and returns correct result", async () => {
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "1 + 1", // Simple arithmetic to verify functionality
+    };
+
+    const response: RunFormula200Response = await client.runFormula({
+      body: request,
+    });
+
+    console.log("Real API response (no rid):", response);
+
+    expect(response).toHaveProperty("result");
+    expect(response.result).toBe("2"); // Expect "2" as a string
+  }, 10000);
+
+  it("runs formula with rid and field ID 3, returns correct numeric result", async () => {
+    const request: RunFormulaRequest = {
+      from: QB_TABLE_ID_1,
+      formula: "Sum([Record ID#], 20)", // Field ID 3 is "Record ID#"
+      rid: testRecordId, // Use the upserted record ID
+    };
+
+    const response: RunFormula200Response = await client.runFormula({
+      body: request,
+    });
+
+    console.log("Real API response (with rid):", response);
+
+    expect(response).toHaveProperty("result");
+    expect(response.result).toBe(String(testRecordId + 20)); // Dynamic result based on the record ID
+  }, 10000);
+});

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

@@ -0,0 +1,102 @@
+// tests/vitest/qb/tables/createRelationship.test.ts
+
+import { test, expect } from "vitest";
+import { quickbase } from "/home/drew/Projects/quickbase-js/src/quickbaseClient";
+import {
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+  QB_TABLE_ID_2,
+} from "/home/drew/Projects/quickbase-js/tests/setup.ts";
+
+test(
+  "QuickbaseClient Integration - createRelationship > creates a new relationship in QuickBase",
+  { timeout: 60000 }, // 60 seconds for create and delete
+  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
+    const client = quickbase({
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    // Define the relationship creation request
+    const uniqueLabel = `TestRelationship_${Date.now()}`;
+    const requestBody = {
+      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("Config used:", {
+      realm: QB_REALM,
+      userToken: "[REDACTED]",
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+    });
+    console.log("Creating relationship with:", requestBody);
+
+    // Create the relationship
+    const response = await client.createRelationship({
+      tableId: QB_TABLE_ID_2,
+      body: requestBody,
+    });
+
+    console.log("Real API response:", JSON.stringify(response, null, 2));
+
+    // Assertions for creation
+    expect(response).toBeDefined();
+    expect(response.id).toBeDefined();
+    expect(response.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(response.childTableId).toBe(QB_TABLE_ID_2);
+    expect(response.foreignKeyField).toBeDefined();
+    expect(response.foreignKeyField?.label).toBe(uniqueLabel);
+    expect(response.lookupFields).toHaveLength(1);
+    expect(response.lookupFields[0].id).toBeGreaterThan(0);
+    expect(response.summaryFields).toHaveLength(1);
+    expect(response.summaryFields[0].label).toBe(`Sum_${uniqueLabel}`);
+
+    // Cleanup: Delete the relationship
+    const relationshipId = response.id;
+    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)
+    );
+
+    // Verify deletion
+    expect(deleteResponse).toBeDefined();
+    expect(deleteResponse.relationshipId).toBe(relationshipId);
+
+    // Confirm relationship is gone
+    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(); // Should no longer exist
+  }
+);

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

@@ -0,0 +1,143 @@
+// tests/vitest/qb/tables/deleteRelationship.test.ts
+
+import { test, expect } from "vitest";
+import { quickbase } from "/home/drew/Projects/quickbase-js/src/quickbaseClient";
+import {
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+  QB_TABLE_ID_2,
+} from "/home/drew/Projects/quickbase-js/tests/setup.ts";
+
+test(
+  "QuickbaseClient Integration - deleteRelationship > creates and deletes a relationship in QuickBase",
+  { timeout: 60000 }, // 60 seconds for two API calls
+  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
+    const client = quickbase({
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
+    });
+
+    // Step 1: Create a 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("Config used:", {
+      realm: QB_REALM,
+      userToken: "[REDACTED]",
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+    });
+    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)
+    );
+
+    // Verify creation
+    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).toBeDefined();
+    expect(createResponse.foreignKeyField?.label).toBe(uniqueLabel);
+
+    const relationshipId = createResponse.id;
+    const foreignKeyFieldId = createResponse.foreignKeyField?.id;
+
+    // Step 2: 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)
+    );
+
+    // Verify deletion (adjusted to match actual response)
+    expect(deleteResponse).toBeDefined();
+    expect(deleteResponse.relationshipId).toBe(relationshipId); // Updated to use "relationshipId"
+
+    // Step 3: Confirm relationship is gone (or non-functional)
+    try {
+      const relationships = await client.getRelationships({
+        tableId: QB_TABLE_ID_2,
+      });
+      console.log(
+        "Relationships after deletion:",
+        JSON.stringify(relationships, null, 2)
+      );
+      // Check if the relationship is still listed (metadata might persist)
+      const deletedRelationship = relationships.relationships.find(
+        (r) => r.id === relationshipId
+      );
+      if (deletedRelationship) {
+        console.log("Relationship metadata persists:", deletedRelationship);
+        expect(deletedRelationship.foreignKeyField).toBeUndefined(); // Should lack fields
+      }
+    } catch (error) {
+      console.error("Error fetching relationships post-deletion:", error);
+      expect(error.message).toMatch(/404|not found/i); // Optional stricter check
+    }
+
+    // Cleanup remaining fields
+    const lookupFieldId = createResponse.lookupFields[0]?.id;
+    const summaryFieldId = createResponse.summaryFields[0]?.id;
+
+    if (foreignKeyFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_2,
+        body: { fieldIds: [foreignKeyFieldId] },
+      });
+      console.log(
+        `Deleted foreign key field ${foreignKeyFieldId} from ${QB_TABLE_ID_2}`
+      );
+    }
+    if (lookupFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_2,
+        body: { fieldIds: [lookupFieldId] },
+      });
+      console.log(
+        `Deleted lookup field ${lookupFieldId} from ${QB_TABLE_ID_2}`
+      );
+    }
+    if (summaryFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [summaryFieldId] },
+      });
+      console.log(
+        `Deleted summary field ${summaryFieldId} from ${QB_TABLE_ID_1}`
+      );
+    }
+  }
+);

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