@alumbwe/anvil 1.0.20 → 1.0.21

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

@@ -0,0 +1,325 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,130 @@
+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] })
+  })
+})