Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma strängvärde byggs med konkatenering i stället för att matcha mönstret.
124 lines
4.3 KiB
TypeScript
124 lines
4.3 KiB
TypeScript
/**
|
|
* Putting a foreign receipt into kronor so it can be compared at all.
|
|
*
|
|
* Swedish banks post a converted SEK figure for a card purchase abroad, and
|
|
* the receipt states the original: Anthropic bills 180,00 EUR and the
|
|
* statement reads -2 014,32 kr. Neither number appears in the other document,
|
|
* so the matcher has always refused the pair rather than guess. On a
|
|
* SaaS-heavy ledger that is not an edge case: measured on a real company, 14
|
|
* of 25 fetched receipts were in USD or EUR and none of them could ever pair.
|
|
*
|
|
* The conversion is deliberately not a match on its own. It fills in the one
|
|
* missing number and hands the pair back to the same matcher, which still
|
|
* wants the merchant and the date to agree, and still applies its own
|
|
* tolerance. That tolerance is what absorbs the difference between
|
|
* Riksbanken's mid rate and what a card issuer actually charged: measured
|
|
* against real statements, Supabase came out 1.22% off and Vercel 1.23%,
|
|
* comfortably inside the 5% the matcher already allows.
|
|
*/
|
|
import type { SupabaseClient } from '@supabase/supabase-js'
|
|
import { convertToSEK, fetchExchangeRate } from '@/lib/currency/riksbanken'
|
|
import { roundOre } from '@/lib/money'
|
|
import { createLogger } from '@/lib/logger'
|
|
import type { HuntPoolItem } from './select'
|
|
|
|
const log = createLogger('receipt-hunt-fx')
|
|
|
|
/** Currencies Riksbanken publishes a series for. */
|
|
const SUPPORTED = new Set(['EUR', 'USD', 'GBP', 'NOK', 'DKK', 'CHF', 'JPY', 'PLN'])
|
|
|
|
interface Signals {
|
|
currency: string
|
|
total: number | null
|
|
date: string | null
|
|
}
|
|
|
|
function signalsOf(item: HuntPoolItem): Signals {
|
|
const data = item.extracted_data as
|
|
| {
|
|
invoice?: { currency?: string | null; invoiceDate?: string | null }
|
|
totals?: { total?: number | null }
|
|
}
|
|
| null
|
|
| undefined
|
|
return {
|
|
currency: (data?.invoice?.currency || 'SEK').toUpperCase(),
|
|
total: data?.totals?.total ?? null,
|
|
date: data?.invoice?.invoiceDate ?? null,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve a SEK total for every pool item stated in another currency.
|
|
*
|
|
* Rates are fetched once per currency and day and reused, because Riksbanken
|
|
* answers 429 to a caller that asks per document, and a run can hold a dozen
|
|
* receipts from the same vendor in the same month.
|
|
*
|
|
* An item whose rate cannot be resolved is returned untouched, which leaves it
|
|
* exactly as incomparable as it was before: the hunt loses nothing it had.
|
|
*/
|
|
export async function attachSekTotals(
|
|
supabase: SupabaseClient,
|
|
pool: readonly HuntPoolItem[],
|
|
): Promise<HuntPoolItem[]> {
|
|
const rates = new Map<string, number | null>()
|
|
|
|
const rateFor = async (currency: string, date: string | null): Promise<number | null> => {
|
|
// No date, no conversion. Reaching for today's rate would put a receipt
|
|
// whose age nobody knows into amount matching on the strength of a guess,
|
|
// and a rate two years out is how an incomparable receipt becomes a
|
|
// confident wrong pairing.
|
|
if (!date) return null
|
|
|
|
// Riksbanken publishes per day, so the day is the whole cache key.
|
|
const day = date
|
|
const key = `${currency}::${day}`
|
|
if (rates.has(key)) return rates.get(key) ?? null
|
|
|
|
try {
|
|
const rate = await fetchExchangeRate(currency as never, new Date(day), supabase as never)
|
|
rates.set(key, rate?.rate ?? null)
|
|
return rate?.rate ?? null
|
|
} catch (error) {
|
|
log.warn('could not resolve an exchange rate', {
|
|
currency,
|
|
day,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
})
|
|
rates.set(key, null)
|
|
return null
|
|
}
|
|
}
|
|
|
|
const out: HuntPoolItem[] = []
|
|
let converted = 0
|
|
|
|
for (const item of pool) {
|
|
const sig = signalsOf(item)
|
|
if (sig.currency === 'SEK' || sig.total == null || !SUPPORTED.has(sig.currency)) {
|
|
out.push(item)
|
|
continue
|
|
}
|
|
|
|
const rate = await rateFor(sig.currency, sig.date)
|
|
if (rate == null) {
|
|
out.push(item)
|
|
continue
|
|
}
|
|
|
|
converted++
|
|
out.push({
|
|
...item,
|
|
// Öre, like every other money value here: a raw float would put
|
|
// 1015.9700000000001 into a comparison against a bank amount.
|
|
sek_total: roundOre(convertToSEK(sig.total, rate)),
|
|
})
|
|
}
|
|
|
|
if (converted > 0) {
|
|
log.info('resolved foreign receipt totals', { converted, rates: rates.size })
|
|
}
|
|
return out
|
|
}
|