quickbase-js 0.1.0-beta.10

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

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_TABLE_ID_1,
+  QB_TABLE_ID_2,
+} from "@tests/setup.ts";
+import {
+  CreateRelationship200Response,
+  CreateRelationshipRequest,
+} from "/home/drew/Projects/quickbase-js/src/generated/models";
+
+describe("QuickbaseClient Unit - createRelationship", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has createRelationship method", () => {
+    expect(typeof client.createRelationship).toBe("function");
+  });
+
+  it("sends correct request and handles successful response", async () => {
+    const mockResponse: CreateRelationship200Response = {
+      id: 6,
+      foreignKeyField: {
+        id: 6,
+        label: "my relationship field",
+        type: "numeric",
+      },
+      lookupFields: [
+        { id: 7, label: "Field 1", type: "text" },
+        { id: 8, label: "Field 2", type: "text" },
+        { id: 9, label: "Field 3", type: "text" },
+      ],
+      isCrossApp: false,
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+      summaryFields: [
+        { id: 10, label: "my first summary field", type: "numeric" },
+        { id: 11, label: "my second summary field", type: "numeric" },
+      ],
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: "my relationship field" },
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: [
+        {
+          summaryFid: 3,
+          label: "my first summary field",
+          accumulationType: "AVG",
+          where: "{'3'.EX.1}",
+        },
+        {
+          summaryFid: 4,
+          label: "my second summary field",
+          accumulationType: "SUM",
+        },
+      ],
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    const result = await client.createRelationship({
+      tableId,
+      body: requestBody,
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+        body: JSON.stringify(requestBody),
+      })
+    );
+    expect(result).toEqual(mockResponse);
+    expect(result.id).toBe(6);
+    expect(result.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(result.childTableId).toBe(QB_TABLE_ID_2);
+    expect(result.foreignKeyField).toBeDefined();
+    if (result.foreignKeyField) {
+      expect(result.foreignKeyField.label).toBe("my relationship field");
+    }
+    expect(result.lookupFields).toHaveLength(3);
+    expect(result.summaryFields).toBeDefined();
+    if (result.summaryFields) {
+      expect(result.summaryFields).toHaveLength(2);
+      expect(result.summaryFields[0].label).toBe("my first summary field");
+      expect(result.summaryFields[1].label).toBe("my second summary field");
+    }
+  });
+
+  it("handles error from TablesApi", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ message: "Invalid request payload" }),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: "my relationship field" },
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: [
+        { summaryFid: 3, label: "invalid", accumulationType: "INVALID" },
+      ],
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    await expect(
+      client.createRelationship({
+        tableId,
+        body: requestBody,
+      })
+    ).rejects.toThrow("API Error: Invalid request payload (Status: 400)");
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+        body: JSON.stringify(requestBody),
+      })
+    );
+  });
+
+  it("handles response with undefined foreignKeyField and summaryFields", async () => {
+    const mockResponse: CreateRelationship200Response = {
+      id: 6,
+      foreignKeyField: undefined,
+      lookupFields: [
+        { id: 7, label: "Field 1", type: "text" },
+        { id: 8, label: "Field 2", type: "text" },
+        { id: 9, label: "Field 3", type: "text" },
+      ],
+      isCrossApp: false,
+      parentTableId: QB_TABLE_ID_1,
+      childTableId: QB_TABLE_ID_2,
+      summaryFields: undefined,
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const requestBody: CreateRelationshipRequest = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: undefined,
+      lookupFieldIds: [1, 2, 3],
+      summaryFields: undefined,
+    };
+
+    const tableId = QB_TABLE_ID_2;
+
+    const result = await client.createRelationship({
+      tableId,
+      body: requestBody,
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+        body: JSON.stringify(requestBody),
+      })
+    );
+    expect(result).toEqual(mockResponse);
+    expect(result.id).toBe(6);
+    expect(result.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(result.childTableId).toBe(QB_TABLE_ID_2);
+    expect(result.foreignKeyField).toBeUndefined();
+    expect(result.lookupFields).toHaveLength(3);
+    expect(result.summaryFields).toBeUndefined();
+  });
+});

package/tests/vitest/unit/tables/createTable.test.ts

@@ -0,0 +1,70 @@
+// tests/vitest/unit/records/createTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - createTable", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("calls createTable successfully with user token", async () => {
+    const mockBody = {
+      name: "TestTable",
+      description: "Unit test table",
+      singleRecordName: "Test",
+      pluralRecordName: "Tests",
+    };
+    const mockResponse = {
+      id: "newly-created-table-id-1234567890", // Changed from "buya8h9iz"
+      name: "TestTable",
+      alias: "_DBID_TESTTABLE",
+      description: "Unit test table",
+      created: new Date("2025-03-10T21:00:00.000Z"),
+      updated: new Date("2025-03-10T21:00:00.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Test",
+      pluralRecordName: "Tests",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const response = await client.createTable({
+      appId: QB_APP_ID,
+      body: mockBody,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+        body: JSON.stringify(mockBody),
+      })
+    );
+  });
+});

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

@@ -0,0 +1,97 @@
+// tests/vitest/unit/tables/deleteRelationship.test.ts
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_TABLE_ID_2, // Child table
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - deleteRelationship", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("initializes without errors", () => {
+    expect(client).toBeDefined();
+  });
+
+  it("has deleteRelationship method", () => {
+    expect(typeof client.deleteRelationship).toBe("function");
+  });
+
+  it("sends correct DELETE request and handles successful response", async () => {
+    // Mock response for a successful deletion
+    const mockResponse = {
+      deletedRelationshipId: 6, // Matches the relationshipId
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const tableId = QB_TABLE_ID_2; // Child table
+    const relationshipId = 6; // Example relationship ID (foreign key field ID)
+
+    const result = await client.deleteRelationship({
+      tableId,
+      relationshipId,
+    });
+
+    // Verify the fetch call
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship/6`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+      })
+    );
+
+    // Verify the response
+    expect(result).toEqual(mockResponse);
+    expect(result.deletedRelationshipId).toBe(6);
+  });
+
+  it("handles error when relationship is not found", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      json: () => Promise.resolve({ message: "Relationship not found" }),
+    });
+
+    const tableId = QB_TABLE_ID_2;
+    const relationshipId = 999; // Non-existent relationship ID
+
+    await expect(
+      client.deleteRelationship({
+        tableId,
+        relationshipId,
+      })
+    ).rejects.toThrow("API Error: Relationship not found (Status: 404)");
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationship/999`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
+          Authorization:
+            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+        }),
+      })
+    );
+  });
+});

package/tests/vitest/unit/tables/deleteTable.test.ts

@@ -0,0 +1,77 @@
+// tests/vitest/unit/records/deleteTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_TABLE_ID_1,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - deleteTable", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("calls deleteTable successfully with user token", async () => {
+    const mockResponse = {
+      deletedTableId: QB_TABLE_ID_1,
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const response = await client.deleteTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+      })
+    );
+  });
+
+  it("handles 404 error for non-existent table", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      json: () =>
+        Promise.resolve({
+          message: "Invalid DBID",
+          description: "Table not found in app.",
+        }),
+    });
+
+    await expect(
+      client.deleteTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
+    ).rejects.toThrow("API Error: Invalid DBID (Status: 404)");
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "DELETE",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+      })
+    );
+  });
+});

package/tests/vitest/unit/tables/getAppTables.test.ts

@@ -0,0 +1,85 @@
+// tests/vitest/unit/tables/getAppTables.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getAppTables", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
+  });
+
+  it("calls getAppTables successfully", async () => {
+    mockFetch.mockImplementation((url: string, options: any) => {
+      console.log("Mock fetch for getAppTables:", url, options);
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve([
+            {
+              id: "buwai2zr4",
+              name: "Root",
+              alias: "_DBID_ROOT",
+              description: "",
+              created: new Date("2025-02-13T18:22:33.000Z"),
+              updated: new Date("2025-02-13T18:22:34.000Z"),
+              nextRecordId: 1,
+              nextFieldId: 6,
+              defaultSortFieldId: 2,
+              defaultSortOrder: "DESC",
+              keyFieldId: 3,
+              singleRecordName: "Root",
+              pluralRecordName: "Roots",
+              sizeLimit: "500 MB",
+              spaceUsed: "0 KB",
+              spaceRemaining: "500 MB",
+            },
+          ]),
+      } as Response);
+    });
+
+    const result = await client.getAppTables({ appId: QB_APP_ID });
+    console.log("getAppTables response:", result);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "buwai2zr4",
+          name: "Root",
+          alias: "_DBID_ROOT",
+          description: "",
+          created: new Date("2025-02-13T18:22:33.000Z"),
+          updated: new Date("2025-02-13T18:22:34.000Z"),
+          nextRecordId: 1,
+          nextFieldId: 6,
+          defaultSortFieldId: 2,
+          defaultSortOrder: "DESC",
+          keyFieldId: 3,
+          singleRecordName: "Root",
+          pluralRecordName: "Roots",
+          sizeLimit: "500 MB",
+          spaceUsed: "0 KB",
+          spaceRemaining: "500 MB",
+        }),
+      ])
+    );
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
+        }),
+      })
+    );
+  });
+});