chore: merge latest upstream routes-b updates

Author: Jay-Peter-Egemasi

app/api/routes-b/_lib/__tests__/audit-action-filter.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Tests for buildActionFilter — Issue #621
+ */
+
+import { describe, it, expect } from 'vitest'
+import { buildActionFilter } from '../audit-action-filter'
+
+function params(record: Record<string, string>): URLSearchParams {
+  return new URLSearchParams(record)
+}
+
+describe('buildActionFilter (#621)', () => {
+  it('returns empty clause when both filters are missing', () => {
+    const result = buildActionFilter(params({}))
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.clause).toEqual({})
+  })
+
+  it('builds equals filter for ?action', () => {
+    const result = buildActionFilter(params({ action: 'refund.created' }))
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.clause).toEqual({ eventType: { equals: 'refund.created' } })
+    }
+  })
+
+  it('builds startsWith filter for ?actionPrefix', () => {
+    const result = buildActionFilter(params({ actionPrefix: 'webhook.' }))
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.clause).toEqual({ eventType: { startsWith: 'webhook.' } })
+    }
+  })
+
+  it('rejects actionPrefix shorter than 2 chars', () => {
+    const result = buildActionFilter(params({ actionPrefix: 'a' }))
+    expect(result.ok).toBe(false)
+    if (!result.ok) expect(result.error).toMatch(/2 and 64/)
+  })
+
+  it('rejects actionPrefix longer than 64 chars', () => {
+    const result = buildActionFilter(params({ actionPrefix: 'x'.repeat(65) }))
+    expect(result.ok).toBe(false)
+  })
+
+  it('action takes precedence when both are present', () => {
+    const result = buildActionFilter(
+      params({ action: 'refund.created', actionPrefix: 'webhook.' }),
+    )
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.clause).toEqual({ eventType: { equals: 'refund.created' } })
+    }
+  })
+
+  it('trims whitespace from inputs', () => {
+    const result = buildActionFilter(params({ action: '  refund.created  ' }))
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.clause).toEqual({ eventType: { equals: 'refund.created' } })
+    }
+  })
+
+  it('treats empty string action as missing', () => {
+    const result = buildActionFilter(params({ action: '   ' }))
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.clause).toEqual({})
+  })
+})

app/api/routes-b/_lib/__tests__/late-fee.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Tests for computeLateFee — Issue #599
+ */
+
+import { describe, it, expect } from 'vitest'
+import { computeLateFee, DEFAULT_LATE_FEE_POLICY } from '../late-fee'
+
+const baseInvoice = {
+  amount: 1000,
+  currency: 'USD',
+  dueDate: new Date('2026-01-01'),
+}
+
+describe('computeLateFee (#599)', () => {
+  it('returns zero when invoice is not overdue', () => {
+    const result = computeLateFee(baseInvoice, new Date('2025-12-31'))
+    expect(result.amount).toBe(0)
+    expect(result.applied).toBe(false)
+    expect(result.daysLate).toBe(0)
+  })
+
+  it('returns zero when overdue but less than one period', () => {
+    const result = computeLateFee(baseInvoice, new Date('2026-01-15')) // 14 days late
+    expect(result.amount).toBe(0)
+    expect(result.applied).toBe(false)
+    expect(result.daysLate).toBe(14)
+  })
+
+  it('charges 1.5% for one full period (30 days)', () => {
+    const result = computeLateFee(baseInvoice, new Date('2026-01-31')) // 30 days late
+    // 1000 * 0.015 * 1 = 15
+    expect(result.amount).toBe(15)
+    expect(result.applied).toBe(true)
+    expect(result.daysLate).toBe(30)
+    expect(result.currency).toBe('USD')
+  })
+
+  it('scales linearly across multiple periods', () => {
+    const result = computeLateFee(baseInvoice, new Date('2026-04-01')) // 90 days = 3 periods
+    // 1000 * 0.015 * 3 = 45
+    expect(result.amount).toBe(45)
+    expect(result.applied).toBe(true)
+  })
+
+  it('caps at 10% of principal', () => {
+    // 8 periods (240 days) → would be 12% → cap at 10%
+    const result = computeLateFee(baseInvoice, new Date('2026-08-29'))
+    expect(result.amount).toBe(100) // 10% of 1000
+    expect(result.applied).toBe(true)
+  })
+
+  it('returns zero for invoice with no due date', () => {
+    const result = computeLateFee(
+      { amount: 1000, currency: 'USD', dueDate: null },
+      new Date(),
+    )
+    expect(result.amount).toBe(0)
+    expect(result.applied).toBe(false)
+  })
+
+  it('preserves currency', () => {
+    const result = computeLateFee(
+      { ...baseInvoice, currency: 'EUR' },
+      new Date('2026-01-31'),
+    )
+    expect(result.currency).toBe('EUR')
+  })
+
+  it('accepts ISO string dates', () => {
+    const result = computeLateFee(
+      { ...baseInvoice, dueDate: '2026-01-01' },
+      '2026-01-31',
+    )
+    expect(result.amount).toBe(15)
+  })
+
+  it('uses default policy when none supplied', () => {
+    const result = computeLateFee(baseInvoice, new Date('2026-01-31'))
+    expect(result.amount).toBe(1000 * DEFAULT_LATE_FEE_POLICY.ratePerPeriod * 1)
+  })
+
+  it('respects custom policy', () => {
+    const result = computeLateFee(
+      baseInvoice,
+      new Date('2026-01-31'),
+      { ratePerPeriod: 0.05, periodDays: 30, capFraction: 0.5 },
+    )
+    expect(result.amount).toBe(50) // 1000 * 0.05 * 1
+  })
+})

app/api/routes-b/_lib/__tests__/tag-validation.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Tests for validateTagName — Issue #610
+ */
+
+import { describe, it, expect } from 'vitest'
+import { validateTagName } from '../tag-validation'
+
+describe('validateTagName (#610)', () => {
+  it('accepts a valid name', () => {
+    const result = validateTagName('Important')
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.value).toBe('Important')
+  })
+
+  it('trims whitespace', () => {
+    const result = validateTagName('  spaced  ')
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.value).toBe('spaced')
+  })
+
+  it('rejects non-string input', () => {
+    expect(validateTagName(null).ok).toBe(false)
+    expect(validateTagName(123).ok).toBe(false)
+    expect(validateTagName(undefined).ok).toBe(false)
+  })
+
+  it('rejects empty string', () => {
+    expect(validateTagName('').ok).toBe(false)
+    expect(validateTagName('   ').ok).toBe(false)
+  })
+
+  it('rejects names longer than 32 chars', () => {
+    expect(validateTagName('x'.repeat(33)).ok).toBe(false)
+  })
+
+  it('accepts names exactly 32 chars', () => {
+    expect(validateTagName('x'.repeat(32)).ok).toBe(true)
+  })
+
+  it('rejects control characters', () => {
+    expect(validateTagName('bad\x00name').ok).toBe(false)
+    expect(validateTagName('bad\x07name').ok).toBe(false)
+  })
+})

app/api/routes-b/_lib/__tests__/webhook-backoff.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Tests for webhook backoff config — Issue #607
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  validateBackoff,
+  computeBackoffDelay,
+  DEFAULT_BACKOFF,
+} from '../webhook-backoff'
+
+describe('validateBackoff (#607)', () => {
+  it('returns defaults when input is null', () => {
+    const result = validateBackoff(null)
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.value).toEqual(DEFAULT_BACKOFF)
+  })
+
+  it('merges partial config with defaults', () => {
+    const result = validateBackoff({ initialMs: 500 })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.value.initialMs).toBe(500)
+      expect(result.value.maxMs).toBe(DEFAULT_BACKOFF.maxMs)
+    }
+  })
+
+  it('rejects initialMs below 50', () => {
+    const result = validateBackoff({ initialMs: 10 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects initialMs above 5000', () => {
+    const result = validateBackoff({ initialMs: 6000 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects maxMs below initialMs', () => {
+    const result = validateBackoff({ initialMs: 1000, maxMs: 500 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects maxMs above 60000', () => {
+    const result = validateBackoff({ maxMs: 70_000 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects multiplier below 1', () => {
+    const result = validateBackoff({ multiplier: 0.5 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects multiplier above 5', () => {
+    const result = validateBackoff({ multiplier: 6 })
+    expect(result.ok).toBe(false)
+  })
+
+  it('rejects jitter outside [0, 1]', () => {
+    expect(validateBackoff({ jitter: -0.1 }).ok).toBe(false)
+    expect(validateBackoff({ jitter: 1.1 }).ok).toBe(false)
+  })
+
+  it('accepts boundary values', () => {
+    const result = validateBackoff({
+      initialMs: 50,
+      maxMs: 60_000,
+      multiplier: 5,
+      jitter: 0,
+    })
+    expect(result.ok).toBe(true)
+  })
+})
+
+describe('computeBackoffDelay (#607)', () => {
+  it('returns initialMs for attempt 0 with zero jitter', () => {
+    const delay = computeBackoffDelay(
+      0,
+      { ...DEFAULT_BACKOFF, jitter: 0 },
+      () => 0.5,
+    )
+    expect(delay).toBe(DEFAULT_BACKOFF.initialMs)
+  })
+
+  it('multiplies on each successive attempt', () => {
+    const cfg = { initialMs: 100, maxMs: 10_000, multiplier: 2, jitter: 0 }
+    expect(computeBackoffDelay(0, cfg, () => 0.5)).toBe(100)
+    expect(computeBackoffDelay(1, cfg, () => 0.5)).toBe(200)
+    expect(computeBackoffDelay(2, cfg, () => 0.5)).toBe(400)
+    expect(computeBackoffDelay(3, cfg, () => 0.5)).toBe(800)
+  })
+
+  it('caps at maxMs', () => {
+    const cfg = { initialMs: 100, maxMs: 500, multiplier: 2, jitter: 0 }
+    expect(computeBackoffDelay(10, cfg, () => 0.5)).toBe(500)
+  })
+
+  it('respects jitter bounds', () => {
+    const cfg = { initialMs: 1000, maxMs: 10_000, multiplier: 1, jitter: 0.5 }
+    // With random()=0 → variance = 1000*0.5*-0.5 = -250 → 750
+    // With random()=1 → variance = 1000*0.5*0.5 = 250 → 1250
+    expect(computeBackoffDelay(0, cfg, () => 0)).toBe(750)
+    expect(computeBackoffDelay(0, cfg, () => 1)).toBe(1250)
+  })
+
+  it('never returns negative delays', () => {
+    const cfg = { initialMs: 100, maxMs: 10_000, multiplier: 1, jitter: 1 }
+    expect(computeBackoffDelay(0, cfg, () => -10)).toBeGreaterThanOrEqual(0)
+  })
+})

app/api/routes-b/_lib/audit-action-filter.ts

@@ -0,0 +1,50 @@
+/**
+ * audit-action-filter.ts — Issue #621
+ *
+ * Validates and builds the Prisma `where` clause for the audit-log
+ * `?action=...` (exact match) and `?actionPrefix=...` (prefix match)
+ * query parameters. Both compose with existing filters via AND.
+ */
+
+const PREFIX_MIN = 2;
+const PREFIX_MAX = 64;
+
+export type ActionFilterResult =
+  | { ok: true; clause: { eventType?: { equals?: string; startsWith?: string } } }
+  | { ok: false; error: string };
+
+/**
+ * Build a Prisma `eventType` filter clause from URL search params.
+ *
+ * - When both `action` and `actionPrefix` are missing → returns `{}` (no filter).
+ * - When `action` is present → `{ eventType: { equals: action } }`.
+ * - When `actionPrefix` is present → validates length [2, 64]; returns
+ *   `{ eventType: { startsWith: actionPrefix } }`.
+ * - When `actionPrefix` is invalid → returns `{ ok: false, error }`.
+ *
+ * If both are provided, `action` (exact) takes precedence — the more
+ * specific filter wins.
+ */
+export function buildActionFilter(
+  searchParams: URLSearchParams,
+): ActionFilterResult {
+  const action = searchParams.get('action')?.trim();
+  const actionPrefix = searchParams.get('actionPrefix')?.trim();
+
+  if (action) {
+    return { ok: true, clause: { eventType: { equals: action } } };
+  }
+
+  if (!actionPrefix) {
+    return { ok: true, clause: {} };
+  }
+
+  if (actionPrefix.length < PREFIX_MIN || actionPrefix.length > PREFIX_MAX) {
+    return {
+      ok: false,
+      error: `actionPrefix must be between ${PREFIX_MIN} and ${PREFIX_MAX} characters`,
+    };
+  }
+
+  return { ok: true, clause: { eventType: { startsWith: actionPrefix } } };
+}