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

package/tests/vitest/qb/quickbase-js/FlowBucket.test.ts

@@ -1,77 +0,0 @@
-// tests/vitest/qb/ThrottleBucket.test.ts
-import { describe, it, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-describe("QuickbaseClient with ConcurrentThrottleBucket Integration Tests", () => {
-  it("handles concurrent API calls with burst and rate limiting in strict order", async () => {
-    const mockFetch = async (
-      url: string,
-      options: RequestInit
-    ): Promise<Response> => {
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      return new Response(JSON.stringify({ id: "mock-app" }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const qbClient = quickbase({
-      realm: "test",
-      userToken: "mock-token",
-      throttle: { rate: 5, burst: 3 },
-      fetchApi: mockFetch,
-      debug: true,
-    });
-
-    const throttleTimes: number[] = [];
-    const startTimes: number[] = new Array(6).fill(0);
-    const completionTimes: number[] = [];
-    const recordTime = async (index: number) => {
-      const preThrottle = Date.now();
-      throttleTimes[index] = preThrottle;
-      await qbClient.getApp({
-        appId: "mock-app-id",
-        startTime: startTimes[index],
-      });
-      completionTimes[index] = Date.now();
-      startTimes[index] = startTimes[index] || Date.now() - 500;
-    };
-
-    const startTime = Date.now();
-    const promises = [];
-    for (let i = 0; i < 6; i++) {
-      promises.push(recordTime(i));
-      await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-    await Promise.all(promises);
-
-    const relativeThrottleTimes = throttleTimes.map((t) => t - startTime);
-    const relativeStartTimes = startTimes.map((t) => t - startTime);
-    const durations = completionTimes.map((t) => t - startTime);
-    const timings = completionTimes.map((t, i) => t - startTimes[i]);
-
-    console.log("Relative Throttle Times:", relativeThrottleTimes);
-    console.log("Relative Start Times (post-throttle):", relativeStartTimes);
-    console.log("Durations (completion times):", durations);
-    console.log("Timings (fetch durations):", timings);
-    console.log("Total Duration:", Date.now() - startTime);
-
-    const totalDuration = Date.now() - startTime;
-    expect(totalDuration).toBeGreaterThanOrEqual(1000);
-    expect(totalDuration).toBeLessThan(1200); // Adjusted back to ~1100ms
-
-    expect(durations.length).toBe(6);
-    expect(durations.slice(0, 3).every((d) => d >= 500 && d < 550)).toBe(true);
-
-    // Sort durations to handle out-of-order completion
-    const sortedDurations = [...durations].sort((a, b) => a - b);
-    expect(sortedDurations[3]).toBeGreaterThanOrEqual(650);
-    expect(sortedDurations[3]).toBeLessThan(750);
-    expect(sortedDurations[4]).toBeGreaterThanOrEqual(850);
-    expect(sortedDurations[4]).toBeLessThan(950);
-    expect(sortedDurations[5]).toBeGreaterThanOrEqual(1050);
-    expect(sortedDurations[5]).toBeLessThan(1150);
-
-    expect(timings.every((t) => t >= 500 && t < 550)).toBe(true);
-  });
-});

package/tests/vitest/qb/quickbase-js/paginationSkip.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect, beforeAll } from "vitest";
-import {
-  createClient,
-  QB_TABLE_ID_1,
-  QB_REALM,
-  QB_USER_TOKEN,
-} from "@tests/setup";
-import { QuickbaseClient } from "@/quickbaseClient";
-import {
-  RunQueryRequest,
-  RunQueryRequestOptions,
-  RunQuery200Response,
-} from "@/generated/models";
-
-// Extend RunQueryRequestOptions to include sortBy (for reference, not used here)
-interface ExtendedRunQueryRequestOptions extends RunQueryRequestOptions {
-  sortBy?: Array<{ fieldId: number; order: "ASC" | "DESC" }>;
-}
-
-describe("QuickbaseClient Integration - Pagination with Skip", () => {
-  let qb: QuickbaseClient;
-
-  beforeAll(() => {
-    qb = createClient(undefined, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-      autoPaginate: true, // Enable library's automatic pagination
-    });
-    console.log("[beforeAll] Client initialized");
-  });
-
-  it(
-    "fetches full dataset with auto-pagination and heavy data",
-    { timeout: 30000 }, // 30s for multiple calls
-    async () => {
-      const queryOptions: ExtendedRunQueryRequestOptions = {
-        skip: 0, // Start at beginning, no top specified
-        // sortBy removed to test without ordering
-      };
-
-      const queryRequest: RunQueryRequest = {
-        from: QB_TABLE_ID_1,
-        select: [3, 822, 823, 824, 825, 6], // FID 3 for Record ID
-        options: queryOptions,
-      };
-
-      const startTime = Date.now();
-      console.log(
-        "[Test Start] Query request with auto-pagination:",
-        queryRequest
-      );
-
-      try {
-        const response = (await qb.runQuery({
-          body: queryRequest,
-        })) as RunQuery200Response & {
-          data: Array<{ [key: string]: { value: any } }>;
-          metadata: {
-            totalRecords: number;
-            numRecords: number;
-            numFields: number;
-            skip: number;
-            top?: number;
-          };
-        };
-
-        const duration = Date.now() - startTime;
-        console.log(`[Test Complete] Response received in ${duration}ms`, {
-          recordCount: response.data.length,
-          totalRecords: response.metadata.totalRecords,
-          defaultTop: response.metadata.top,
-        });
-
-        // Assertions
-        expect(response.data).toBeDefined();
-        expect(response.data.length).toBeGreaterThan(2429); // More than initial cap, confirming pagination
-        expect(response.data.length).toEqual(response.metadata.totalRecords); // Full dataset fetched
-        expect(response.metadata).toBeDefined();
-        // Removed expect(response.metadata.totalRecords).toBe(5000)
-        expect(response.metadata.totalRecords).toBeGreaterThanOrEqual(5000); // Flexible minimum, allows growth
-        expect(response.metadata.numFields).toBe(6); // 6 fields with FID 3
-        expect(response.metadata.skip).toBe(0); // Initial skip
-
-        const sampleRecord = response.data[0];
-        console.log("[Debug] Sample record:", sampleRecord);
-        expect(sampleRecord["6"]?.value).toBeDefined();
-        expect(typeof sampleRecord["6"]?.value).toBe("string");
-        expect(sampleRecord["6"]?.value.length).toBeGreaterThan(9000); // ~10KB
-        expect(sampleRecord["3"]?.value).toBeDefined(); // Check FID 3 exists
-        expect(typeof sampleRecord["3"]?.value).toBe("number"); // Record ID is numeric
-
-        // Check for duplicates using Record ID (FID 3)
-        const recordIds = response.data.map(
-          (record: { [key: string]: { value: any } }) => record["3"]?.value
-        );
-        const uniqueRecordIds = new Set(recordIds);
-        expect(uniqueRecordIds.size).toEqual(response.data.length); // No duplicates
-        expect(uniqueRecordIds.size).toEqual(response.metadata.totalRecords); // All records unique
-
-        console.log(
-          `[Integration Test] Fetched ${response.data.length} records in ${duration}ms, totalRecords: ${response.metadata.totalRecords}`
-        );
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        console.error("[Test Error] Failed after", duration, "ms:", error);
-        throw error;
-      }
-    }
-  );
-});

package/tests/vitest/qb/records/deleteRecords.test.ts

@@ -1,110 +0,0 @@
-// tests/vitest/qb/records/deleteRecords.test.ts
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { quickbase } from "@/quickbaseClient.ts";
-import {
-  Upsert200Response,
-  Upsert207Response,
-} from "/home/drew/Projects/quickbase-js/src/generated/models";
-
-const TABLE_ID = "buwai2zws";
-const UNIQUE_FIELD_ID = 3; // Record ID field
-const MARKER_FIELD_ID = 6; // Text field for marking test records
-
-describe("QuickbaseClient - DeleteRecords Integration", () => {
-  const qb = quickbase({
-    realm: "builderprogram-dbradford6815",
-    userToken: process.env.QB_USER_TOKEN,
-    debug: true,
-  });
-
-  beforeEach(async () => {
-    try {
-      await qb.deleteRecords({
-        body: {
-          from: TABLE_ID,
-          where: `{${MARKER_FIELD_ID}.CT.'test-marker-delete'}`,
-        },
-      });
-    } catch (e) {
-      // Ignore if no records exist
-    }
-  });
-
-  afterEach(async () => {
-    try {
-      await qb.deleteRecords({
-        body: {
-          from: TABLE_ID,
-          where: `{${MARKER_FIELD_ID}.CT.'test-marker-delete'}`,
-        },
-      });
-    } catch (e) {}
-  });
-
-  test(
-    "deletes a newly upserted record",
-    async () => {
-      const upsertResponse: Upsert200Response | Upsert207Response =
-        await qb.upsert({
-          body: {
-            to: TABLE_ID,
-            data: [{ [MARKER_FIELD_ID]: { value: "test-marker-delete" } }],
-            fieldsToReturn: [UNIQUE_FIELD_ID], // Return record ID
-          },
-        });
-
-      // Check metadata and createdRecordIds
-      expect(
-        upsertResponse.metadata,
-        "Expected metadata to be defined"
-      ).toBeDefined();
-      expect(
-        upsertResponse.metadata?.createdRecordIds,
-        "Expected createdRecordIds to be defined"
-      ).toBeDefined();
-
-      const createdRecordIds = upsertResponse.metadata?.createdRecordIds;
-      if (!createdRecordIds || createdRecordIds.length === 0) {
-        throw new Error("Expected at least one created record ID");
-      }
-
-      const recordId = createdRecordIds[0];
-      expect(recordId, "Expected recordId to be defined").toBeDefined();
-
-      // Check data
-      expect(upsertResponse.data, "Expected data to be defined").toBeDefined();
-      if (!upsertResponse.data || upsertResponse.data.length === 0) {
-        throw new Error("Expected at least one data entry");
-      }
-
-      const recordData = upsertResponse.data[0];
-      expect(
-        recordData[UNIQUE_FIELD_ID]?.value,
-        "Expected record ID in data to match created record ID"
-      ).toBe(recordId);
-
-      const deleteResponse = await qb.deleteRecords({
-        body: { from: TABLE_ID, where: `{${UNIQUE_FIELD_ID}.EX.${recordId}}` },
-      });
-
-      expect(deleteResponse).toEqual({ numberDeleted: 1 });
-
-      const checkResponse = await qb.deleteRecords({
-        body: { from: TABLE_ID, where: `{${UNIQUE_FIELD_ID}.EX.${recordId}}` },
-      });
-      expect(checkResponse.numberDeleted).toBe(0);
-    },
-    { timeout: 10000 }
-  );
-
-  test(
-    "handles empty result when no records match",
-    async () => {
-      const response = await qb.deleteRecords({
-        body: { from: TABLE_ID, where: "{3.EX.'999999'}" },
-      });
-      expect(response).toEqual({ numberDeleted: 0 });
-    },
-    { timeout: 10000 }
-  );
-});

package/tests/vitest/qb/records/runQuery.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
-import {
-  RunQueryRequest,
-  RunQueryResponse,
-  Upsert200Response,
-  Upsert207Response,
-} from "@/generated/models";
-
-// Define a type for field data with a value property (matches generated Record type)
-interface FieldData {
-  value: any; // Adjust type based on your needs (e.g., string | number)
-}
-
-describe("QuickbaseClient Integration - runQuery", () => {
-  let createdRecordId: number;
-
-  it(
-    "queries real records from QuickBase",
-    async () => {
-      const client = createClient();
-
-      // Upsert a test record to query later
-      const upsertResponse: Upsert200Response | Upsert207Response =
-        await client.upsert({
-          body: {
-            to: QB_TABLE_ID_1,
-            data: [
-              {
-                "6": { value: "Test Task " + Date.now() }, // Assuming field 6 is a text field
-              },
-            ],
-            fieldsToReturn: [3, 6], // Record ID# and the text field
-          },
-        });
-
-      // Check metadata and createdRecordIds with null safety
-      expect(
-        upsertResponse.metadata,
-        "Expected metadata to be defined"
-      ).toBeDefined();
-      expect(
-        upsertResponse.metadata?.createdRecordIds,
-        "Expected createdRecordIds to be defined"
-      ).toBeDefined();
-
-      const createdRecordIds = upsertResponse.metadata?.createdRecordIds;
-      if (!createdRecordIds || createdRecordIds.length === 0) {
-        throw new Error("Expected at least one created record ID from upsert");
-      }
-
-      createdRecordId = createdRecordIds[0];
-      expect(
-        createdRecordId,
-        "Expected createdRecordId to be defined"
-      ).toBeDefined();
-      console.log("Created test record with ID:", createdRecordId);
-
-      // Query the record
-      const queryRequest: RunQueryRequest = {
-        from: QB_TABLE_ID_1,
-        select: [3, 6], // Query Record ID# and the text field
-        where: `{3.EX.${createdRecordId}}`, // Filter by the created record
-        sortBy: [{ fieldId: 6, order: "ASC" }],
-        options: { skip: 0, top: 1 },
-      };
-
-      console.log("Config used:", {
-        realm: process.env.QB_REALM,
-        userToken: process.env.QB_USER_TOKEN,
-        tableId: QB_TABLE_ID_1,
-      });
-      console.log("Query request:", queryRequest);
-      const response: RunQueryResponse = await client.runQuery({
-        body: queryRequest,
-      });
-      console.log("Real API response:", response);
-
-      // Assertions with safety checks and type assertion
-      expect(
-        response.data,
-        "Expected response.data to be defined"
-      ).toBeDefined();
-      if (!response.data || response.data.length === 0) {
-        throw new Error(
-          "Expected response.data to contain at least one record"
-        );
-      }
-
-      expect(response.data).toHaveLength(1);
-      const record = response.data[0] as { [key: string]: FieldData };
-      expect(
-        record["3"]?.value,
-        "Expected field 3 to match createdRecordId"
-      ).toBe(createdRecordId);
-      expect(
-        record["6"]?.value,
-        "Expected field 6 to contain 'Test Task'"
-      ).toContain("Test Task");
-
-      expect(
-        response.fields,
-        "Expected response.fields to be defined"
-      ).toBeDefined();
-      if (!response.fields) {
-        throw new Error("Expected response.fields to contain field metadata");
-      }
-      expect(response.fields).toContainEqual({
-        id: 3,
-        label: expect.any(String),
-        type: expect.any(String),
-      });
-      expect(response.fields).toContainEqual({
-        id: 6,
-        label: expect.any(String),
-        type: expect.any(String),
-      });
-
-      expect(
-        response.metadata,
-        "Expected response.metadata to be defined"
-      ).toBeDefined();
-      if (!response.metadata) {
-        throw new Error("Expected response.metadata to be present");
-      }
-      expect(response.metadata).toMatchObject({
-        numFields: 2,
-        numRecords: 1,
-        skip: 0,
-        // Removed top: 1, as it should be undefined in the final response
-        totalRecords: expect.any(Number),
-      });
-
-      // Cleanup: Delete the test record
-      await client.deleteRecords({
-        body: {
-          from: QB_TABLE_ID_1,
-          where: `{3.EX.${createdRecordId}}`, // Assuming field 3 is Record ID#
-        },
-      });
-      console.log("Cleaned up test record with ID:", createdRecordId);
-    },
-    { timeout: 10000 }
-  );
-});

package/tests/vitest/qb/records/upsert.test.ts

@@ -1,102 +0,0 @@
-// tests/vitest/qb/records/upsert.test.ts
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { quickbase } from "@/quickbaseClient.ts";
-import {
-  Upsert200Response,
-  Upsert207Response,
-} from "/home/drew/Projects/quickbase-js/src/generated/models";
-
-const TABLE_ID = "buwai2zws";
-const MARKER_FIELD_ID = 6; // Text field for marking test records
-
-describe("QuickbaseClient - Upsert Integration", () => {
-  const qb = quickbase({
-    realm: "builderprogram-dbradford6815",
-    userToken: process.env.QB_USER_TOKEN,
-    debug: true,
-  });
-
-  beforeEach(async () => {
-    try {
-      await qb.deleteRecords({
-        body: {
-          from: TABLE_ID,
-          where: `{${MARKER_FIELD_ID}.CT.'test-marker-upsert'}`,
-        },
-      });
-    } catch (e) {
-      // Ignore if no records exist
-    }
-  });
-
-  afterEach(async () => {
-    try {
-      await qb.deleteRecords({
-        body: {
-          from: TABLE_ID,
-          where: `{${MARKER_FIELD_ID}.CT.'test-marker-upsert'}`,
-        },
-      });
-    } catch (e) {}
-  });
-
-  test(
-    "creates a new record successfully",
-    async () => {
-      const response: Upsert200Response | Upsert207Response = await qb.upsert({
-        body: {
-          to: TABLE_ID,
-          data: [{ [MARKER_FIELD_ID]: { value: "test-marker-upsert" } }],
-          fieldsToReturn: [MARKER_FIELD_ID, 3], // Return marker and record ID
-        },
-      });
-
-      // Check metadata with null safety
-      expect(
-        response.metadata,
-        "Expected metadata to be defined"
-      ).toBeDefined();
-      if (!response.metadata) {
-        throw new Error("Expected metadata to be present in upsert response");
-      }
-
-      expect(
-        response.metadata.createdRecordIds,
-        "Expected createdRecordIds to be defined"
-      ).toBeDefined();
-      if (!response.metadata.createdRecordIds) {
-        throw new Error(
-          "Expected createdRecordIds to be present in upsert response"
-        );
-      }
-      expect(response.metadata.createdRecordIds.length).toBe(1);
-
-      // Check data with null safety
-      expect(response.data, "Expected data to be defined").toBeDefined();
-      if (!response.data || response.data.length === 0) {
-        throw new Error("Expected at least one record in data");
-      }
-      expect(response.data).toHaveLength(1);
-      expect(response.data[0][MARKER_FIELD_ID]?.value).toBe(
-        "test-marker-upsert"
-      );
-      expect(response.data[0][3]?.value).toBeDefined(); // Record ID assigned by QuickBase
-
-      // Check totalNumberOfRecordsProcessed
-      expect(response.metadata.totalNumberOfRecordsProcessed).toBe(1);
-    },
-    { timeout: 10000 }
-  );
-
-  test(
-    "handles empty data gracefully",
-    async () => {
-      await expect(
-        qb.upsert({
-          body: { to: TABLE_ID, data: [] },
-        })
-      ).rejects.toThrow("API Error: Bad Request (Status: 400)");
-    },
-    { timeout: 10000 }
-  );
-});

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

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