quickbase-js 1.0.1-beta.0

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

@@ -0,0 +1,180 @@
+// tests/integration/auth/getTempToken.test.ts
+import { test, expect } from "@playwright/test";
+import { quickbaseClient } 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 = quickbaseClient({
+      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

@@ -0,0 +1,192 @@
+// tests/playwright/qb/auth/tokenPrefetch.test.ts
+import { test, expect } from "@playwright/test";
+import { quickbaseClient } 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 = quickbaseClient({
+      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

@@ -0,0 +1,110 @@
+// tests/playwright/qb/auth/tokenRenewal.test.ts
+import { test, expect } from "@playwright/test";
+import { quickbaseClient } 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 = quickbaseClient({
+      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/setup.ts

@@ -0,0 +1,19 @@
+import { quickbaseClient, QuickbaseConfig } from "../src/quickbaseClient.ts";
+import dotenv from "dotenv";
+import { vi } from "vitest";
+
+dotenv.config();
+
+export const createClient = (
+  fetchApi?: any,
+  config: Partial<QuickbaseConfig> = {}
+) =>
+  quickbaseClient({
+    realm: process.env.QB_REALM || "default-realm",
+    userToken: process.env.QB_USER_TOKEN || "default-token",
+    debug: true,
+    fetchApi,
+    ...config,
+  });
+
+export const mockFetch = vi.fn();

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

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { createClient } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - getApp", () => {
+  const client = createClient();
+
+  it(
+    "fetches real app data from QuickBase",
+    async () => {
+      const getAppId = process.env.QB_APP_ID;
+      if (!getAppId) throw new Error("QB_APP_ID is not defined in .env");
+      if (!process.env.QB_REALM)
+        throw new Error("QB_REALM is not defined in .env");
+      if (!process.env.QB_USER_TOKEN)
+        throw new Error("QB_USER_TOKEN is not defined in .env");
+
+      console.log("Config used:", {
+        realm: process.env.QB_REALM,
+        userToken: process.env.QB_USER_TOKEN,
+        appId: getAppId,
+      });
+      const result = await client.getApp({ appId: getAppId });
+      console.log("Real API response:", result);
+      expect(result).toEqual({
+        id: getAppId,
+        name: "qb-copy",
+        created: new Date("2025-02-13T18:22:33Z"),
+        updated: new Date("2025-03-04T04:25:51Z"),
+        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,
+        },
+      });
+    },
+    { timeout: 10000 }
+  );
+});