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

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";
 
@@ -67,13 +67,13 @@ test.describe("QuickbaseClient Integration - Cache Switching with Temp Tokens",
     console.log("Starting cacheSwitching test");
     const realm = process.env.QB_REALM;
     const appId = process.env.QB_APP_ID;
-    const tableId = process.env.QB_TABLE_ID;
+    const tableId = process.env.QB_TABLE_ID_1;
     const username = process.env.QB_USERNAME;
     const password = process.env.QB_PASSWORD;
 
     if (!realm) throw new Error("QB_REALM is not defined in .env");
     if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-    if (!tableId) throw new Error("QB_TABLE_ID is not defined in .env");
+    if (!tableId) throw new Error("QB_TABLE_ID_1 is not defined in .env");
     if (!username) throw new Error("QB_USERNAME is not defined in .env");
     if (!password) throw new Error("QB_PASSWORD is not defined in .env");
 
@@ -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,47 @@
-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";
+import dotenv from "dotenv";
+
+// Load environment variables from .env file
+dotenv.config({ path: "./.env" }); // Assumes .env is at project root
+
+export const mockFetch = vi.fn();
+
+export const QB_REALM = process.env.QB_REALM || "test-realm";
+export const QB_USER_TOKEN =
+  process.env.QB_USER_TOKEN || "user-token-1234567890";
+export const QB_APP_ID = process.env.QB_APP_ID || "app-id-1234567890";
+export const QB_TABLE_ID_1 = process.env.QB_TABLE_ID_1 || "table-id-1234567890";
 
-dotenv.config();
+// Mock env variables for consistency, using .env values if available
+vi.stubEnv("QB_REALM", QB_REALM);
+vi.stubEnv("QB_USER_TOKEN", QB_USER_TOKEN);
+vi.stubEnv("QB_APP_ID", QB_APP_ID);
+vi.stubEnv("QB_TABLE_ID_1", QB_TABLE_ID_1);
 
 export const createClient = (
   fetchApi?: any,
   config: Partial<QuickbaseConfig> = {}
-) =>
-  quickbaseClient({
-    realm: process.env.QB_REALM || "default-realm",
-    userToken: process.env.QB_USER_TOKEN || "default-token",
+) => {
+  // Use loaded env vars with fallbacks for safety
+  const realm = QB_REALM;
+  const userToken = QB_USER_TOKEN;
+
+  const client = quickbase({
+    realm,
+    userToken,
     debug: true,
     fetchApi,
+    ...config, // Allow overrides if provided
+  });
+  console.log("[createClient] Config:", {
+    realm,
+    userToken,
+    debug: true,
     ...config,
   });
-
-export const mockFetch = vi.fn();
+  console.log("[createClient] Returning:", client);
+  return client;
+};

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createClient } from "../../../setup.ts";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
 
 describe("QuickbaseClient Integration - getFields", () => {
   const client = createClient();
@@ -7,8 +7,6 @@ describe("QuickbaseClient Integration - getFields", () => {
   it(
     "fetches real field data from QuickBase",
     async () => {
-      const tableId = "buwai2z3s";
-      if (!tableId) throw new Error("Table ID is not defined");
       if (!process.env.QB_REALM)
         throw new Error("QB_REALM is not defined in .env");
       if (!process.env.QB_USER_TOKEN)
@@ -17,10 +15,10 @@ describe("QuickbaseClient Integration - getFields", () => {
       console.log("Config used:", {
         realm: process.env.QB_REALM,
         userToken: process.env.QB_USER_TOKEN,
-        tableId,
+        tableId: QB_TABLE_ID_1,
       });
       const result = await client.getFields({
-        tableId,
+        tableId: QB_TABLE_ID_1,
         includeFieldPerms: true,
       });
       console.log("Real API response:", result);

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

@@ -0,0 +1,82 @@
+// tests/vitest/qb/records/runQuery.test.ts
+import { describe, it, expect } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts"; // Import QB_TABLE_ID_1
+import { RunQueryRequest, RunQueryResponse } from "@/generated/models";
+
+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 = 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
+        },
+      });
+      createdRecordId = upsertResponse.metadata.createdRecordIds[0];
+      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
+      expect(response.data).toHaveLength(1);
+      expect(response.data[0]["3"].value).toBe(createdRecordId);
+      expect(response.data[0]["6"].value).toContain("Test Task");
+      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).toMatchObject({
+        numFields: 2,
+        numRecords: 1,
+        skip: 0,
+        top: 1,
+        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

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