quickbase-js 0.1.0-beta.7

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

@@ -0,0 +1,152 @@
+import { test, expect } from "@playwright/test";
+import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient.ts";
+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 || !appId || !username || !password) {
+      throw new Error(
+        "Required QuickBase environment variables are not defined"
+      );
+    }
+
+    // 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());
+
+    // Single client with browser-based fetch
+    const client = quickbase({
+      realm,
+      useTempTokens: true,
+      debug: true,
+      fetchApi: async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = input.toString();
+        console.log(`Fetching ${url} with init:`, init);
+        const effectiveInit = init || {};
+        const response = await page.evaluate(
+          async ([fetchUrl, fetchInit]: [string, RequestInit]) => {
+            const res = await fetch(fetchUrl, fetchInit); // Rely on quickbaseClient.ts for credentials
+            const body = await res.text();
+            const headersObj: Record<string, string> = {};
+            res.headers.forEach((value, key) => {
+              headersObj[key] = value;
+            });
+            return {
+              ok: res.ok,
+              status: res.status,
+              statusText: res.statusText,
+              headers: headersObj,
+              body,
+            };
+          },
+          [url, effectiveInit] 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: new 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;
+      },
+    }) as QuickbaseClient;
+
+    // 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

@@ -0,0 +1,179 @@
+import { test, expect } from "@playwright/test";
+import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient.ts";
+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 || !appId || !username || !password) {
+      throw new Error(
+        "Required QuickBase environment variables are not defined"
+      );
+    }
+
+    // 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 client = quickbase({
+      realm,
+      useTempTokens: true,
+      debug: true,
+      fetchApi: async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = input.toString();
+        callCount++;
+        console.log(`fetchApi called for ${url}, callCount: ${callCount}`);
+
+        const effectiveInit = init || {};
+        const response = await page.evaluate(
+          async ([fetchUrl, fetchInit]: [string, RequestInit]) => {
+            const res = await fetch(fetchUrl, fetchInit); // Rely on quickbaseClient.ts for credentials
+            const body = await res.text();
+            const headersObj: Record<string, string> = {};
+            res.headers.forEach((value, key) => {
+              headersObj[key] = value;
+            });
+            return {
+              ok: res.ok,
+              status: res.status,
+              statusText: res.statusText,
+              headers: headersObj,
+              body,
+            };
+          },
+          [url, effectiveInit] 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: new 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}`);
+          }
+        };
+
+        // 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;
+      },
+    }) as QuickbaseClient;
+
+    // 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();
+    console.log(`Pre-fetched token: ${cachedToken}`);
+  });
+});

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

@@ -0,0 +1,133 @@
+import { test, expect } from "@playwright/test";
+import { quickbase, QuickbaseClient } from "../../../../src/quickbaseClient.ts";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const loginToQuickbase = async (
+  page: import("@playwright/test").Page,
+  quickbaseUrl: string,
+  username: string,
+  password: string,
+  appUrl: string
+): Promise<void> => {
+  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 ?? "";
+
+    if (!realm || !appId || !username || !password) {
+      throw new Error(
+        "Required QuickBase environment variables are not defined"
+      );
+    }
+
+    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 client = quickbase({
+      realm,
+      useTempTokens: true,
+      debug: true,
+      fetchApi: async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = input.toString();
+        console.log(`Fetching ${url} with init:`, init);
+        const effectiveInit = init || {};
+        const response = await page.evaluate(
+          async ([fetchUrl, fetchInit]: [string, RequestInit]) => {
+            const res = await fetch(fetchUrl, fetchInit); // Rely on quickbaseClient.ts for credentials
+            const body = await res.text();
+            const headersObj: Record<string, string> = {};
+            res.headers.forEach((value, key) => {
+              headersObj[key] = value;
+            });
+            return {
+              ok: res.ok,
+              status: res.status,
+              statusText: res.statusText,
+              headers: headersObj,
+              body,
+            };
+          },
+          [url, effectiveInit] 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: new 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;
+      },
+    }) as QuickbaseClient;
+
+    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).toHaveProperty("id", 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).toHaveProperty("id", appId);
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,51 @@
+// @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

@@ -0,0 +1,76 @@
+// 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

@@ -0,0 +1,64 @@
+// 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;
+    }
+  }
+);