@alumbwe/anvil 1.0.0

package/src/hooks/__tests__/use-usage-query.test.ts

@@ -0,0 +1,502 @@
+import { createMockLogger } from '@anvil/common/testing/mocks/logger'
+import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test'
+
+import {
+  resetActivityQueryCache,
+  getActivityQueryData,
+  setActivityQueryData,
+  invalidateActivityQuery,
+  removeActivityQuery,
+} from '../use-activity-query'
+import {
+  fetchUsageData,
+  usageQueryKeys,
+} from '../use-usage-query'
+
+import type { ClientEnv } from '@anvil/common/types/contracts/env'
+
+
+beforeEach(() => {
+  resetActivityQueryCache()
+})
+
+describe('fetchUsageData', () => {
+  const originalFetch = globalThis.fetch
+  const originalEnv = process.env.NEXT_PUBLIC_ANVIL_APP_URL
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = 'https://test.codebuff.local'
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = originalEnv
+    mock.restore()
+  })
+
+  test('should fetch usage data successfully', async () => {
+    const mockResponse = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      balanceBreakdown: { free: 300, paid: 200 },
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    globalThis.fetch = mock(
+      async () =>
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    ) as unknown as typeof fetch
+
+    const result = await fetchUsageData({ authToken: 'test-token' })
+
+    expect(result).toEqual(mockResponse)
+  })
+
+  test('should handle full balance breakdown with all fields', async () => {
+    const mockResponse = {
+      type: 'usage-response' as const,
+      usage: 250,
+      remainingBalance: 1000,
+      balanceBreakdown: {
+        free: 100,
+        paid: 500,
+        ad: 200,
+        referral: 150,
+        admin: 50,
+      },
+      next_quota_reset: '2024-03-01T00:00:00.000Z',
+      autoTopupEnabled: true,
+    }
+
+    globalThis.fetch = mock(
+      async () =>
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    ) as unknown as typeof fetch
+
+    const result = await fetchUsageData({ authToken: 'test-token' })
+
+    expect(result).toEqual(mockResponse)
+    expect(result.balanceBreakdown?.ad).toBe(200)
+    expect(result.balanceBreakdown?.referral).toBe(150)
+    expect(result.balanceBreakdown?.admin).toBe(50)
+    expect(result.autoTopupEnabled).toBe(true)
+  })
+
+  test('should handle null remaining balance', async () => {
+    const mockResponse = {
+      type: 'usage-response' as const,
+      usage: 0,
+      remainingBalance: null,
+      next_quota_reset: null,
+    }
+
+    globalThis.fetch = mock(
+      async () =>
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    ) as unknown as typeof fetch
+
+    const result = await fetchUsageData({ authToken: 'test-token' })
+
+    expect(result.remainingBalance).toBeNull()
+    expect(result.next_quota_reset).toBeNull()
+    expect(result.balanceBreakdown).toBeUndefined()
+  })
+
+  test('should handle zero usage and balance', async () => {
+    const mockResponse = {
+      type: 'usage-response' as const,
+      usage: 0,
+      remainingBalance: 0,
+      balanceBreakdown: { free: 0, paid: 0 },
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    globalThis.fetch = mock(
+      async () =>
+        new Response(JSON.stringify(mockResponse), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    ) as unknown as typeof fetch
+
+    const result = await fetchUsageData({ authToken: 'test-token' })
+
+    expect(result.usage).toBe(0)
+    expect(result.remainingBalance).toBe(0)
+  })
+
+  test('should throw error on failed request', async () => {
+    globalThis.fetch = mock(
+      async () => new Response('Error', { status: 500 }),
+    ) as unknown as typeof fetch
+    const mockLogger = createMockLogger()
+
+    await expect(
+      fetchUsageData({ authToken: 'test-token', logger: mockLogger }),
+    ).rejects.toThrow('Failed to fetch usage: 500')
+  })
+
+  test('should throw error on 401 unauthorized', async () => {
+    globalThis.fetch = mock(
+      async () => new Response('Unauthorized', { status: 401 }),
+    ) as unknown as typeof fetch
+    const mockLogger = createMockLogger()
+
+    await expect(
+      fetchUsageData({ authToken: 'invalid-token', logger: mockLogger }),
+    ).rejects.toThrow('Failed to fetch usage: 401')
+  })
+
+  test('should throw error on 402 payment required', async () => {
+    globalThis.fetch = mock(
+      async () => new Response('Payment Required', { status: 402 }),
+    ) as unknown as typeof fetch
+    const mockLogger = createMockLogger()
+
+    await expect(
+      fetchUsageData({ authToken: 'test-token', logger: mockLogger }),
+    ).rejects.toThrow('Failed to fetch usage: 402')
+  })
+
+  test('should throw error when app URL is not set', async () => {
+    await expect(
+      fetchUsageData({
+        authToken: 'test-token',
+        clientEnv: {
+          NEXT_PUBLIC_ANVIL_APP_URL: undefined,
+        } as unknown as ClientEnv,
+      }),
+    ).rejects.toThrow('NEXT_PUBLIC_ANVIL_APP_URL is not set')
+  })
+
+  test('should send correct request body', async () => {
+    let capturedBody: string | undefined
+
+    globalThis.fetch = mock(async (url: string, init?: RequestInit) => {
+      capturedBody = init?.body as string
+      return new Response(
+        JSON.stringify({
+          type: 'usage-response',
+          usage: 0,
+          remainingBalance: 100,
+          next_quota_reset: null,
+        }),
+        { status: 200 },
+      )
+    }) as unknown as typeof fetch
+
+    await fetchUsageData({ authToken: 'my-auth-token' })
+
+    expect(capturedBody).toBeDefined()
+    const parsed = JSON.parse(capturedBody!)
+    expect(parsed.fingerprintId).toBe('cli-usage')
+    expect(parsed.authToken).toBe('my-auth-token')
+  })
+
+  test('should call correct API endpoint', async () => {
+    let capturedUrl: string | undefined
+
+    globalThis.fetch = mock(async (url: string) => {
+      capturedUrl = url
+      return new Response(
+        JSON.stringify({
+          type: 'usage-response',
+          usage: 0,
+          remainingBalance: 100,
+          next_quota_reset: null,
+        }),
+        { status: 200 },
+      )
+    }) as unknown as typeof fetch
+
+    await fetchUsageData({
+      authToken: 'test-token',
+      clientEnv: {
+        NEXT_PUBLIC_ANVIL_APP_URL: 'https://test.codebuff.local',
+      } as ClientEnv,
+    })
+
+    expect(capturedUrl).toBe('https://test.codebuff.local/api/v1/usage')
+  })
+
+  test('should log error on failed request', async () => {
+    globalThis.fetch = mock(
+      async () => new Response('Server Error', { status: 503 }),
+    ) as unknown as typeof fetch
+
+    const mockLogger = createMockLogger()
+
+    await expect(
+      fetchUsageData({ authToken: 'test-token', logger: mockLogger }),
+    ).rejects.toThrow()
+
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      { status: 503 },
+      'Failed to fetch usage data from API',
+    )
+  })
+})
+
+describe('usageQueryKeys', () => {
+  test('all returns base query key', () => {
+    expect(usageQueryKeys.all).toEqual(['usage'])
+  })
+
+  test('current returns extended query key', () => {
+    expect(usageQueryKeys.current()).toEqual(['usage', 'current'])
+  })
+
+  test('current returns new array instance each call', () => {
+    const first = usageQueryKeys.current()
+    const second = usageQueryKeys.current()
+    expect(first).not.toBe(second)
+    expect(first).toEqual(second)
+  })
+
+  test('query keys can be used for cache operations', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 50,
+      remainingBalance: 200,
+      next_quota_reset: null,
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toEqual(mockData)
+  })
+})
+
+describe('useRefreshUsage behavior', () => {
+  // Note: useRefreshUsage is a React hook that wraps invalidateActivityQuery.
+  // We can't call it directly outside a component, but we can test the
+  // underlying invalidation behavior it uses.
+
+  afterEach(() => {
+    mock.restore()
+    resetActivityQueryCache()
+  })
+
+  test('invalidating usage query preserves cached data', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    // Pre-populate cache
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toEqual(mockData)
+
+    // Call the underlying invalidation function (what useRefreshUsage wraps)
+    invalidateActivityQuery(usageQueryKeys.current())
+
+    // Data should still exist (invalidation doesn't remove data)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toEqual(mockData)
+  })
+
+  test('invalidation marks data as stale for refetching', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 200,
+      remainingBalance: 300,
+      next_quota_reset: '2024-03-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    invalidateActivityQuery(usageQueryKeys.current())
+
+    // Data is still accessible (stale but usable)
+    const cached = getActivityQueryData<typeof mockData>(
+      usageQueryKeys.current(),
+    )
+    expect(cached?.usage).toBe(200)
+    expect(cached?.remainingBalance).toBe(300)
+  })
+})
+
+describe('usage query cache behavior', () => {
+  afterEach(() => {
+    mock.restore()
+    resetActivityQueryCache()
+  })
+
+  test('should store and retrieve usage data from cache', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toEqual(mockData)
+  })
+
+  test('should update cache when new data is set', () => {
+    const initialData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    const updatedData = {
+      type: 'usage-response' as const,
+      usage: 150,
+      remainingBalance: 450,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), initialData)
+    expect(
+      getActivityQueryData<typeof initialData>(usageQueryKeys.current())?.usage,
+    ).toBe(100)
+
+    setActivityQueryData(usageQueryKeys.current(), updatedData)
+    expect(
+      getActivityQueryData<typeof initialData>(usageQueryKeys.current())?.usage,
+    ).toBe(150)
+  })
+
+  test('should preserve data after invalidation', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    invalidateActivityQuery(usageQueryKeys.current())
+
+    // Data should still be accessible
+    const cached = getActivityQueryData<typeof mockData>(
+      usageQueryKeys.current(),
+    )
+    expect(cached).toEqual(mockData)
+  })
+
+  test('should handle cache removal', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toBeDefined()
+
+    removeActivityQuery(usageQueryKeys.current())
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toBeUndefined()
+  })
+
+  test('should handle balance breakdown with all credit types', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 500,
+      remainingBalance: 1500,
+      balanceBreakdown: {
+        free: 300,
+        paid: 700,
+        ad: 200,
+        referral: 200,
+        admin: 100,
+      },
+      next_quota_reset: '2024-02-15T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    const cached = getActivityQueryData<typeof mockData>(
+      usageQueryKeys.current(),
+    )
+
+    expect(cached?.balanceBreakdown?.free).toBe(300)
+    expect(cached?.balanceBreakdown?.paid).toBe(700)
+    expect(cached?.balanceBreakdown?.ad).toBe(200)
+    expect(cached?.balanceBreakdown?.referral).toBe(200)
+    expect(cached?.balanceBreakdown?.admin).toBe(100)
+  })
+
+  test('should handle zero and null values correctly', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 0,
+      remainingBalance: 0,
+      balanceBreakdown: { free: 0, paid: 0 },
+      next_quota_reset: null,
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    const cached = getActivityQueryData<typeof mockData>(
+      usageQueryKeys.current(),
+    )
+
+    expect(cached?.usage).toBe(0)
+    expect(cached?.remainingBalance).toBe(0)
+    expect(cached?.next_quota_reset).toBeNull()
+  })
+
+  test('reset clears usage cache', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: null,
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toBeDefined()
+
+    resetActivityQueryCache()
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toBeUndefined()
+  })
+
+  test('multiple invalidations preserve data', () => {
+    const mockData = {
+      type: 'usage-response' as const,
+      usage: 100,
+      remainingBalance: 500,
+      next_quota_reset: '2024-02-01T00:00:00.000Z',
+    }
+
+    setActivityQueryData(usageQueryKeys.current(), mockData)
+
+    // Invalidate multiple times
+    invalidateActivityQuery(usageQueryKeys.current())
+    invalidateActivityQuery(usageQueryKeys.current())
+    invalidateActivityQuery(usageQueryKeys.current())
+
+    // Data should still be there
+    expect(
+      getActivityQueryData<typeof mockData>(usageQueryKeys.current()),
+    ).toEqual(mockData)
+  })
+})

package/src/hooks/__tests__/use-user-details-query.test.ts

@@ -0,0 +1,195 @@
+import {
+  describe,
+  test,
+  expect,
+  mock,
+  beforeEach,
+  afterEach,
+  spyOn,
+} from 'bun:test'
+
+import { createMockApiClient } from '../../__tests__/helpers/mock-api-client'
+import * as AnvilApiModule from '../../utils/anvil-api'
+import { fetchUserDetails } from '../use-user-details-query'
+
+import type { Logger } from '@anvil/common/types/contracts/logger'
+
+describe('fetchUserDetails', () => {
+  const mockLogger: Logger = {
+    error: mock(() => {}),
+    warn: mock(() => {}),
+    info: mock(() => {}),
+    debug: mock(() => {}),
+  }
+
+  const originalEnv = process.env.NEXT_PUBLIC_ANVIL_APP_URL
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = 'https://test.codebuff.com'
+  })
+
+  afterEach(() => {
+    process.env.NEXT_PUBLIC_ANVIL_APP_URL = originalEnv
+  })
+
+  describe('API failure handling', () => {
+    test('throws error on 401 Unauthorized response', async () => {
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: false,
+          status: 401,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'invalid-token',
+          fields: ['email'] as const,
+          logger: mockLogger,
+          apiClient,
+        }),
+      ).rejects.toThrow('Failed to fetch user details (HTTP 401)')
+    })
+
+    test('throws error on 500 Internal Server Error response', async () => {
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'valid-token',
+          fields: ['email'] as const,
+          logger: mockLogger,
+          apiClient,
+        }),
+      ).rejects.toThrow('Failed to fetch user details (HTTP 500)')
+    })
+
+    test('throws error on 403 Forbidden response', async () => {
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: false,
+          status: 403,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'valid-token',
+          fields: ['email'] as const,
+          logger: mockLogger,
+          apiClient,
+        }),
+      ).rejects.toThrow('Failed to fetch user details (HTTP 403)')
+    })
+
+    test('throws error on 404 Not Found response', async () => {
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: false,
+          status: 404,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'valid-token',
+          fields: ['id', 'email'] as const,
+          logger: mockLogger,
+          apiClient,
+        }),
+      ).rejects.toThrow('Failed to fetch user details (HTTP 404)')
+    })
+
+    test('logs error before throwing on API failure', async () => {
+      const errorSpy = mock(() => {})
+      const testLogger: Logger = {
+        ...mockLogger,
+        error: errorSpy,
+      }
+
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: false,
+          status: 500,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'valid-token',
+          fields: ['email'] as const,
+          logger: testLogger,
+          apiClient,
+        }),
+      ).rejects.toThrow()
+
+      expect(errorSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('successful responses', () => {
+    test('returns user details on successful response', async () => {
+      const mockUserDetails = {
+        email: 'test@example.com',
+      }
+
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 200,
+          data: mockUserDetails,
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      const result = await fetchUserDetails({
+        authToken: 'valid-token',
+        fields: ['email'] as const,
+        logger: mockLogger,
+        apiClient,
+      })
+
+      expect(result).toEqual(mockUserDetails)
+    })
+
+  })
+
+  describe('environment validation', () => {
+    test('uses shared API client when apiClient is not provided', async () => {
+      const meMock = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 200,
+          data: { email: 'test@example.com' },
+        }),
+      )
+      const apiClient = createMockApiClient({ me: meMock })
+
+      const setTokenSpy = spyOn(
+        AnvilApiModule,
+        'setApiClientAuthToken',
+      )
+      spyOn(AnvilApiModule, 'getApiClient').mockReturnValue(apiClient as ReturnType<typeof AnvilApiModule.getApiClient>)
+
+      await expect(
+        fetchUserDetails({
+          authToken: 'valid-token',
+          fields: ['email'] as const,
+          logger: mockLogger,
+        }),
+      ).resolves.toEqual({ email: 'test@example.com' })
+
+      expect(setTokenSpy).toHaveBeenCalledWith('valid-token')
+    })
+  })
+})