quickbase-js 0.1.0-beta.8 → 0.1.0-beta.9

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

@@ -1,5 +1,3 @@
-// tests/vitest/unit/tables/updateRelationship.test.ts
-
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import {
   createClient,
@@ -76,7 +74,7 @@ describe("QuickbaseClient Unit - updateRelationship", () => {
 
     expect(result).toEqual(mockResponse);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`, // Changed to singular
+      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`,
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
@@ -156,7 +154,7 @@ describe("QuickbaseClient Unit - updateRelationship", () => {
     );
     expect(mockFetch).toHaveBeenNthCalledWith(
       2,
-      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`, // Changed to singular
+      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`,
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
@@ -233,7 +231,7 @@ describe("QuickbaseClient Unit - updateRelationship", () => {
     );
     expect(mockFetch).toHaveBeenNthCalledWith(
       2,
-      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`, // Changed to singular
+      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`,
       expect.objectContaining({
         headers: expect.objectContaining({
           Authorization: "QB-TEMP-TOKEN initial_token",
@@ -247,20 +245,24 @@ describe("QuickbaseClient Unit - updateRelationship", () => {
     );
     expect(mockFetch).toHaveBeenNthCalledWith(
       4,
-      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`, // Changed to singular
+      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`,
       expect.objectContaining({
         headers: expect.objectContaining({
           Authorization: "QB-TEMP-TOKEN new_token",
         }),
       })
     );
+
+    // Updated log expectations
     expect(consoleSpy).toHaveBeenCalledWith(
-      "Authorization error for updateRelationship (temp token), refreshing token:",
-      expect.any(String)
+      "Authorization error for updateRelationship (temp token), refreshing token:"
     );
     expect(consoleSpy).toHaveBeenCalledWith(
-      "Retrying updateRelationship with temp token"
+      expect.stringContaining(
+        "[updateRelationship] Retrying with token: new_tok"
+      )
     );
+
     consoleSpy.mockRestore();
   });
 
@@ -289,7 +291,7 @@ describe("QuickbaseClient Unit - updateRelationship", () => {
     ).rejects.toThrow("API Error: Invalid field ID (Status: 400)");
 
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`, // Changed to singular
+      `https://api.quickbase.com/v1/tables/${tableId}/relationship/${relationshipId}`,
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({

package/tests/vitest/unit/tokenLifespan.test.ts

@@ -1,120 +1,184 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { createClient, mockFetch, QB_APP_ID, QB_REALM } from "@tests/setup.ts";
 import { UpdateAppRequest, UpdateApp200Response } from "@/generated/models";
 
 describe("QuickbaseClient Unit - Token Lifespan", () => {
   let client: ReturnType<typeof createClient>;
+  const request: UpdateAppRequest = { name: "Test App" };
+  const mockResponse: UpdateApp200Response = {
+    id: QB_APP_ID,
+    name: "Test App",
+    description: "",
+    created: new Date("2020-01-01T00:00:00Z"), // Match deserialized Date object
+    updated: new Date("2020-01-01T00:00:00Z"),
+    dateFormat: "MM-DD-YYYY",
+    timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+    hasEveryoneOnTheInternet: false,
+    ancestorId: undefined,
+    variables: [],
+    securityProperties: {},
+    memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+    dataClassification: "None",
+  };
 
   beforeEach(() => {
     mockFetch.mockClear();
+    vi.useFakeTimers();
+    console.log("[beforeEach] mockFetch cleared and fake timers enabled");
   });
 
-  it("reuses token within lifespan and fetches new token after expiration", async () => {
-    // Set a short lifespan of 500ms for testing
-    client = createClient(mockFetch, {
-      realm: QB_REALM,
-      useTempTokens: true,
-      tokenLifespan: 500, // 0.5 seconds
-      debug: true,
-    });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
 
-    const request: UpdateAppRequest = {
-      name: "Test App",
-    };
-    const mockResponse: UpdateApp200Response = {
-      id: QB_APP_ID,
-      name: "Test App",
-      description: "",
-      created: new Date("2020-01-01T00:00:00Z"),
-      updated: new Date("2020-01-01T00:00:00Z"),
-      dateFormat: "MM-DD-YYYY",
-      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-      hasEveryoneOnTheInternet: false,
-      ancestorId: null,
-      variables: [],
-      securityProperties: {},
-      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-      dataClassification: "None",
-    };
-
-    // First call: Fetch a new token
+  const setupMocks = (token: string) => {
     mockFetch
       .mockResolvedValueOnce({
         ok: true,
         status: 200,
-        json: () => Promise.resolve({ temporaryAuthorization: "token1" }),
+        json: () => Promise.resolve({ temporaryAuthorization: token }),
       })
       .mockResolvedValueOnce({
         ok: true,
         status: 200,
         json: () => Promise.resolve(mockResponse),
       });
+  };
+
+  it("reuses token within custom lifespan and refetches after expiration", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true,
+      tempTokenLifespan: 500,
+      debug: true,
+    });
 
+    setupMocks("token1");
     await client.updateApp({ appId: QB_APP_ID, body: request });
-    expect(mockFetch).toHaveBeenCalledTimes(2); // Token fetch + API call
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token1"
+    );
 
-    // Second call within lifespan: Should reuse token1
     mockFetch.mockResolvedValueOnce({
       ok: true,
       status: 200,
       json: () => Promise.resolve(mockResponse),
     });
     await client.updateApp({ appId: QB_APP_ID, body: request });
-    expect(mockFetch).toHaveBeenCalledTimes(3); // Only API call, no new token fetch
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch.mock.calls[2][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token1"
+    );
 
-    // Wait for token to expire (500ms + buffer)
-    await new Promise((resolve) => setTimeout(resolve, 600));
+    vi.advanceTimersByTime(500);
+    console.log("[Test 1] Token expired after 500ms");
 
-    // Third call after expiration: Should fetch a new token
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve({ temporaryAuthorization: "token2" }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(mockResponse),
-      });
+    setupMocks("token2");
     await client.updateApp({ appId: QB_APP_ID, body: request });
-    expect(mockFetch).toHaveBeenCalledTimes(5); // New token fetch + API call
+    expect(mockFetch).toHaveBeenCalledTimes(5);
+    expect(mockFetch.mock.calls[4][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token2"
+    );
   });
 
-  it("uses default lifespan when not specified", async () => {
-    // No tokenLifespan provided, should use default (4:50 = 290,000ms)
+  it("reuses token within default lifespan of 4m50s", async () => {
     client = createClient(mockFetch, {
       realm: QB_REALM,
       useTempTokens: true,
       debug: true,
     });
 
-    const request: UpdateAppRequest = {
-      name: "Default Lifespan Test",
-    };
-    const mockResponse: UpdateApp200Response = {
-      id: QB_APP_ID,
-      name: "Default Lifespan Test",
-      description: "",
-      created: new Date("2020-01-01T00:00:00Z"),
-      updated: new Date("2020-01-01T00:00:00Z"),
-      dateFormat: "MM-DD-YYYY",
-      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-      hasEveryoneOnTheInternet: false,
-      ancestorId: null,
-      variables: [],
-      securityProperties: {},
-      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-      dataClassification: "None",
-    };
-
-    // First call: Fetch a new token
+    setupMocks("default_token");
+    await client.updateApp({ appId: QB_APP_ID, body: request });
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN default_token"
+    );
+
+    vi.advanceTimersByTime(1000);
+    console.log(
+      "[Test 2] Advanced time by 1000ms, still within default lifespan"
+    );
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+    await client.updateApp({ appId: QB_APP_ID, body: request });
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch.mock.calls[2][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN default_token"
+    );
+  });
+
+  it("handles token fetch failure gracefully", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true,
+      tempTokenLifespan: 500,
+    });
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      json: () => Promise.resolve({ message: "Network error" }),
+    });
+    await expect(
+      client.updateApp({ appId: QB_APP_ID, body: request })
+    ).rejects.toThrow("API Error: Network error (Status: 500)");
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("fetches new token every call with zero lifespan", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true,
+      tempTokenLifespan: 0,
+    });
+
+    setupMocks("token1");
+    await client.updateApp({ appId: QB_APP_ID, body: request });
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+
+    setupMocks("token2");
+    await client.updateApp({ appId: QB_APP_ID, body: request });
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(mockFetch.mock.calls[3][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token2"
+    );
+  });
+
+  it("reuses token across concurrent calls within lifespan", async () => {
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true,
+      tempTokenLifespan: 500,
+      debug: true,
+    });
+
+    // Pre-fetch token to ensure it’s cached
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ temporaryAuthorization: "token1" }),
+    });
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(mockResponse),
+    });
+    await client.updateApp({ appId: QB_APP_ID, body: request }); // Cache token1
+    vi.advanceTimersByTime(1);
+
+    // Reset mocks and set up API responses
+    mockFetch.mockClear();
     mockFetch
       .mockResolvedValueOnce({
         ok: true,
         status: 200,
-        json: () =>
-          Promise.resolve({ temporaryAuthorization: "default_token" }),
+        json: () => Promise.resolve(mockResponse),
       })
       .mockResolvedValueOnce({
         ok: true,
@@ -122,17 +186,19 @@ describe("QuickbaseClient Unit - Token Lifespan", () => {
         json: () => Promise.resolve(mockResponse),
       });
 
-    await client.updateApp({ appId: QB_APP_ID, body: request });
-    expect(mockFetch).toHaveBeenCalledTimes(2); // Token fetch + API call
+    const [call1, call2] = await Promise.all([
+      client.updateApp({ appId: QB_APP_ID, body: request }),
+      client.updateApp({ appId: QB_APP_ID, body: request }),
+    ]);
 
-    // Second call within default lifespan (e.g., after 1 second, well below 4:50)
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: () => Promise.resolve(mockResponse),
-    });
-    await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
-    await client.updateApp({ appId: QB_APP_ID, body: request });
-    expect(mockFetch).toHaveBeenCalledTimes(3); // No new token fetch, still within 4:50
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[0][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token1"
+    );
+    expect(mockFetch.mock.calls[1][1].headers.Authorization).toBe(
+      "QB-TEMP-TOKEN token1"
+    );
+    expect(call1).toEqual(mockResponse);
+    expect(call2).toEqual(mockResponse);
   });
 });

package/tools/log-gen.ts

@@ -31,23 +31,32 @@ const includeRecursiveFolders: string[] = [
 // prettier-ignore
 const includeFiles: string[] = [
   // "tests/setup.ts",
+  // "vitest.config.ts",
 
   // "package.json",
   // "tsconfig.json",
   // "tsconfig.build.json",
   // "rollup.config.js",
-  // "vitest.config.ts",
   // "build-common.js",
   // "build-umd.js",
   // "build-esm.js",
-  // "src/tokenCache.ts",
-  // "src/generated/runtime.ts",
+
   // "src/quickbaseClient.ts",
   // "src/invokeMethod.ts",
   // "src/generated-unified/QuickbaseClient.ts",
-
+  // "src/authorizationStrategy.ts",
+  // "src/rateLimiter.ts",
   // "src/RateLimitError.ts",
-  // "src/TokenBucket.ts"
+  // "src/ThrottleBucket.ts",
+  // "src/tokenCache.ts",
+  // "src/utils.ts",
+
+  // "src/generated/runtime.ts",
+  // "src/generated/apis/AuthApi.ts",
+  // "src/generated/apis/FieldsApi.ts",
+  // "src/generated/apis/AppsApi.ts",
+
+  "test/vitest/unit/fields/createField.test.ts",
 ];
 
 const projectGoals: string[] = [