quickbase-js 0.1.0-beta.8 → 1.0.0

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

@@ -1,280 +0,0 @@
-// tests/vitest/unit/fields/updateField.test.ts
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_APP_ID,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "@tests/setup.ts";
-import { UpdateFieldRequest, UpdateField200Response } from "@/generated/models";
-
-describe("QuickbaseClient Unit - updateField", () => {
-  let client: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-  });
-
-  it("initializes and has updateField method", () => {
-    client = createClient(mockFetch, { debug: true });
-    expect(client).toBeDefined();
-    expect(typeof client.updateField).toBe("function");
-  });
-
-  it("updates field successfully with user token", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-    });
-
-    const tableId = QB_TABLE_ID_1;
-    const fieldId = 123;
-
-    const request: UpdateFieldRequest = {
-      label: "Field1",
-      // fieldType omitted as it’s not allowed in updates
-      noWrap: false,
-      bold: false,
-      required: true,
-      appearsByDefault: false,
-      findEnabled: false,
-      unique: true,
-      fieldHelp: "field help",
-      addToForms: true,
-      properties: {
-        numLines: 1,
-        maxLength: 50,
-        appendOnly: true,
-        sortAsGiven: false,
-        allowMentions: false,
-        comments: "Updated field settings",
-        doesTotal: false,
-        defaultValue: "Initial text",
-        choices: ["Option1", "Option2"], // Still valid for properties
-      },
-      permissions: [
-        { role: "Viewer", permissionType: "View", roleId: 10 },
-        { role: "Participant", permissionType: "None", roleId: 11 },
-        { role: "Administrator", permissionType: "Modify", roleId: 12 },
-      ],
-    };
-
-    const mockResponse: UpdateField200Response = {
-      id: fieldId,
-      label: "Field1",
-      fieldType: "text", // Returned by API, not updated
-      mode: "",
-      noWrap: false,
-      bold: false,
-      required: true,
-      appearsByDefault: false,
-      findEnabled: false,
-      unique: true,
-      doesDataCopy: false,
-      fieldHelp: "field help",
-      audited: false,
-      properties: {
-        numLines: 1,
-        maxLength: 50,
-        appendOnly: true,
-        sortAsGiven: false,
-        allowMentions: false,
-        comments: "Updated field settings",
-        doesTotal: false,
-        defaultValue: "Initial text",
-        choices: ["Option1", "Option2"],
-        allowHTML: false,
-        carryChoices: true,
-        allowNewChoices: false,
-        formula: "",
-      },
-      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.updateField({
-      fieldId,
-      tableId,
-      body: request,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/${fieldId}?tableId=${tableId}`,
-      expect.objectContaining({
-        method: "POST",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify(request),
-        credentials: "omit",
-      })
-    );
-  });
-
-  it("updates field successfully with temp token", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      useTempTokens: true,
-      debug: true,
-    });
-
-    const tableId = QB_TABLE_ID_1;
-    const fieldId = 123;
-
-    const request: UpdateFieldRequest = {
-      label: "Field1",
-      // fieldType omitted as it’s not allowed in updates
-      required: true,
-      unique: true,
-      properties: {
-        numLines: 1,
-        maxLength: 0,
-        choices: ["Yes", "No"],
-        allowNewChoices: true,
-        defaultValue: "No",
-      },
-    };
-
-    const mockResponse: UpdateField200Response = {
-      id: fieldId,
-      label: "Field1",
-      fieldType: "text-multiple-choice", // Returned by API, not updated
-      mode: "",
-      noWrap: false,
-      bold: false,
-      required: true,
-      appearsByDefault: false,
-      findEnabled: false,
-      unique: true,
-      doesDataCopy: false,
-      fieldHelp: "",
-      audited: false,
-      properties: {
-        numLines: 1,
-        maxLength: 0,
-        choices: ["Yes", "No"],
-        allowNewChoices: true,
-        defaultValue: "No",
-        appendOnly: false,
-        allowHTML: false,
-        allowMentions: false,
-        sortAsGiven: false,
-        carryChoices: true,
-        formula: "",
-      },
-      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({ temporaryAuthorization: "temp_token" }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(mockResponse),
-      });
-
-    const result = await client.updateField({
-      fieldId,
-      tableId,
-      body: request,
-    });
-
-    expect(result).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      1,
-      `https://api.quickbase.com/v1/auth/temporary/${tableId}`,
-      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/${fieldId}?tableId=${tableId}`,
-      expect.objectContaining({
-        method: "POST",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: "QB-TEMP-TOKEN temp_token",
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify(request),
-        credentials: "omit",
-      })
-    );
-  });
-
-  it("handles 400 error for invalid field update", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-    });
-
-    const tableId = QB_TABLE_ID_1;
-    const fieldId = 999;
-
-    const request: UpdateFieldRequest = {
-      label: "InvalidField",
-      // fieldType omitted as it’s not allowed in updates
-      required: true,
-      properties: {
-        numLines: 1,
-        decimalPlaces: 2,
-        currencySymbol: "$",
-      },
-    };
-
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      json: () => Promise.resolve({ message: "Invalid field ID" }),
-    });
-
-    await expect(
-      client.updateField({ fieldId, tableId, body: request })
-    ).rejects.toThrow("API Error: Invalid field ID (Status: 400)");
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/fields/${fieldId}?tableId=${tableId}`,
-      expect.objectContaining({
-        method: "POST",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify(request),
-        credentials: "omit",
-      })
-    );
-  });
-});

package/tests/vitest/unit/index.ts

@@ -1,33 +0,0 @@
-// tests/vitest/unit/index.ts
-// Apps
-export * from "./apps/copyApp.test.ts";
-export * from "./apps/createApp.test.ts";
-export * from "./apps/deleteApp.test.ts";
-export * from "./apps/getApp.test.ts";
-
-// Auth
-export * from "./auth/fetchTempToken401.test.ts";
-export * from "./auth/getTempToken.test.ts";
-export * from "./auth/retryOn401.test.ts";
-export * from "./auth/two401s.test.ts";
-
-// Fields
-export * from "./fields/getFields.test.ts";
-export * from "./fields/getField.test.ts";
-export * from "./fields/createField.test.ts";
-export * from "./fields/deleteFields.test.ts";
-export * from "./fields/getFieldsUsage.test.ts";
-export * from "./fields/getFieldUsage.test.ts";
-
-// Records
-export * from "./records/deleteRecords.test.ts";
-export * from "./records/runQuery.test.ts";
-export * from "./records/upsert.test.ts";
-
-// Tables
-export * from "./tables/createTable.test.ts";
-export * from "./tables/deleteTable.test.ts";
-export * from "./tables/getAppTables.test.ts";
-export * from "./tables/getRelationships.test.ts";
-export * from "./tables/getTable.test.ts";
-export * from "./tables/updateTable.test.ts";

package/tests/vitest/unit/rateLimit.test.ts

@@ -1,189 +0,0 @@
-// tests/vitest/unit/rateLimit.test.ts
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_APP_ID,
-  QB_REALM,
-  QB_USER_TOKEN,
-} from "@tests/setup.ts";
-import { RateLimitError } from "@/RateLimitError";
-import { GetApp200Response } from "@/generated/models";
-
-describe("QuickbaseClient Unit - Rate Limit Handling", () => {
-  let client: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-  });
-
-  it("succeeds after retrying on 429 Too Many Requests", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-      maxRetries: 2,
-      retryDelay: 100,
-      throttle: { rate: 10, burst: 10 },
-    });
-
-    const appId = QB_APP_ID;
-
-    const mockResponse: GetApp200Response = {
-      id: appId,
-      name: "TestApp",
-      created: "2025-01-01T00:00:00Z",
-      updated: "2025-01-02T00:00:00Z",
-      description: "Test app",
-      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,
-      },
-    };
-
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: false,
-        status: 429,
-        headers: new Headers({ "Retry-After": "1" }),
-        json: () => Promise.resolve({ message: "Too Many Requests" }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(mockResponse),
-      });
-
-    const result = await client.getApp({ appId });
-
-    expect(result).toEqual({
-      ...mockResponse,
-      created: new Date("2025-01-01T00:00:00Z"),
-      updated: new Date("2025-01-02T00:00:00Z"),
-    });
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      1,
-      `https://api.quickbase.com/v1/apps/${appId}`,
-      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",
-        }),
-        credentials: "omit",
-      })
-    );
-    expect(mockFetch).toHaveBeenNthCalledWith(
-      2,
-      `https://api.quickbase.com/v1/apps/${appId}`,
-      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",
-        }),
-        credentials: "omit",
-      })
-    );
-  });
-
-  it("throws RateLimitError after max retries on 429", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-      maxRetries: 1,
-      retryDelay: 100,
-      throttle: { rate: 10, burst: 10 },
-    });
-
-    const appId = QB_APP_ID;
-
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: false,
-        status: 429,
-        headers: new Headers({ "Retry-After": "1" }),
-        json: () => Promise.resolve({ message: "Too Many Requests" }),
-      })
-      .mockResolvedValueOnce({
-        ok: false,
-        status: 429,
-        headers: new Headers({ "Retry-After": "1" }),
-        json: () => Promise.resolve({ message: "Too Many Requests" }),
-      });
-
-    await expect(client.getApp({ appId })).rejects.toMatchObject({
-      name: "RateLimitError",
-      message: "API Error: Too Many Requests (Status: 429)",
-      status: 429,
-      retryAfter: 1,
-    });
-
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it("respects throttle limits without exceeding rate", async () => {
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-      throttle: { rate: 5, burst: 5 },
-    });
-
-    const appId = QB_APP_ID;
-
-    const mockResponse: GetApp200Response = {
-      id: appId,
-      name: "TestApp",
-      created: "2025-01-01T00:00:00Z",
-      updated: "2025-01-02T00:00:00Z",
-      description: "Test app",
-      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,
-      },
-    };
-
-    mockFetch.mockResolvedValue({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve(mockResponse),
-    });
-
-    const startTime = Date.now();
-    await Promise.all([
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-      client.getApp({ appId }),
-      client.getApp({ appId }), // 6th call triggers throttle
-    ]);
-    const endTime = Date.now();
-    const durationMs = endTime - startTime;
-
-    expect(mockFetch).toHaveBeenCalledTimes(6);
-    expect(durationMs).toBeGreaterThanOrEqual(200);
-    expect(durationMs).toBeLessThan(1000);
-  });
-});

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

@@ -1,112 +0,0 @@
-// tests/vitest/unit/records/deleteRecords.test.ts
-import { describe, expect, test, beforeEach } from "vitest";
-import {
-  createClient,
-  mockFetch,
-  QB_REALM,
-  QB_USER_TOKEN,
-  QB_TABLE_ID_1,
-} from "@tests/setup.ts";
-
-describe("QuickbaseClient Unit - deleteRecords", () => {
-  let qb: ReturnType<typeof createClient>;
-
-  beforeEach(() => {
-    mockFetch.mockClear();
-    qb = createClient(mockFetch, { debug: true }); // Use debug: true for consistency with other tests
-  });
-
-  test("sends correct DELETE request and handles success", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve({ numberDeleted: 1 }),
-    });
-
-    const result = await qb.deleteRecords({
-      body: {
-        from: QB_TABLE_ID_1,
-        where: "{3.EX.'5'}", // Simulate deleting Record ID 5
-      },
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      "https://api.quickbase.com/v1/records",
-      expect.objectContaining({
-        method: "DELETE",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify({ from: QB_TABLE_ID_1, where: "{3.EX.'5'}" }),
-      })
-    );
-    expect(result).toEqual({ numberDeleted: 1 });
-  });
-
-  test("handles no records deleted", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve({ numberDeleted: 0 }),
-    });
-
-    const result = await qb.deleteRecords({
-      body: {
-        from: QB_TABLE_ID_1,
-        where: "{3.EX.'999999'}", // Non-existent Record ID
-      },
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      "https://api.quickbase.com/v1/records",
-      expect.objectContaining({
-        method: "DELETE",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify({
-          from: QB_TABLE_ID_1,
-          where: "{3.EX.'999999'}",
-        }),
-      })
-    );
-    expect(result).toEqual({ numberDeleted: 0 });
-  });
-
-  test("throws error on API failure", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      json: () => Promise.resolve({ message: "Invalid query" }),
-    });
-
-    await expect(() =>
-      qb.deleteRecords({
-        body: {
-          from: QB_TABLE_ID_1,
-          where: "{3.EX.'invalid'}",
-        },
-      })
-    ).rejects.toThrow("API Error: Invalid query (Status: 400)");
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      "https://api.quickbase.com/v1/records",
-      expect.objectContaining({
-        method: "DELETE",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-          "Content-Type": "application/json",
-        }),
-        body: JSON.stringify({
-          from: QB_TABLE_ID_1,
-          where: "{3.EX.'invalid'}",
-        }),
-      })
-    );
-  });
-});