quickbase-js 1.0.1-beta.0 → 1.1.0-beta.1

package/tests/vitest/unit/tables/getTable.test.ts

@@ -0,0 +1,233 @@
+// tests/vitest/unit/tables/getTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_TABLE_ID_1,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getTable", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  it("calls getTable successfully with user token", async () => {
+    client = createClient(mockFetch, { debug: true });
+
+    const mockResponse = {
+      id: QB_TABLE_ID_1,
+      name: "Root",
+      alias: "_DBID_ROOT",
+      description: "",
+      created: new Date("2025-02-13T18:22:33.000Z"),
+      updated: new Date("2025-02-13T18:22:34.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Root",
+      pluralRecordName: "Roots",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const response = await client.getTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+      })
+    );
+  });
+
+  it("calls getTable successfully with temp token", async () => {
+    client = createClient(mockFetch, { debug: true, useTempTokens: true });
+
+    const mockResponse = {
+      id: QB_TABLE_ID_1,
+      name: "Root",
+      alias: "_DBID_ROOT",
+      description: "",
+      created: new Date("2025-02-13T18:22:33.000Z"),
+      updated: new Date("2025-02-13T18:22:34.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Root",
+      pluralRecordName: "Roots",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const response = await client.getTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: "QB-TEMP-TOKEN temp_token",
+        }),
+      })
+    );
+  });
+
+  it("retries successfully after 401 with temp token", async () => {
+    client = createClient(mockFetch, { debug: true, useTempTokens: true });
+
+    const mockResponse = {
+      id: QB_TABLE_ID_1,
+      name: "Root",
+      alias: "_DBID_ROOT",
+      description: "",
+      created: new Date("2025-02-13T18:22:33.000Z"),
+      updated: new Date("2025-02-13T18:22:34.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Root",
+      pluralRecordName: "Roots",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({ temporaryAuthorization: "initial_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "new_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const response = await client.getTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN new_token",
+        }),
+      })
+    );
+  });
+
+  it("handles 401 with failed temp token retry", async () => {
+    client = createClient(mockFetch, { debug: true, useTempTokens: true });
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({ temporaryAuthorization: "initial_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () =>
+          Promise.resolve({ message: "Unauthorized in fetchTempToken" }),
+      });
+
+    await expect(
+      client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
+    ).rejects.toThrow(
+      "API Error: Unauthorized in fetchTempToken (Status: 401)"
+    );
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+  });
+
+  it("handles 404 Not Found", async () => {
+    client = createClient(mockFetch, { debug: true });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      json: () => Promise.resolve({ message: "Table not found" }),
+    });
+
+    await expect(
+      client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
+    ).rejects.toThrow("API Error: Table not found (Status: 404)");
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+      })
+    );
+  });
+});

package/tests/vitest/unit/tables/updateTable.test.ts

@@ -0,0 +1,80 @@
+// tests/vitest/unit/records/updateTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - updateTable", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true });
+  });
+
+  it("calls updateTable successfully with temp token", async () => {
+    client = createClient(mockFetch, { debug: true, useTempTokens: true });
+
+    const mockBody = {
+      name: "Updated Root",
+      description: "Updated description",
+    };
+    const mockResponse = {
+      id: QB_TABLE_ID_1,
+      name: "Updated Root",
+      alias: "_DBID_ROOT",
+      description: "Updated description",
+      created: new Date("2025-02-13T18:22:33.000Z"),
+      updated: new Date("2025-03-10T12:00:00.000Z"),
+      nextRecordId: 1,
+      nextFieldId: 6,
+      defaultSortFieldId: 2,
+      defaultSortOrder: "DESC",
+      keyFieldId: 3,
+      singleRecordName: "Root",
+      pluralRecordName: "Roots",
+      sizeLimit: "500 MB",
+      spaceUsed: "0 KB",
+      spaceRemaining: "500 MB",
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+    const response = await client.updateTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+      body: mockBody,
+    });
+    expect(response).toEqual(mockResponse);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          Authorization: "QB-TEMP-TOKEN temp_token",
+          "Content-Type": "application/json",
+        }),
+        body: JSON.stringify(mockBody),
+      })
+    );
+  });
+});

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "ESNext",
     "moduleResolution": "bundler",
     "strict": true,
-    "lib": ["ES2015", "ESNext", "DOM"], // Explicitly include ES2015 for Record
+    "lib": ["ES2015", "ESNext", "DOM"],
     "types": ["node", "playwright/test"],
     "esModuleInterop": true,
     "resolveJsonModule": true,
@@ -16,7 +16,8 @@
     "sourceMap": true,
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./*"]
+      "@/*": ["src/*"],      // Matches Vite's @ -> src/
+      "@tests/*": ["tests/*"] // Matches Vite's @tests -> tests/
     }
   },
   "include": ["src/**/*", "tests/**/*"],

package/vitest.config.ts

@@ -1,11 +1,16 @@
+// vitest.config.ts
 import { defineConfig } from "vitest/config";
 import path from "path";
+import dotenv from "dotenv"; // Add this import
+
+// Load .env variables before tests run
+dotenv.config({ path: path.resolve(__dirname, ".env") });
 
 export default defineConfig({
   test: {
     environment: "jsdom",
     include: ["tests/vitest/**/**/*.test.ts"],
-    setupFiles: ["tests/setup.ts"],
+    setupFiles: ["tests/setup.ts"], // Relative path from root
     pool: "forks",
     poolOptions: {
       forks: {
@@ -15,7 +20,8 @@ export default defineConfig({
   },
   resolve: {
     alias: {
-      "@": path.resolve(__dirname, "./"),
+      "@": path.resolve(__dirname, "./src"), // For src/ imports
+      "@tests": path.resolve(__dirname, "./tests"), // For tests/ imports
     },
   },
 });