@alumbwe/anvil 1.0.42 → 1.0.50

package/vendor/@anvil/common/src/util/__tests__/promise.test.ts

@@ -1,325 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test'
-
-import { INITIAL_RETRY_DELAY, withRetry } from '../promise'
-
-describe('withRetry', () => {
-  describe('basic functionality', () => {
-    it('should return result on successful first attempt', async () => {
-      const operation = mock(() => Promise.resolve('success'))
-
-      const result = await withRetry(operation)
-
-      expect(result).toBe('success')
-      expect(operation).toHaveBeenCalledTimes(1)
-    })
-
-    it('should retry on retryable error and succeed', async () => {
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts === 1) {
-          const error = { type: 'APIConnectionError' }
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success after retry')
-      })
-
-      // Mock setTimeout to avoid delays
-      const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
-        ((callback: () => void) => {
-          callback()
-          return 0 as unknown as NodeJS.Timeout
-        }) as typeof setTimeout,
-      )
-
-      const result = await withRetry(operation)
-
-      expect(result).toBe('success after retry')
-      expect(attempts).toBe(2)
-
-      setTimeoutSpy.mockRestore()
-    })
-
-    it('should throw immediately on non-retryable error', async () => {
-      const error = new Error('non-retryable')
-      const operation = mock(() => Promise.reject(error))
-
-      await expect(withRetry(operation)).rejects.toThrow('non-retryable')
-      expect(operation).toHaveBeenCalledTimes(1)
-    })
-
-    it('should throw after max retries exceeded', async () => {
-      const error = { type: 'APIConnectionError' }
-      const operation = mock(() => Promise.reject(error))
-
-      // Mock setTimeout to avoid delays
-      const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
-        ((callback: () => void) => {
-          callback()
-          return 0 as unknown as NodeJS.Timeout
-        }) as typeof setTimeout,
-      )
-
-      await expect(
-        withRetry(operation, { maxRetries: 3 }),
-      ).rejects.toMatchObject({ type: 'APIConnectionError' })
-
-      expect(operation).toHaveBeenCalledTimes(3)
-
-      setTimeoutSpy.mockRestore()
-    })
-  })
-
-  describe('jitter behavior', () => {
-    let setTimeoutSpy: ReturnType<typeof spyOn>
-    let mathRandomSpy: ReturnType<typeof spyOn>
-    let capturedDelays: number[]
-
-    beforeEach(() => {
-      capturedDelays = []
-
-      // Capture the delay values passed to setTimeout
-      setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
-        ((callback: () => void, delay: number) => {
-          capturedDelays.push(delay)
-          callback()
-          return 0 as unknown as NodeJS.Timeout
-        }) as typeof setTimeout,
-      )
-    })
-
-    afterEach(() => {
-      setTimeoutSpy.mockRestore()
-      if (mathRandomSpy) {
-        mathRandomSpy.mockRestore()
-      }
-    })
-
-    it('should apply minimum jitter (0.8x) when Math.random returns 0', async () => {
-      mathRandomSpy = spyOn(Math, 'random').mockReturnValue(0)
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 3) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 3,
-        retryDelayMs: INITIAL_RETRY_DELAY,
-      })
-
-      // With Math.random() = 0, jitter = 0.8
-      // Attempt 0 (first retry): baseDelay = 1000 * 2^0 = 1000, delay = 1000 * 0.8 = 800
-      // Attempt 1 (second retry): baseDelay = 1000 * 2^1 = 2000, delay = 2000 * 0.8 = 1600
-      expect(capturedDelays).toEqual([800, 1600])
-    })
-
-    it('should apply maximum jitter (1.2x) when Math.random returns 1', async () => {
-      mathRandomSpy = spyOn(Math, 'random').mockReturnValue(1)
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 3) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 3,
-        retryDelayMs: INITIAL_RETRY_DELAY,
-      })
-
-      // With Math.random() = 1, jitter = 1.2
-      // Attempt 0: baseDelay = 1000 * 2^0 = 1000, delay = 1000 * 1.2 = 1200
-      // Attempt 1: baseDelay = 1000 * 2^1 = 2000, delay = 2000 * 1.2 = 2400
-      expect(capturedDelays).toEqual([1200, 2400])
-    })
-
-    it('should apply no jitter (1.0x) when Math.random returns 0.5', async () => {
-      mathRandomSpy = spyOn(Math, 'random').mockReturnValue(0.5)
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 3) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 3,
-        retryDelayMs: INITIAL_RETRY_DELAY,
-      })
-
-      // With Math.random() = 0.5, jitter = 0.8 + 0.5 * 0.4 = 1.0
-      // Attempt 0: baseDelay = 1000, delay = 1000 * 1.0 = 1000
-      // Attempt 1: baseDelay = 2000, delay = 2000 * 1.0 = 2000
-      expect(capturedDelays).toEqual([1000, 2000])
-    })
-
-    it('should apply exponential backoff with jitter correctly', async () => {
-      // Use a specific random value to verify the jitter calculation
-      mathRandomSpy = spyOn(Math, 'random').mockReturnValue(0.25)
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 4) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 4,
-        retryDelayMs: 1000,
-      })
-
-      // With Math.random() = 0.25, jitter = 0.8 + 0.25 * 0.4 = 0.9
-      // Attempt 0: 1000 * 2^0 * 0.9 = 900
-      // Attempt 1: 1000 * 2^1 * 0.9 = 1800
-      // Attempt 2: 1000 * 2^2 * 0.9 = 3600
-      expect(capturedDelays).toEqual([900, 1800, 3600])
-    })
-
-    it('should produce delays within ±20% of base delay', async () => {
-      // Don't mock Math.random - let it use real random values
-      mathRandomSpy?.mockRestore()
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 3) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 3,
-        retryDelayMs: 1000,
-      })
-
-      // Verify delays are within expected ranges
-      // Attempt 0: base = 1000, range = [800, 1200]
-      expect(capturedDelays[0]).toBeGreaterThanOrEqual(800)
-      expect(capturedDelays[0]).toBeLessThanOrEqual(1200)
-
-      // Attempt 1: base = 2000, range = [1600, 2400]
-      expect(capturedDelays[1]).toBeGreaterThanOrEqual(1600)
-      expect(capturedDelays[1]).toBeLessThanOrEqual(2400)
-    })
-
-    it('should use custom retryDelayMs for base delay calculation', async () => {
-      mathRandomSpy = spyOn(Math, 'random').mockReturnValue(0.5) // jitter = 1.0
-
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 2) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 2,
-        retryDelayMs: 500, // Custom base delay
-      })
-
-      // With jitter = 1.0 and retryDelayMs = 500
-      // Attempt 0: 500 * 2^0 * 1.0 = 500
-      expect(capturedDelays).toEqual([500])
-    })
-  })
-
-  describe('onRetry callback', () => {
-    it('should call onRetry with error and attempt number', async () => {
-      const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
-        ((callback: () => void) => {
-          callback()
-          return 0 as unknown as NodeJS.Timeout
-        }) as typeof setTimeout,
-      )
-
-      const onRetry = mock(() => {})
-      const error = { type: 'APIConnectionError' }
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts < 3) {
-          return Promise.reject(error)
-        }
-        return Promise.resolve('success')
-      })
-
-      await withRetry(operation, {
-        maxRetries: 3,
-        onRetry,
-      })
-
-      expect(onRetry).toHaveBeenCalledTimes(2)
-      expect(onRetry).toHaveBeenNthCalledWith(1, error, 1)
-      expect(onRetry).toHaveBeenNthCalledWith(2, error, 2)
-
-      setTimeoutSpy.mockRestore()
-    })
-  })
-
-  describe('retryIf callback', () => {
-    it('should use custom retryIf to determine retryability', async () => {
-      const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
-        ((callback: () => void) => {
-          callback()
-          return 0 as unknown as NodeJS.Timeout
-        }) as typeof setTimeout,
-      )
-
-      let attempts = 0
-      const operation = mock(() => {
-        attempts++
-        if (attempts === 1) {
-          return Promise.reject({ code: 'RETRY_ME' })
-        }
-        return Promise.resolve('success')
-      })
-
-      const result = await withRetry(operation, {
-        maxRetries: 3,
-        retryIf: (error) => error?.code === 'RETRY_ME',
-      })
-
-      expect(result).toBe('success')
-      expect(attempts).toBe(2)
-
-      setTimeoutSpy.mockRestore()
-    })
-
-    it('should not retry when retryIf returns false', async () => {
-      const error = { code: 'DO_NOT_RETRY' }
-      const operation = mock(() => Promise.reject(error))
-
-      await expect(
-        withRetry(operation, {
-          maxRetries: 3,
-          retryIf: (err) => err?.code === 'RETRY_ME',
-        }),
-      ).rejects.toMatchObject({ code: 'DO_NOT_RETRY' })
-
-      expect(operation).toHaveBeenCalledTimes(1)
-    })
-  })
-})

package/vendor/@anvil/common/src/util/__tests__/rate-limit.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { createFixedWindowRateLimiter } from '../rate-limit'
-
-describe('createFixedWindowRateLimiter', () => {
-  it('allows up to `max` requests per window, then limits', () => {
-    const rl = createFixedWindowRateLimiter({ windowMs: 1000, max: 3 })
-    const t = 0
-    expect(rl.limited('a', t)).toBe(false) // 1
-    expect(rl.limited('a', t)).toBe(false) // 2
-    expect(rl.limited('a', t)).toBe(false) // 3
-    expect(rl.limited('a', t)).toBe(true) // 4 -> over
-  })
-
-  it('resets after the window elapses', () => {
-    const rl = createFixedWindowRateLimiter({ windowMs: 1000, max: 1 })
-    expect(rl.limited('a', 0)).toBe(false)
-    expect(rl.limited('a', 500)).toBe(true) // still in window
-    expect(rl.limited('a', 1000)).toBe(false) // window rolled over
-  })
-
-  it('tracks keys independently', () => {
-    const rl = createFixedWindowRateLimiter({ windowMs: 1000, max: 1 })
-    expect(rl.limited('a', 0)).toBe(false)
-    expect(rl.limited('b', 0)).toBe(false) // different key, own budget
-    expect(rl.limited('a', 0)).toBe(true)
-  })
-})

package/vendor/@anvil/common/src/util/__tests__/reddit-anvil-retention.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  getAnvilRetentionMilestonesToFire,
-  isFirstAnvilPrompt,
-  planAnvilRedditConversionEvents,
-} from '@anvil/common/util/reddit-anvil-retention'
-
-describe('isFirstAnvilPrompt', () => {
-  test('returns true on first-ever usage day', () => {
-    expect(
-      isFirstAnvilPrompt({
-        previousUsageDays: [],
-        newUsageDayRecorded: true,
-      }),
-    ).toBe(true)
-  })
-
-  test('returns false on repeat prompts same day', () => {
-    expect(
-      isFirstAnvilPrompt({
-        previousUsageDays: ['2026-06-30'],
-        newUsageDayRecorded: false,
-      }),
-    ).toBe(false)
-  })
-
-  test('returns false on a later usage day', () => {
-    expect(
-      isFirstAnvilPrompt({
-        previousUsageDays: ['2026-06-30'],
-        newUsageDayRecorded: true,
-      }),
-    ).toBe(false)
-  })
-})
-
-describe('getAnvilRetentionMilestonesToFire', () => {
-  test('returns nothing on first-ever usage day', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: [],
-        todayDateKey: '2026-06-30',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([])
-  })
-
-  test('returns nothing when no new usage day was recorded', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-30'],
-        todayDateKey: '2026-07-01',
-        newUsageDayRecorded: false,
-      }),
-    ).toEqual([])
-  })
-
-  test('fires 1d retention on day 1', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-30'],
-        todayDateKey: '2026-07-01',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([1])
-  })
-
-  test('does not repeat 1d on day 2', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-30', '2026-07-01'],
-        todayDateKey: '2026-07-02',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([])
-  })
-
-  test('fires 7d retention on day 7', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-30', '2026-07-01'],
-        todayDateKey: '2026-07-07',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([7])
-  })
-
-  test('does not backfill missed milestones after a long gap', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-01'],
-        todayDateKey: '2026-07-01',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([])
-  })
-
-  test('fires 24d retention only on exact day 24', () => {
-    expect(
-      getAnvilRetentionMilestonesToFire({
-        previousUsageDays: ['2026-06-01', '2026-06-02'],
-        todayDateKey: '2026-06-25',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual([24])
-  })
-})
-
-describe('planAnvilRedditConversionEvents', () => {
-  test('first prompt only on day 0', () => {
-    expect(
-      planAnvilRedditConversionEvents({
-        previousUsageDays: [],
-        todayDateKey: '2026-06-30',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual({ fireFirstPrompt: true, retentionMilestones: [] })
-  })
-
-  test('1d retention without first prompt on day 1', () => {
-    expect(
-      planAnvilRedditConversionEvents({
-        previousUsageDays: ['2026-06-30'],
-        todayDateKey: '2026-07-01',
-        newUsageDayRecorded: true,
-      }),
-    ).toEqual({ fireFirstPrompt: false, retentionMilestones: [1] })
-  })
-})