quickbase-js 0.1.0-beta.8 → 1.0.0

package/tests/vitest/qb/apps/deleteApp.test.ts

@@ -1,76 +0,0 @@
-// tests/vitest/qb/apps/deleteApp.test.ts
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - deleteApp > deletes an app in QuickBase",
-  { timeout: 30000 },
-  async () => {
-    const config = {
-      realm: process.env.QB_REALM || "",
-      userToken: process.env.QB_USER_TOKEN || "",
-      debug: true,
-      useTempTokens: false,
-    };
-    const client = quickbase(config);
-
-    const appName = `TempApp_${Date.now()}`;
-    const createBody = {
-      name: appName,
-      description: "Temporary app for deleteApp test",
-      assignToken: true, // Match createApp.test.ts
-    };
-
-    console.log("Config used:", {
-      ...config,
-      userToken: config.userToken ? "[REDACTED]" : "",
-    });
-    console.log("Creating temporary app with:", createBody);
-    const createStartTime = Date.now();
-    let createResponse;
-    try {
-      createResponse = await client.createApp({ body: createBody });
-      const createDuration = Date.now() - createStartTime;
-      console.log(`createApp completed in ${createDuration}ms`);
-      console.log("Created app response:", createResponse);
-
-      expect(createResponse).toBeDefined();
-      expect(createResponse.id).toBeDefined();
-      expect(createResponse.name).toBe(appName);
-    } catch (error) {
-      const createDuration = Date.now() - createStartTime;
-      console.error(`createApp failed after ${createDuration}ms:`, error);
-      throw error;
-    }
-
-    const deleteBody = {
-      name: appName,
-    };
-    console.log("Deleting app with:", deleteBody);
-    const deleteStartTime = Date.now();
-    try {
-      const deleteResponse = await client.deleteApp({
-        appId: createResponse.id,
-        body: deleteBody,
-      });
-      const deleteDuration = Date.now() - deleteStartTime;
-      console.log(`deleteApp completed in ${deleteDuration}ms`);
-      console.log("Delete app response:", deleteResponse);
-
-      expect(deleteResponse).toBeDefined();
-      expect(deleteResponse.deletedAppId).toBe(createResponse.id);
-    } catch (error) {
-      const deleteDuration = Date.now() - deleteStartTime;
-      console.error(`deleteApp failed after ${deleteDuration}ms:`, error);
-      if (error instanceof Error && "response" in error) {
-        try {
-          const errorBody = await (error as any).response.json();
-          console.error("Full deleteApp error response:", errorBody);
-        } catch (e) {
-          console.error("Could not parse error response:", e);
-        }
-      }
-      throw error;
-    }
-  }
-);

package/tests/vitest/qb/apps/getApp.test.ts

@@ -1,44 +0,0 @@
-// tests/vitest/qb/apps/getApp.test.ts
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-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";
-
-    console.log("Config used:", config);
-    const result = await client.getApp({ appId: getAppId });
-    console.log("Real API response:", result);
-
-    expect(result).toEqual({
-      id: getAppId,
-      name: "qb-copy",
-      created: expect.any(Date),
-      updated: expect.any(Date),
-      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,
-      },
-      ancestorId: undefined,
-      dataClassification: undefined,
-      variables: [{ name: "TestVar", value: "TestValue" }],
-    });
-  }
-);

package/tests/vitest/qb/apps/getAppEvents.test.ts

@@ -1,67 +0,0 @@
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - getAppEvents > fetches real app events 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 appId = "buwai2zpe"; // Same app ID as getApp test
-
-    console.log("Config used:", config);
-    const result = await client.getAppEvents({ appId });
-    console.log("Real API response:", result);
-
-    // Validate the response is an array of events
-    expect(result).toBeInstanceOf(Array);
-
-    // Check that each event has the required properties
-    result.forEach((event) => {
-      expect(event).toHaveProperty("type");
-      expect([
-        "qb-action",
-        "webhook",
-        "email-notification",
-        "subscription",
-        "reminder",
-        "automation",
-      ]).toContain(event.type);
-
-      expect(event).toHaveProperty("owner");
-      expect(event.owner).toHaveProperty("email");
-      expect(typeof event.owner.email).toBe("string");
-      expect(event.owner).toHaveProperty("id");
-      expect(typeof event.owner.id).toBe("string");
-      expect(event.owner).toHaveProperty("name");
-      expect(typeof event.owner.name).toBe("string");
-      // userName is optional, so we don't enforce it
-
-      expect(event).toHaveProperty("isActive");
-      expect(typeof event.isActive).toBe("boolean");
-
-      expect(event).toHaveProperty("tableId");
-      expect(typeof event.tableId).toBe("string");
-
-      // Name is present for all types except automation
-      if (event.type !== "automation") {
-        expect(event).toHaveProperty("name");
-        expect(typeof event.name).toBe("string");
-      } else {
-        expect(event.name).toBeUndefined();
-      }
-
-      // URL is only present for automation
-      if (event.type === "automation") {
-        expect(event).toHaveProperty("url");
-        expect(typeof event.url).toBe("string");
-      } else {
-        expect(event.url).toBeUndefined();
-      }
-    });
-  }
-);

package/tests/vitest/qb/apps/updateApp.test.ts

@@ -1,58 +0,0 @@
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - updateApp > updates real app 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"; // Same app ID as before
-
-    // Original app data (to restore later if needed)
-    const originalApp = await client.getApp({ appId });
-    console.log("Original app data:", originalApp);
-
-    // Update request
-    const updateRequest = {
-      name: "qb-copy-updated",
-      description: "Updated via integration test",
-      variables: [{ name: "TestVar", value: "TestValue" }],
-    };
-
-    console.log("Config used:", config);
-    console.log("Update request:", updateRequest);
-    const result = await client.updateApp({ appId, body: updateRequest });
-    console.log("Real API response:", result);
-
-    // Validate the response
-    expect(result).toHaveProperty("id", appId);
-    expect(result).toHaveProperty("name", "qb-copy-updated");
-    expect(result).toHaveProperty(
-      "description",
-      "Updated via integration test"
-    );
-    expect(result).toHaveProperty("variables");
-    expect(result.variables).toContainEqual({
-      name: "TestVar",
-      value: "TestValue",
-    });
-    expect(result).toHaveProperty("created");
-    expect(result.created).toBeInstanceOf(Date);
-    expect(result).toHaveProperty("updated");
-    expect(result.updated).toBeInstanceOf(Date);
-
-    // Optional: Restore original name to avoid permanent changes
-    const restoreRequest = {
-      name: originalApp.name,
-      description: originalApp.description,
-      variables: originalApp.variables,
-    };
-    await client.updateApp({ appId, body: restoreRequest });
-    console.log("Restored app to:", originalApp.name);
-  }
-);

package/tests/vitest/qb/auth/retryUserToken401.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, vi, expect, beforeEach } from "vitest";
-import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient";
-import { ResponseError } from "../../../../src/generated/runtime";
-
-describe("QuickbaseClient Integration - User Token Retry on 401", () => {
-  let client: QuickbaseClient;
-  const mockFetch = vi.fn();
-
-  beforeEach(() => {
-    const config = {
-      realm: process.env.QB_REALM || "builderprogram-dbradford6815",
-      userToken: "mock-user-token",
-      debug: true,
-      fetchApi: mockFetch,
-    };
-    console.log("[quickbaseTest] Config:", config);
-    client = quickbase(config);
-  });
-
-  it("retries on transient 401 with user token and succeeds", async () => {
-    const consoleSpy = vi.spyOn(console, "log");
-
-    mockFetch
-      .mockImplementationOnce(() => {
-        const response = new Response(null, {
-          status: 401,
-          statusText: "Unauthorized",
-        });
-        console.log("[mockFetch] Throwing 401 ResponseError");
-        return Promise.reject(new ResponseError(response));
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => [{ id: 1, label: "Mock Field", fieldType: "text" }],
-      });
-
-    const fields = await client.getFields({ tableId: "mock-table-id" });
-
-    expect(fields).toBeInstanceOf(Array);
-    expect(fields.length).toBeGreaterThan(0);
-    expect(fields[0]).toHaveProperty("id");
-    expect(fields[0]).toHaveProperty("label");
-
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "Authorization error for getFields (user token), retrying with same token:",
-      "" // Matches empty ResponseError message from mock
-    );
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "Retrying getFields with user token"
-    );
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-
-    consoleSpy.mockRestore();
-  });
-});

package/tests/vitest/qb/fields/createField.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect, afterAll } from "vitest";
-import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
-
-describe("QuickbaseClient Integration - createField", () => {
-  const client = createClient();
-
-  const createdFieldIds: number[] = [];
-
-  afterAll(async () => {
-    if (createdFieldIds.length > 0) {
-      try {
-        const response = await client.deleteFields({
-          tableId: QB_TABLE_ID_1,
-          body: { fieldIds: createdFieldIds },
-        });
-        console.log(
-          `Cleaned up fields: ${JSON.stringify(response.deletedFieldIds)}`,
-          response.errors && response.errors.length > 0
-            ? `Errors: ${response.errors}`
-            : ""
-        );
-      } catch (error) {
-        console.error("Cleanup failed:", error);
-        console.log(`Fields left in table: ${createdFieldIds}`);
-      }
-    } else {
-      console.log("No fields to clean up.");
-    }
-  });
-
-  it("creates a field with user token", async () => {
-    const uniqueLabel = `TestField_${Date.now()}`;
-    const response = await client.createField({
-      tableId: QB_TABLE_ID_1,
-      body: {
-        label: uniqueLabel,
-        fieldType: "text",
-        fieldHelp: "Created via integration test",
-        addToForms: true,
-      },
-    });
-
-    expect(response.id).toBeDefined();
-    expect(response.label).toBe(uniqueLabel);
-    expect(response.fieldType).toBe("text");
-    expect(response.fieldHelp).toBe("Created via integration test");
-
-    createdFieldIds.push(response.id);
-    console.log(`Created field ${uniqueLabel} with ID ${response.id}`);
-  });
-
-  it("fails with invalid field type", async () => {
-    const uniqueLabel = `InvalidField_${Date.now()}`;
-    await expect(
-      client.createField({
-        tableId: QB_TABLE_ID_1,
-        body: {
-          label: uniqueLabel,
-          fieldType: "invalid_type" as "text", // Type assertion to bypass compile-time check
-          fieldHelp: "Should fail",
-        },
-      })
-    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
-  }, 10000); // Increased timeout to 10 seconds
-
-  it("fails with missing label", async () => {
-    await expect(
-      client.createField({
-        tableId: QB_TABLE_ID_1,
-        body: {
-          label: "",
-          fieldType: "text",
-        },
-      })
-    ).rejects.toThrow("API Error: Invalid input (Status: 400)");
-  });
-});

package/tests/vitest/qb/fields/deleteFields.test.ts

@@ -1,83 +0,0 @@
-// tests/vitest/qb/fields/deleteFields.test.ts
-import { describe, it, expect, beforeAll } from "vitest";
-import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
-
-describe("QuickbaseClient Integration - deleteFields", () => {
-  const client = createClient();
-  let fieldIdsToDelete: number[] = [];
-
-  beforeAll(async () => {
-    try {
-      const fieldLabels = ["DeleteTest1", "DeleteTest2"];
-      for (const label of fieldLabels) {
-        const response = await client.createField({
-          tableId: QB_TABLE_ID_1,
-          body: {
-            label,
-            fieldType: "text",
-            fieldHelp: "Test field for deletion",
-          },
-        });
-        fieldIdsToDelete.push(response.id);
-        console.log(`Created field ${label} with ID ${response.id}`);
-      }
-      if (fieldIdsToDelete.length !== 2) {
-        throw new Error("Failed to create all test fields");
-      }
-    } catch (error) {
-      console.error("beforeAll failed:", error);
-      throw error;
-    }
-  });
-
-  it("deletes fields successfully with user token", async () => {
-    try {
-      const response = await client.deleteFields({
-        tableId: QB_TABLE_ID_1,
-        body: { fieldIds: fieldIdsToDelete },
-      });
-      console.log("deleteFields response:", JSON.stringify(response, null, 2));
-      expect(response).toBeDefined();
-      expect(response.deletedFieldIds).toEqual(
-        expect.arrayContaining(fieldIdsToDelete)
-      );
-      expect(response.errors ?? []).toHaveLength(0);
-    } catch (error) {
-      console.error("deleteFields failed:", error);
-      throw error;
-    }
-  });
-
-  it("handles partial success with errors", { timeout: 10000 }, async () => {
-    const newField = await client.createField({
-      tableId: QB_TABLE_ID_1,
-      body: { label: "DeleteTest3", fieldType: "text" },
-    });
-    console.log(`Created field DeleteTest3 with ID ${newField.id}`);
-
-    const invalidFieldId = 999999;
-    const fieldIds = [newField.id, invalidFieldId];
-
-    console.log("Sending deleteFields request at:", new Date());
-    const response = await client.deleteFields({
-      tableId: QB_TABLE_ID_1,
-      body: { fieldIds },
-    });
-    console.log("deleteFields response received at:", new Date());
-    console.log("Response:", JSON.stringify(response, null, 2));
-
-    expect(response.deletedFieldIds).toContain(newField.id);
-    expect(response.deletedFieldIds).not.toContain(invalidFieldId);
-    expect(response.errors).toHaveLength(1);
-    expect(response.errors[0]).toMatch(/Field: 999999 was not found/i);
-  });
-
-  it("fails with invalid request (empty fieldIds)", async () => {
-    await expect(
-      client.deleteFields({
-        tableId: QB_TABLE_ID_1,
-        body: { fieldIds: [] },
-      })
-    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
-  });
-});

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

@@ -1,85 +0,0 @@
-// tests/vitest/qb/fields/getField.test.ts
-import { describe, it, expect } from "vitest";
-import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
-
-describe("QuickbaseClient Integration - getField", () => {
-  const client = createClient();
-
-  it("retrieves an existing field with user token", async () => {
-    // Create a field to ensure we have a known field ID to retrieve
-    const uniqueLabel = `TestField_${Date.now()}`;
-    const createResponse = await client.createField({
-      tableId: QB_TABLE_ID_1,
-      body: {
-        label: uniqueLabel,
-        fieldType: "text",
-        fieldHelp: "Created for getField integration test",
-        addToForms: true,
-      },
-    });
-
-    expect(createResponse.id).toBeDefined();
-    const fieldId = createResponse.id;
-    console.log(`Created field ${uniqueLabel} with ID ${fieldId} for testing`);
-
-    // Test getField with the created field
-    const response = await client.getField({
-      fieldId: fieldId,
-      tableId: QB_TABLE_ID_1,
-      includeFieldPerms: true,
-    });
-
-    expect(response.id).toBe(fieldId);
-    expect(response.label).toBe(uniqueLabel);
-    expect(response.fieldType).toBe("text");
-    expect(response.fieldHelp).toBe("Created for getField integration test");
-    expect(response.permissions).toBeDefined();
-    expect(Array.isArray(response.permissions)).toBe(true);
-    console.log(`Retrieved field ${response.label} with ID ${response.id}`);
-
-    // Clean up the created field
-    try {
-      const deleteResponse = await client.deleteFields({
-        tableId: QB_TABLE_ID_1,
-        body: { fieldIds: [fieldId] },
-      });
-      console.log(
-        `Cleaned up field ${fieldId}: ${JSON.stringify(deleteResponse)}`
-      );
-    } catch (error) {
-      console.error(`Failed to clean up field ${fieldId}:`, error);
-    }
-  }, 10000); // Increase timeout to 10 seconds
-
-  it("fails with non-existent field ID", async () => {
-    const nonExistentFieldId = 999999; // Assuming this ID doesn’t exist
-    await expect(
-      client.getField({
-        fieldId: nonExistentFieldId,
-        tableId: QB_TABLE_ID_1,
-      })
-    ).rejects.toMatchObject({
-      message: expect.stringContaining(
-        "API Error: No such field (Status: 404)"
-      ),
-    });
-    console.log(
-      `Confirmed 404 for non-existent field ID ${nonExistentFieldId}`
-    );
-  });
-
-  it("fails with invalid table ID", async () => {
-    const invalidTableId = "invalid_dbid";
-    await expect(
-      client.getField({
-        fieldId: 1, // Arbitrary field ID
-        tableId: invalidTableId,
-      })
-    ).rejects.toMatchObject({
-      message: expect.stringContaining(
-        "API Error: Invalid request (Status: 400)"
-      ),
-    });
-    console.log(`Confirmed 400 for invalid table ID ${invalidTableId}`);
-  });
-});