quickbase-js 1.0.1-beta.0 → 1.1.0-beta.0

package/tests/playwright/qb/auth/cacheSwitching.test.ts

@@ -1,6 +1,6 @@
 // tests/playwright/qb/auth/cacheSwitching.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import fetch from "node-fetch";
 import dotenv from "dotenv";
 
@@ -137,7 +137,7 @@ test.describe("QuickbaseClient Integration - Cache Switching with Temp Tokens",
       return fetchResponse;
     };
 
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       useTempTokens: true,
       debug: true,

package/tests/playwright/qb/auth/fetchTempToken401.test.ts

@@ -1,6 +1,6 @@
 // tests/playwright/qb/auth/tokenInvalidation.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import fetch from "node-fetch";
 import dotenv from "dotenv";
 
@@ -141,7 +141,7 @@ test.describe("QuickbaseClient Integration - Token Invalidation with Cached Toke
       return fetchResponse;
     };
 
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       useTempTokens: true,
       debug: true,

package/tests/playwright/qb/auth/getAppWithUserToken.test.ts

@@ -1,6 +1,6 @@
 // tests/integration/auth/getAppWithUserToken.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import dotenv from "dotenv";
 
 dotenv.config();
@@ -89,7 +89,7 @@ test.describe("QuickbaseClient Integration - getApp with User Token", () => {
     console.log("Post-login URL after app navigation:", currentUrl);
 
     // Create Quickbase client with user token
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       userToken, // Use user token instead of temp tokens
       debug: true,

package/tests/playwright/qb/auth/getTempToken.test.ts

@@ -1,6 +1,6 @@
 // tests/integration/auth/getTempToken.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import fetch from "node-fetch";
 import dotenv from "dotenv";
 
@@ -132,7 +132,7 @@ test.describe("QuickbaseClient Integration - getApp with Temp Tokens", () => {
     };
 
     // Single client with conditional fetch
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       useTempTokens: true,
       debug: true,

package/tests/playwright/qb/auth/tokenPrefetch.test.ts

@@ -1,6 +1,6 @@
 // tests/playwright/qb/auth/tokenPrefetch.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import fetch from "node-fetch";
 import dotenv from "dotenv";
 
@@ -134,7 +134,7 @@ test.describe("QuickbaseClient Integration - Token Pre-Fetch and Cache Reuse", (
       return fetchResponse;
     };
 
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       useTempTokens: true,
       debug: true,

package/tests/playwright/qb/auth/tokenRenewal.test.ts

@@ -1,6 +1,6 @@
 // tests/playwright/qb/auth/tokenRenewal.test.ts
 import { test, expect } from "@playwright/test";
-import { quickbaseClient } from "../../../../src/quickbaseClient.ts";
+import { quickbase } from "../../../../src/quickbaseClient.ts";
 import dotenv from "dotenv";
 
 dotenv.config();
@@ -70,7 +70,7 @@ test.describe("QuickbaseClient Integration - Temp Token Renewal", () => {
       });
     };
 
-    const client = quickbaseClient({
+    const client = quickbase({
       realm,
       useTempTokens: true,
       debug: true,

package/tests/setup.ts

@@ -1,19 +1,27 @@
-import { quickbaseClient, QuickbaseConfig } from "../src/quickbaseClient.ts";
-import dotenv from "dotenv";
+// @tests/setup.ts
 import { vi } from "vitest";
+import { quickbase } from "../src/quickbaseClient.ts";
+import type { QuickbaseConfig } from "../src/quickbaseClient.ts";
 
-dotenv.config();
+export const mockFetch = vi.fn();
 
 export const createClient = (
   fetchApi?: any,
   config: Partial<QuickbaseConfig> = {}
-) =>
-  quickbaseClient({
-    realm: process.env.QB_REALM || "default-realm",
-    userToken: process.env.QB_USER_TOKEN || "default-token",
+) => {
+  const client = quickbase({
+    realm: process.env.QB_REALM || "test-realm", // Match upsert.test.ts
+    userToken: process.env.QB_USER_TOKEN || "test-token", // Match upsert.test.ts
     debug: true,
     fetchApi,
     ...config,
   });
+  console.log("[createClient] Config:", config); // Debug config
+  console.log("[createClient] Returning:", client); // Debug client
+  return client;
+};
 
-export const mockFetch = vi.fn();
+// Mock env variables for consistency
+vi.stubEnv("QB_REALM", "builderprogram-dbradford6815");
+vi.stubEnv("QB_USER_TOKEN", "b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3");
+vi.stubEnv("QB_APP_ID", "buwai2zpe");

package/tests/vitest/qb/apps/getApp.test.ts

@@ -1,46 +1,40 @@
-import { describe, it, expect } from "vitest";
-import { createClient } from "../../../setup.ts";
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
 
-describe("QuickbaseClient Integration - getApp", () => {
-  const client = createClient();
+test(
+  "QuickbaseClient Integration - getApp > fetches real app 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 getAppId = "buwai2zpe";
 
-  it(
-    "fetches real app data from QuickBase",
-    async () => {
-      const getAppId = process.env.QB_APP_ID;
-      if (!getAppId) throw new Error("QB_APP_ID is not defined in .env");
-      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:", config);
+    const result = await client.getApp({ appId: getAppId });
+    console.log("Real API response:", result);
 
-      console.log("Config used:", {
-        realm: process.env.QB_REALM,
-        userToken: process.env.QB_USER_TOKEN,
-        appId: getAppId,
-      });
-      const result = await client.getApp({ appId: getAppId });
-      console.log("Real API response:", result);
-      expect(result).toEqual({
-        id: getAppId,
-        name: "qb-copy",
-        created: new Date("2025-02-13T18:22:33Z"),
-        updated: new Date("2025-03-04T04:25:51Z"),
-        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,
-        },
-      });
-    },
-    { timeout: 10000 }
-  );
-});
+    expect(result).toEqual({
+      id: getAppId,
+      name: "qb-copy",
+      created: expect.any(Date), // Matches Date object from client
+      updated: expect.any(Date), // Matches Date object from client
+      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,
+      },
+    });
+  }
+);

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

@@ -0,0 +1,78 @@
+// tests/vitest/qb/records/deleteRecords.test.ts
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { quickbase } from "@/quickbaseClient.ts";
+
+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 = await qb.upsert({
+        body: {
+          to: TABLE_ID,
+          data: [{ [MARKER_FIELD_ID]: { value: "test-marker-delete" } }],
+          fieldsToReturn: [UNIQUE_FIELD_ID], // Return record ID
+        },
+      });
+      const recordId = upsertResponse.metadata.createdRecordIds[0];
+      expect(recordId).toBeDefined();
+      expect(upsertResponse.data[0][UNIQUE_FIELD_ID].value).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/upsert.test.ts

@@ -0,0 +1,72 @@
+// tests/vitest/qb/records/upsert.test.ts
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { quickbase } from "@/quickbaseClient.ts";
+
+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 = 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
+        },
+      });
+
+      expect(response.metadata.createdRecordIds.length).toBe(1);
+      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
+      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/createTable.test.ts

@@ -0,0 +1,55 @@
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - createTable > creates a new table 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 tableName = `TestTable_${Date.now()}`;
+    const createBody = {
+      name: tableName,
+      description: "Test table creation",
+      singleRecordName: "TestRecord",
+      pluralRecordName: "TestRecords",
+    };
+
+    console.log("Config used:", config);
+    console.log("Creating table with:", createBody);
+    const response = await client.createTable({ appId, body: createBody });
+
+    expect(response).toBeDefined();
+    expect(response.id).toBeDefined();
+    expect(response.name).toBe(tableName);
+    expect(response.description).toBe(createBody.description);
+    expect(response.singleRecordName).toBe(createBody.singleRecordName);
+    expect(response.pluralRecordName).toBe(createBody.pluralRecordName);
+    expect(response.alias).toMatch(/^_DBID_/);
+    expect(response.created).toBeInstanceOf(Date);
+    expect(response.updated).toBeInstanceOf(Date);
+    expect(response.nextRecordId).toBeGreaterThanOrEqual(1);
+    expect(response.nextFieldId).toBeGreaterThanOrEqual(1);
+    expect(response.defaultSortFieldId).toBeGreaterThanOrEqual(0);
+    expect(response.keyFieldId).toBeGreaterThanOrEqual(1);
+    expect(response.sizeLimit).toMatch(/^\d+\sMB$/); // e.g., "500 MB"
+    expect(response.spaceUsed).toMatch(/^\d+\s(KB|MB)$/); // e.g., "0 KB"
+    expect(response.spaceRemaining).toMatch(/^\d+\sMB$/); // e.g., "500 MB"
+
+    console.log("Real API response:", response);
+
+    // Cleanup: Delete the table to avoid clutter
+    const deleteResponse = await client.deleteTable({
+      tableId: response.id,
+      appId,
+    });
+    expect(deleteResponse.deletedTableId).toBe(response.id);
+    console.log("Cleanup - Deleted table:", deleteResponse);
+  }
+);

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

@@ -1,67 +1,46 @@
-import { describe, it, expect } from "vitest";
-import { createClient } from "../../../setup.ts";
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
 
-describe("QuickbaseClient Integration - getAppTables", () => {
-  const client = createClient();
+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";
 
-  it(
-    "fetches real table data from QuickBase",
-    async () => {
-      const tablesAppId = process.env.QB_APP_ID;
-      if (!tablesAppId) throw new Error("QB_APP_ID is not defined in .env");
-      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:", config);
+    const result = await client.getAppTables({ appId: tablesAppId });
+    console.log("Real API response:", result);
 
-      console.log("Config used:", {
-        realm: process.env.QB_REALM,
-        userToken: process.env.QB_USER_TOKEN,
-        appId: tablesAppId,
-      });
-      const result = await client.getAppTables({ appId: tablesAppId });
-      console.log("Real API response:", result);
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            alias: "_DBID_ROOT",
-            created: new Date("2025-02-13T18:22:33Z"),
-            defaultSortFieldId: 2,
-            defaultSortOrder: "DESC",
-            description: "",
-            id: "buwai2zr4",
-            keyFieldId: 3,
-            name: "Root",
-            nextFieldId: 6,
-            nextRecordId: 1,
-            pluralRecordName: "Roots",
-            singleRecordName: "Root",
-            sizeLimit: "500 MB",
-            spaceRemaining: "500 MB",
-            spaceUsed: "0 KB",
-            updated: new Date("2025-02-13T18:22:34Z"),
-          }),
-          expect.objectContaining({
-            alias: "_DBID_ROLES",
-            created: new Date("2025-02-13T18:22:33Z"),
-            defaultSortFieldId: 2,
-            defaultSortOrder: "DESC",
-            description: "",
-            id: "buwai2z3s",
-            keyFieldId: 3,
-            name: "Roles",
-            nextFieldId: 6,
-            nextRecordId: 1,
-            pluralRecordName: "Roles",
-            singleRecordName: "Role",
-            sizeLimit: "500 MB",
-            spaceRemaining: "500 MB",
-            spaceUsed: "0 KB",
-            updated: new Date("2025-02-13T18:22:34Z"),
-          }),
-        ])
-      );
-    },
-    { timeout: 10000 }
-  );
-});
+    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/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/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);
+  }
+);