quickbase-js 0.1.0-beta.7

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

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