quickbase-js 0.1.0-beta.9 → 1.0.0

package/tests/vitest/unit/fields/getField.test.ts

@@ -1,189 +0,0 @@
-// tests/vitest/unit/fields/getField.test.ts
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "@tests/setup.ts";
-import { Field } from "@/generated/models";
-
-describe("QuickbaseClient Unit - getField", () => {
-  let client: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-    client = createClient(mockFetch, { debug: true });
-  });
-
-  it("initializes without errors and has getField method", () => {
-    expect(client).toBeDefined();
-    expect(typeof client.getField).toBe("function");
-  });
-
-  it("calls getField successfully with user token", async () => {
-    const mockResponse: Field = {
-      id: 123,
-      label: "Field1",
-      fieldType: "text",
-      mode: "",
-      noWrap: false,
-      bold: false,
-      required: false,
-      appearsByDefault: false,
-      findEnabled: false,
-      unique: false,
-      doesDataCopy: false,
-      fieldHelp: "field help",
-      audited: false,
-      properties: {
-        primaryKey: false,
-        foreignKey: false,
-        numLines: 1,
-        maxLength: 0,
-        appendOnly: false,
-        allowHTML: false,
-        allowMentions: false,
-        sortAsGiven: false,
-        carryChoices: true,
-        allowNewChoices: false,
-        formula: "",
-        defaultValue: "",
-      },
-      permissions: [
-        { permissionType: "View", role: "Viewer", roleId: 10 },
-        { permissionType: "None", role: "Participant", roleId: 11 },
-        { permissionType: "Modify", role: "Administrator", roleId: 12 },
-      ],
-    };
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const result = await client.getField({
-      fieldId: 123,
-      tableId: QB_TABLE_ID_1,
-      includeFieldPerms: true,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/123?tableId=${QB_TABLE_ID_1}&includeFieldPerms=true`,
-      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",
-        }),
-      })
-    );
-  });
-
-  it("calls getField successfully with temp token", async () => {
-    client = createClient(mockFetch, { useTempTokens: true, debug: true });
-
-    const mockResponse: Field = {
-      id: 123,
-      label: "Field1",
-      fieldType: "text",
-      mode: "",
-      noWrap: false,
-      bold: false,
-      required: false,
-      appearsByDefault: false,
-      findEnabled: false,
-      unique: false,
-      doesDataCopy: false,
-      fieldHelp: "field help",
-      audited: false,
-      properties: {
-        primaryKey: false,
-        foreignKey: false,
-        numLines: 1,
-        maxLength: 0,
-        appendOnly: false,
-        allowHTML: false,
-        allowMentions: false,
-        sortAsGiven: false,
-        carryChoices: true,
-        allowNewChoices: false,
-        formula: "",
-        defaultValue: "",
-      },
-      permissions: [],
-    };
-
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(mockResponse),
-      });
-
-    const result = await client.getField({
-      fieldId: 123,
-      tableId: QB_TABLE_ID_1,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      1,
-      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-      expect.objectContaining({
-        method: "GET",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          "Content-Type": "application/json",
-        }),
-        credentials: "include",
-      })
-    );
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      2,
-      `https://api.quickbase.com/v1/fields/123?tableId=${QB_TABLE_ID_1}`,
-      expect.objectContaining({
-        method: "GET",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: "QB-TEMP-TOKEN temp_token",
-          "Content-Type": "application/json",
-        }),
-      })
-    );
-  });
-
-  it("handles 404 error for non-existent field", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      json: () => Promise.resolve({ message: "Field not found" }),
-    });
-
-    await expect(
-      client.getField({ fieldId: 999, tableId: QB_TABLE_ID_1 })
-    ).rejects.toThrow("API Error: Field not found (Status: 404)");
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/999?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-  });
-});

package/tests/vitest/unit/fields/getFieldUsage.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "@tests/setup.ts";
-import { FieldUsage } from "@/generated/models";
-
-describe("QuickbaseClient Unit - getFieldUsage", () => {
-  let client: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-    client = createClient(mockFetch, { realm: QB_REALM, debug: true });
-  });
-
-  it("initializes without errors and has getFieldUsage method", () => {
-    expect(client).toBeDefined();
-    expect(typeof client.getFieldUsage).toBe("function");
-  });
-
-  it("calls getFieldUsage successfully with user token", async () => {
-    const mockResponse: FieldUsage = {
-      field: {
-        id: 6,
-        name: "name",
-        type: "text",
-      },
-      usage: {
-        actions: { count: 0 },
-        appHomePages: { count: 0 },
-        dashboards: { count: 2 },
-        defaultReports: { count: 1 },
-        exactForms: { count: 0 },
-        fields: { count: 0 },
-        forms: { count: 1 },
-        notifications: { count: 0 },
-        personalReports: { count: 0 },
-        pipelines: { count: 1 },
-        relationships: { count: 0 },
-        reminders: { count: 0 },
-        reports: { count: 2 },
-        roles: { count: 2 },
-        tableImports: { count: 2 },
-        tableRules: { count: 1 },
-        webhooks: { count: 0 },
-      },
-    };
-
-    mockFetch.mockResolvedValueOnce(
-      new Response(JSON.stringify([mockResponse]), {
-        status: 200,
-        statusText: "OK",
-        headers: { "Content-Type": "application/json" },
-      })
-    );
-
-    const result = await client.getFieldUsage({
-      fieldId: 6,
-      tableId: QB_TABLE_ID_1,
-    });
-
-    expect(result).toBeInstanceOf(Array);
-    expect(result).toHaveLength(1);
-    const fieldUsage = result[0];
-
-    expect(fieldUsage).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/usage/6?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-    expect(fieldUsage.field.id).toBe(6);
-    expect(fieldUsage.field.name).toBe("name");
-    expect(fieldUsage.usage.dashboards.count).toBe(2);
-  });
-
-  it("handles 404 error for non-existent field", async () => {
-    mockFetch.mockResolvedValueOnce(
-      new Response(JSON.stringify({ message: "Field not found" }), {
-        status: 404,
-        statusText: "Not Found",
-        headers: { "Content-Type": "application/json" },
-      })
-    );
-
-    await expect(
-      client.getFieldUsage({
-        fieldId: 999,
-        tableId: QB_TABLE_ID_1,
-      })
-    ).rejects.toThrow("API Error: Field not found (Status: 404)");
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/usage/999?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-  });
-
-  it("handles persistent 401 error for field usage retrieval", async () => {
-    // Simulate persistent 401 errors to exhaust retries
-    mockFetch
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify({ message: "Unauthorized" }), {
-          status: 401,
-          statusText: "Unauthorized",
-          headers: { "Content-Type": "application/json" },
-        })
-      )
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify({ message: "Unauthorized" }), {
-          status: 401,
-          statusText: "Unauthorized",
-          headers: { "Content-Type": "application/json" },
-        })
-      )
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify({ message: "Unauthorized" }), {
-          status: 401,
-          statusText: "Unauthorized",
-          headers: { "Content-Type": "application/json" },
-        })
-      )
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify({ message: "Unauthorized" }), {
-          status: 401,
-          statusText: "Unauthorized",
-          headers: { "Content-Type": "application/json" },
-        })
-      );
-
-    await expect(
-      client.getFieldUsage({
-        fieldId: 6,
-        tableId: QB_TABLE_ID_1,
-      })
-    ).rejects.toThrow("API Error: Unauthorized (Status: 401)");
-
-    expect(mockFetch).toHaveBeenCalledTimes(4); // Initial + 3 retries
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      1,
-      `https://api.quickbase.com/v1/fields/usage/6?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      4,
-      `https://api.quickbase.com/v1/fields/usage/6?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-  });
-});

package/tests/vitest/unit/fields/getFields.test.ts

@@ -1,122 +0,0 @@
-// tests/vitest/unit/fields/getFields.test.ts
-import { describe, it, expect } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "@tests/setup.ts";
-
-describe("QuickbaseClient Unit - getFields", () => {
-  it("calls getFields successfully", async () => {
-    mockFetch.mockImplementation((url: string, options: any) => {
-      console.log("Mock fetch for getFields:", url, options);
-      return Promise.resolve({
-        ok: true,
-        status: 200,
-        json: () =>
-          Promise.resolve([
-            {
-              id: 1,
-              label: "Field1",
-              fieldType: "text",
-              noWrap: false,
-              bold: false,
-              required: false,
-              appearsByDefault: false,
-              findEnabled: false,
-              unique: false,
-              doesDataCopy: false,
-              fieldHelp: "field help",
-              audited: false,
-              properties: {
-                primaryKey: false,
-                foreignKey: false,
-                numLines: 1,
-                maxLength: 0,
-                appendOnly: false,
-                allowHTML: false,
-                allowMentions: false,
-                sortAsGiven: false,
-                carryChoices: true,
-                allowNewChoices: false,
-                formula: "",
-                defaultValue: "",
-              },
-              permissions: [
-                { permissionType: "View", role: "Viewer", roleId: 10 },
-                { permissionType: "None", role: "Participant", roleId: 11 },
-                { permissionType: "Modify", role: "Administrator", roleId: 12 },
-              ],
-            },
-          ]),
-      } as Response);
-    });
-
-    const client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
-    const result = await client.getFields({
-      tableId: QB_TABLE_ID_1,
-      includeFieldPerms: true,
-    });
-    console.log("getFields response:", result);
-    expect(result).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: 1,
-          label: "Field1",
-          fieldType: "text",
-          noWrap: false,
-          bold: false,
-          required: false,
-          appearsByDefault: false,
-          findEnabled: false,
-          unique: false,
-          doesDataCopy: false,
-          fieldHelp: "field help",
-          audited: false,
-          properties: expect.objectContaining({
-            primaryKey: false,
-            foreignKey: false,
-            numLines: 1,
-            maxLength: 0,
-            appendOnly: false,
-            allowHTML: false,
-            allowMentions: false,
-            sortAsGiven: false,
-            carryChoices: true,
-            allowNewChoices: false,
-            formula: "",
-            defaultValue: "",
-          }),
-          permissions: expect.arrayContaining([
-            expect.objectContaining({
-              permissionType: "View",
-              role: "Viewer",
-              roleId: 10,
-            }),
-            expect.objectContaining({
-              permissionType: "None",
-              role: "Participant",
-              roleId: 11,
-            }),
-            expect.objectContaining({
-              permissionType: "Modify",
-              role: "Administrator",
-              roleId: 12,
-            }),
-          ]),
-        }),
-      ])
-    );
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}&includeFieldPerms=true`,
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-        }),
-      })
-    );
-  });
-});

package/tests/vitest/unit/fields/getFieldsUsage.test.ts

@@ -1,160 +0,0 @@
-// tests/vitest/unit/fields/getFieldsUsage.test.ts
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_REALM,
-  QB_TABLE_ID_1,
-  QB_USER_TOKEN,
-} from "@tests/setup.ts";
-import { FieldUsage } from "@/generated/models";
-
-describe("QuickbaseClient Unit - getFieldsUsage", () => {
-  let client: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-    client = createClient(mockFetch, { debug: true });
-  });
-
-  it("initializes without errors and has getFieldsUsage method", () => {
-    expect(client).toBeDefined();
-    expect(typeof client.getFieldsUsage).toBe("function");
-  });
-
-  it("calls getFieldsUsage successfully with user token", async () => {
-    const mockResponse: FieldUsage[] = [
-      {
-        field: {
-          id: 6,
-          name: "name",
-          type: "Text",
-        },
-        usage: {
-          actions: { count: 0 },
-          appHomePages: { count: 0 },
-          dashboards: { count: 2 },
-          defaultReports: { count: 1 },
-          exactForms: { count: 0 },
-          fields: { count: 0 },
-          forms: { count: 1 },
-          notifications: { count: 0 },
-          personalReports: { count: 0 },
-          pipelines: { count: 1 },
-          relationships: { count: 0 },
-          reminders: { count: 0 },
-          reports: { count: 2 },
-          roles: { count: 2 },
-          tableImports: { count: 3 },
-          tableRules: { count: 1 },
-          webhooks: { count: 0 },
-        },
-      },
-    ];
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const result = await client.getFieldsUsage({
-      tableId: QB_TABLE_ID_1,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/usage?tableId=${QB_TABLE_ID_1}`,
-      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",
-        }),
-      })
-    );
-  });
-
-  it("calls getFieldsUsage with skip and top parameters", async () => {
-    const mockResponse: FieldUsage[] = [
-      {
-        field: {
-          id: 7,
-          name: "priority",
-          type: "Text",
-        },
-        usage: {
-          actions: { count: 1 },
-          appHomePages: { count: 0 },
-          dashboards: { count: 0 },
-          defaultReports: { count: 0 },
-          exactForms: { count: 0 },
-          fields: { count: 1 },
-          forms: { count: 0 },
-          notifications: { count: 0 },
-          personalReports: { count: 0 },
-          pipelines: { count: 0 },
-          relationships: { count: 0 },
-          reminders: { count: 0 },
-          reports: { count: 1 },
-          roles: { count: 1 },
-          tableImports: { count: 0 },
-          tableRules: { count: 0 },
-          webhooks: { count: 0 },
-        },
-      },
-    ];
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const result = await client.getFieldsUsage({
-      tableId: QB_TABLE_ID_1,
-      skip: 1,
-      top: 1,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/usage?tableId=${QB_TABLE_ID_1}&skip=1&top=1`,
-      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",
-        }),
-      })
-    );
-  });
-
-  it("handles 404 error for non-existent table", async () => {
-    const nonExistentTableId = "nonexistent_dbid";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      json: () => Promise.resolve({ message: "Table not found" }),
-    });
-
-    await expect(
-      client.getFieldsUsage({ tableId: nonExistentTableId })
-    ).rejects.toThrow("API Error: Table not found (Status: 404)");
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/usage?tableId=${nonExistentTableId}`,
-      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",
-        }),
-      })
-    );
-  });
-});