quickbase-js 1.1.0-beta.6 → 1.2.0

package/tests/playwright/qb/auth/getTempToken.test.ts

@@ -1,180 +0,0 @@
-// tests/integration/auth/getTempToken.test.ts
-import { test, expect } from "@playwright/test";
-import { quickbase } from "../../../../src/quickbaseClient.ts";
-import fetch from "node-fetch";
-import dotenv from "dotenv";
-
-dotenv.config();
-
-const loginToQuickbase = async (
-  page: import("@playwright/test").Page,
-  quickbaseUrl: string,
-  username: string,
-  password: string
-): Promise<boolean> => {
-  console.log("Logging in to QuickBase");
-  let loginSuccess = false;
-  const maxLoginAttempts = 3;
-  let loginAttempt = 0;
-
-  while (!loginSuccess && loginAttempt < maxLoginAttempts) {
-    try {
-      loginAttempt++;
-      if (loginAttempt > 1) console.log(`Login attempt ${loginAttempt}`);
-
-      await page.goto(quickbaseUrl, { timeout: 60000 });
-      await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-      await page.fill("input[name='loginid']", username);
-      await page.fill("input[name='password']", password);
-      await page.click("#signin");
-      await page.waitForURL(`https://*.quickbase.com/**`, {
-        waitUntil: "networkidle",
-        timeout: 60000,
-      });
-
-      const loginError = await page.$(".login-error");
-      if (loginError) {
-        throw new Error("Login failed. Please check your credentials.");
-      }
-
-      console.log("Signed In to QuickBase.");
-      loginSuccess = true;
-    } catch (error) {
-      console.error(
-        `Login attempt ${loginAttempt} failed: ${(error as Error).message}`
-      );
-      if (loginAttempt >= maxLoginAttempts) {
-        console.error("Max login attempts reached. Exiting.");
-        await page.context().browser()!.close();
-        return false;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  }
-  return loginSuccess;
-};
-
-test.describe("QuickbaseClient Integration - getApp with Temp Tokens", () => {
-  test("uses temp tokens automatically for getApp in browser", async ({
-    page,
-  }) => {
-    const realm = process.env.QB_REALM;
-    const appId = process.env.QB_APP_ID;
-    const username = process.env.QB_USERNAME;
-    const password = process.env.QB_PASSWORD;
-
-    if (!realm) throw new Error("QB_REALM is not defined in .env");
-    if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-    if (!username) throw new Error("QB_USERNAME is not defined in .env");
-    if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-    // Login to QuickBase
-    const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
-    const loginSuccess = await loginToQuickbase(
-      page,
-      quickbaseUrl,
-      username,
-      password
-    );
-    if (!loginSuccess) {
-      throw new Error("Failed to log in to QuickBase after max attempts.");
-    }
-
-    // Navigate to the app page to ensure session context
-    await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-      waitUntil: "networkidle",
-      timeout: 60000,
-    });
-    console.log("Post-login URL after app navigation:", page.url());
-
-    // Define browser fetch function
-    const browserFetch = async (url: string, init?: RequestInit) => {
-      const response = await page.evaluate(
-        async ([fetchUrl, fetchInit]) => {
-          const res = await fetch(fetchUrl, {
-            ...fetchInit,
-            credentials: "include",
-          });
-          const body = await res.text();
-          return {
-            ok: res.ok,
-            status: res.status,
-            statusText: res.statusText,
-            headers: Object.fromEntries(res.headers.entries()),
-            body,
-          };
-        },
-        [url, init] as [string, RequestInit]
-      );
-
-      console.log(`Raw response from ${url}:`, {
-        status: response.status,
-        statusText: response.statusText,
-        body: response.body,
-      });
-
-      const fetchResponse = new Response(response.body || null, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-      });
-
-      fetchResponse.json = async () => {
-        if (!response.body) throw new Error("Empty response body from API");
-        try {
-          return JSON.parse(response.body);
-        } catch (e) {
-          throw new SyntaxError(`Invalid JSON response: ${response.body}`);
-        }
-      };
-
-      return fetchResponse;
-    };
-
-    // Single client with conditional fetch
-    const client = quickbase({
-      realm,
-      useTempTokens: true,
-      debug: true,
-      fetchApi: async (url, init) => {
-        if (url.includes("/auth/temporary/")) {
-          return browserFetch(url, init); // Use browser context for temp token
-        }
-        console.log(`Fetching ${url} with init:`, init);
-        const response = await fetch(url, init as RequestInit); // Node-fetch for API calls
-        const body = await response.text();
-
-        console.log(`Raw response from ${url}:`, {
-          status: response.status,
-          statusText: response.statusText,
-          body,
-        });
-
-        const fetchResponse = new Response(body || null, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: Object.fromEntries(response.headers.entries()),
-        });
-
-        fetchResponse.json = async () => {
-          if (!body) throw new Error("Empty response body from API");
-          try {
-            return JSON.parse(body);
-          } catch (e) {
-            throw new SyntaxError(`Invalid JSON response: ${body}`);
-          }
-        };
-
-        return fetchResponse;
-      },
-    });
-
-    // Call getApp directly, letting the library handle temp token logic
-    const appResult = await client.getApp({ appId });
-    console.log("App response using auto-fetched temp token:", appResult);
-
-    // Validate the app response
-    expect(appResult).toHaveProperty("id", appId);
-    expect(appResult).toHaveProperty("name");
-  });
-});

package/tests/playwright/qb/auth/tokenPrefetch.test.ts

@@ -1,192 +0,0 @@
-// tests/playwright/qb/auth/tokenPrefetch.test.ts
-import { test, expect } from "@playwright/test";
-import { quickbase } from "../../../../src/quickbaseClient.ts";
-import fetch from "node-fetch";
-import dotenv from "dotenv";
-
-dotenv.config();
-
-const loginToQuickbase = async (
-  page: import("@playwright/test").Page,
-  quickbaseUrl: string,
-  username: string,
-  password: string
-): Promise<boolean> => {
-  console.log("Logging in to QuickBase");
-  let loginSuccess = false;
-  const maxLoginAttempts = 3;
-  let loginAttempt = 0;
-
-  while (!loginSuccess && loginAttempt < maxLoginAttempts) {
-    try {
-      loginAttempt++;
-      if (loginAttempt > 1) console.log(`Login attempt ${loginAttempt}`);
-
-      await page.goto(quickbaseUrl, { timeout: 60000 });
-      await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-      await page.fill("input[name='loginid']", username);
-      await page.fill("input[name='password']", password);
-      await page.click("#signin");
-      await page.waitForURL(`https://*.quickbase.com/**`, {
-        waitUntil: "networkidle",
-        timeout: 60000,
-      });
-
-      const loginError = await page.$(".login-error");
-      if (loginError) {
-        throw new Error("Login failed. Please check your credentials.");
-      }
-
-      console.log("Signed In to QuickBase.");
-      loginSuccess = true;
-    } catch (error) {
-      console.error(
-        `Login attempt ${loginAttempt} failed: ${(error as Error).message}`
-      );
-      if (loginAttempt >= maxLoginAttempts) {
-        console.error("Max login attempts reached. Exiting.");
-        await page.context().browser()!.close();
-        return false;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  }
-  return loginSuccess;
-};
-
-test.describe("QuickbaseClient Integration - Token Pre-Fetch and Cache Reuse", () => {
-  test("pre-fetches token and reuses it for subsequent API calls", async ({
-    page,
-  }) => {
-    const realm = process.env.QB_REALM;
-    const appId = process.env.QB_APP_ID;
-    const username = process.env.QB_USERNAME;
-    const password = process.env.QB_PASSWORD;
-
-    if (!realm) throw new Error("QB_REALM is not defined in .env");
-    if (!appId) throw new Error("QB_APP_ID is not defined in .env");
-    if (!username) throw new Error("QB_USERNAME is not defined in .env");
-    if (!password) throw new Error("QB_PASSWORD is not defined in .env");
-
-    // Login to QuickBase
-    const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
-    const loginSuccess = await loginToQuickbase(
-      page,
-      quickbaseUrl,
-      username,
-      password
-    );
-    if (!loginSuccess) {
-      throw new Error("Failed to log in to QuickBase after max attempts.");
-    }
-
-    // Navigate to the app page to ensure session context
-    await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
-      waitUntil: "networkidle",
-      timeout: 60000,
-    });
-    console.log("Post-login URL after app navigation:", page.url());
-
-    // Track tokens and call counts
-    let callCount = 0;
-    let cachedToken: string | null = null;
-
-    const browserFetch = async (url: string, init?: RequestInit) => {
-      console.log(`browserFetch called for ${url}, callCount: ${callCount}`);
-      const response = await page.evaluate(
-        async ([fetchUrl, fetchInit]) => {
-          const res = await fetch(fetchUrl, {
-            ...fetchInit,
-            credentials: "include",
-          });
-          const body = await res.text();
-          return {
-            ok: res.ok,
-            status: res.status,
-            statusText: res.statusText,
-            headers: Object.fromEntries(res.headers.entries()),
-            body,
-          };
-        },
-        [url, init] as [string, RequestInit]
-      );
-
-      console.log(`Raw response from ${url}:`, {
-        status: response.status,
-        statusText: response.statusText,
-        body: response.body,
-      });
-
-      const fetchResponse = new Response(response.body || null, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-      });
-
-      // Capture token from response
-      if (url.includes("/auth/temporary/")) {
-        const json = await fetchResponse.clone().json();
-        const token = json.temporaryAuthorization;
-        cachedToken = token; // Store the pre-fetched token
-        console.log(`Captured pre-fetched token: ${cachedToken}`);
-      }
-
-      return fetchResponse;
-    };
-
-    const client = quickbase({
-      realm,
-      useTempTokens: true,
-      debug: true,
-      fetchApi: async (url, init) => {
-        callCount++;
-        console.log(`fetchApi called for ${url}, callCount: ${callCount}`);
-
-        if (url.includes("/auth/temporary/")) {
-          return browserFetch(url, init); // Use browser fetch for temp tokens
-        }
-
-        // Use node-fetch for app calls, ensuring we track reuse
-        console.log(`Fetching ${url} with init:`, init);
-        const response = await fetch(url, init as RequestInit);
-        const body = await response.text();
-
-        console.log(`Raw response from ${url}:`, {
-          status: response.status,
-          statusText: response.statusText,
-          body,
-        });
-
-        return new Response(body || null, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: Object.fromEntries(response.headers.entries()),
-        });
-      },
-    });
-
-    // Step 1: Pre-fetch token
-    console.log("Pre-fetching token...");
-    const tokenResult = await client.getTempTokenDBID({ dbid: appId });
-    console.log("Pre-fetched token result:", tokenResult);
-    expect(tokenResult).toHaveProperty("temporaryAuthorization");
-    expect(cachedToken).toBe(tokenResult.temporaryAuthorization);
-
-    // Step 2: Call getApp, expecting it to reuse the cached token
-    console.log("Calling getApp with pre-fetched token...");
-    const appResult = await client.getApp({ appId });
-    console.log("App response:", appResult);
-
-    // Validate the app response
-    expect(appResult).toHaveProperty("id", appId);
-    expect(appResult).toHaveProperty("name");
-
-    // Verify call count and token reuse
-    console.log(`Final callCount: ${callCount}`);
-    expect(callCount).toBe(2); // One for pre-fetch, one for getApp
-    expect(cachedToken).toBeDefined();
-
-    // Check that getApp reused the token by inspecting logs manually or adding a header check if needed
-    console.log(`Pre-fetched token: ${cachedToken}`);
-  });
-});

package/tests/playwright/qb/auth/tokenRenewal.test.ts

@@ -1,110 +0,0 @@
-// tests/playwright/qb/auth/tokenRenewal.test.ts
-import { test, expect } from "@playwright/test";
-import { quickbase } from "../../../../src/quickbaseClient.ts";
-import dotenv from "dotenv";
-
-dotenv.config();
-
-const loginToQuickbase = async (
-  page,
-  quickbaseUrl,
-  username,
-  password,
-  appUrl
-) => {
-  console.log("Logging in to QuickBase");
-  await page.goto(quickbaseUrl, { timeout: 60000 });
-  await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
-  await page.fill("input[name='loginid']", username);
-  await page.fill("input[name='password']", password);
-  await page.click("#signin");
-  await page.waitForURL(`https://*.quickbase.com/**`, {
-    waitUntil: "networkidle",
-    timeout: 60000,
-  });
-  console.log("Signed In to QuickBase.");
-  await page.goto(appUrl, { waitUntil: "networkidle", timeout: 60000 });
-  console.log("Navigated to app URL:", page.url());
-};
-
-test.describe("QuickbaseClient Integration - Temp Token Renewal", () => {
-  test("renews temp token after 5 minutes with getApp → wait → getApp sequence", async ({
-    page,
-  }) => {
-    const realm = process.env.QB_REALM!;
-    const appId = process.env.QB_APP_ID!;
-    const username = process.env.QB_USERNAME!;
-    const password = process.env.QB_PASSWORD!;
-    const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
-    const appUrl = `https://${realm}.quickbase.com/db/${appId}`;
-
-    await loginToQuickbase(page, quickbaseUrl, username, password, appUrl);
-
-    const browserFetch = async (
-      url: string,
-      init: RequestInit
-    ): Promise<Response> => {
-      const response = await page.request.fetch(url, {
-        method: init.method || "GET",
-        headers: {
-          ...init.headers,
-          Referer: `https://${realm}.quickbase.com/db/${appId}`,
-          Origin: `https://${realm}.quickbase.com`,
-        },
-        data: init.body,
-        credentials: "include",
-      });
-      const body = await response.text();
-      console.log(
-        "Response from:",
-        url,
-        "status:",
-        response.status(),
-        "body:",
-        body
-      );
-      return new Response(body, {
-        status: response.status(),
-        statusText: response.statusText(),
-        headers: response.headers(),
-      });
-    };
-
-    const client = quickbase({
-      realm,
-      useTempTokens: true,
-      debug: true,
-      fetchApi: browserFetch,
-    });
-
-    console.log("Checking session state before getApp...");
-    const cookies = await page.context().cookies();
-    const sessionCookie = cookies.find(
-      (c) => c.name === "TICKET" || c.name.startsWith("TICKET_")
-    );
-    console.log(
-      "Session cookie present:",
-      !!sessionCookie,
-      "Cookies:",
-      cookies
-    );
-    if (!sessionCookie) throw new Error("TICKET session cookie not found");
-
-    await page.waitForTimeout(5000); // Debug delay
-    console.log("Cookies after delay:", await page.context().cookies());
-
-    const appResult1 = await client.getApp({ appId });
-    console.log("First getApp response:", appResult1);
-    expect(appResult1.id).toBe(appId);
-
-    console.log("Waiting 5 minutes to test token expiration...");
-    await new Promise((resolve) => setTimeout(resolve, 5 * 60 * 1000));
-
-    await page.reload({ waitUntil: "load", timeout: 60000 });
-    console.log("Refreshed page after 5 minutes, URL:", page.url());
-
-    const appResult2 = await client.getApp({ appId });
-    console.log("Second getApp response:", appResult2);
-    expect(appResult2.id).toBe(appId);
-  });
-});

package/tests/playwright/qb/auth/umd.test.ts

@@ -1,10 +0,0 @@
-// tests/playwright/qb/auth/umd.test.ts
-import { test, expect } from "@playwright/test";
-test("UMD build works in browser", async ({ page }) => {
-  await page.goto("http://localhost:3000/test-umd.html");
-  const result = await page.evaluate(() => {
-    const qb = new QuickbaseJS({ realm: "example", useTempTokens: true });
-    return qb.getTempTokenDBID({ dbid: "test-dbid" });
-  });
-  expect(result).toBeTruthy();
-});

package/tests/setup.ts

@@ -1,51 +0,0 @@
-// @tests/setup.ts
-import { vi } from "vitest";
-import { quickbase } from "../src/quickbaseClient.ts";
-import type { QuickbaseConfig } from "../src/quickbaseClient.ts";
-import dotenv from "dotenv";
-
-// Load environment variables from .env file
-dotenv.config({ path: "./.env" }); // Assumes .env is at project root
-
-export const mockFetch = vi.fn();
-
-export const QB_REALM = process.env.QB_REALM || "test-realm";
-export const QB_USER_TOKEN =
-  process.env.QB_USER_TOKEN || "user-token-1234567890";
-export const QB_APP_ID = process.env.QB_APP_ID || "app-id-1234567890";
-export const QB_TABLE_ID_1 =
-  process.env.QB_TABLE_ID_1 || "table-id-1-1234567890";
-export const QB_TABLE_ID_2 =
-  process.env.QB_TABLE_ID_2 || "table-id-2-1234567890";
-
-// Mock env variables for consistency, using .env values if available
-vi.stubEnv("QB_REALM", QB_REALM);
-vi.stubEnv("QB_USER_TOKEN", QB_USER_TOKEN);
-vi.stubEnv("QB_APP_ID", QB_APP_ID);
-vi.stubEnv("QB_TABLE_ID_1", QB_TABLE_ID_1);
-vi.stubEnv("QB_TABLE_ID_2", QB_TABLE_ID_2);
-
-export const createClient = (
-  fetchApi?: any,
-  config: Partial<QuickbaseConfig> = {}
-) => {
-  // Use loaded env vars with fallbacks for safety
-  const realm = QB_REALM;
-  const userToken = QB_USER_TOKEN;
-
-  const client = quickbase({
-    realm,
-    userToken,
-    debug: true,
-    fetchApi,
-    ...config, // Allow overrides if provided
-  });
-  console.log("[createClient] Config:", {
-    realm,
-    userToken,
-    debug: true,
-    ...config,
-  });
-  console.log("[createClient] Returning:", client);
-  return client;
-};

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

@@ -1,76 +0,0 @@
-// tests/vitest/qb/apps/copyApp.test.ts
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - copyApp > creates a new copied app in QuickBase",
-  { timeout: 30000 }, // Increased to 30 seconds
-  async () => {
-    const config = {
-      realm: process.env.QB_REALM || "",
-      userToken: process.env.QB_USER_TOKEN || "",
-      debug: true,
-    };
-    const client = quickbase(config);
-    const appId = process.env.QB_APP_ID || ""; // The source app ID to copy from
-
-    const copyAppName = `CopiedApp_${Date.now()}`; // Unique name to avoid conflicts
-    const copyBody = {
-      name: copyAppName,
-      description: "Test copied app",
-      properties: {
-        keepData: false,
-        excludeFiles: true,
-        usersAndRoles: false,
-        assignUserToken: true,
-      },
-    };
-
-    console.log("Config used:", {
-      ...config,
-      userToken: config.userToken ? "[REDACTED]" : "", // Avoid logging sensitive token
-    });
-    console.log("Copying app with:", copyBody);
-    const startTime = Date.now();
-    let response;
-    try {
-      response = await client.copyApp({ appId, body: copyBody });
-      const duration = Date.now() - startTime;
-      console.log(`copyApp completed in ${duration}ms`);
-      console.log("Real API response:", response);
-
-      expect(response).toBeDefined();
-      expect(response.id).toBeDefined();
-      expect(response.name).toBe(copyAppName);
-      expect(response.description).toBe(copyBody.description);
-      expect(response.created).toBeInstanceOf(Date);
-      expect(response.updated).toBeInstanceOf(Date);
-      expect(response.dateFormat).toMatch(/^\w{2}-\w{2}-\w{4}$/); // e.g., "MM-DD-YYYY"
-      expect(typeof response.timeZone).toBe("string"); // Simplified check
-      expect(typeof response.hasEveryoneOnTheInternet).toBe("boolean");
-      expect(response.ancestorId).toBe(appId); // Should match the source app ID
-      expect(
-        response.dataClassification === undefined ||
-          typeof response.dataClassification === "string"
-      ).toBe(true); // Allow undefined or string
-      expect(
-        response.variables === undefined || Array.isArray(response.variables)
-      ).toBe(true); // Allow undefined or array
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      console.error(`copyApp failed after ${duration}ms:`, error);
-      throw error; // Re-throw to fail the test
-    }
-
-    // Cleanup: Delete the copied app using deleteApp
-    const deleteStartTime = Date.now();
-    const deleteResponse = await client.deleteApp({
-      appId: response.id,
-      body: { name: copyAppName },
-    });
-    const deleteDuration = Date.now() - deleteStartTime;
-    console.log(`deleteApp completed in ${deleteDuration}ms`);
-    console.log("Cleanup - Deleted app:", deleteResponse);
-    expect(deleteResponse.deletedAppId).toBe(response.id);
-  }
-);

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

@@ -1,64 +0,0 @@
-// tests/vitest/qb/apps/createApp.test.ts
-import { test, expect } from "vitest";
-import { quickbase } from "../../../../src/quickbaseClient";
-
-test(
-  "QuickbaseClient Integration - createApp > creates a new 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 = `TestApp_${Date.now()}`;
-    const createBody = {
-      name: appName,
-      description: "Test app creation",
-      assignToken: true,
-    };
-
-    console.log("Config used:", {
-      ...config,
-      userToken: config.userToken ? "[REDACTED]" : "",
-    });
-    console.log("Creating app with:", createBody);
-    const createStartTime = Date.now();
-    let response;
-    try {
-      response = await client.createApp({ body: createBody });
-      const createDuration = Date.now() - createStartTime;
-      console.log(`createApp completed in ${createDuration}ms`);
-      console.log("Real API response:", response);
-
-      expect(response).toBeDefined();
-      expect(response.id).toBeDefined();
-      expect(response.name).toBe(appName);
-      expect(response.description).toBe(createBody.description);
-      expect(response.created).toBeInstanceOf(Date);
-      expect(response.updated).toBeInstanceOf(Date);
-      expect(response.dateFormat).toMatch(/^\w{2}-\w{2}-\w{4}$/);
-      expect(typeof response.timeZone).toBe("string");
-      expect(typeof response.hasEveryoneOnTheInternet).toBe("boolean");
-      expect(
-        response.dataClassification === undefined ||
-          typeof response.dataClassification === "string"
-      ).toBe(true);
-      expect(
-        response.variables === undefined || Array.isArray(response.variables)
-      ).toBe(true);
-
-      // Cleanup: Delete the app after assertions
-      const deleteBody = { name: appName };
-      await client.deleteApp({ appId: response.id, body: deleteBody });
-      console.log("Cleanup: App deleted:", response.id);
-    } catch (error) {
-      const createDuration = Date.now() - createStartTime;
-      console.error(`createApp failed after ${createDuration}ms:`, error);
-      throw error;
-    }
-  }
-);