Files
accounted/lib/invoices/pdf-render-helpers.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Å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.
2026-11-10 09:37:22 +01:00

336 lines
14 KiB
TypeScript

/**
* Shared helpers for invoice PDF render call sites.
*
* Three responsibilities:
* 1. Build the branding object from company settings.
* 2. Resolve the company logo into a format @react-pdf/renderer can draw.
* 3. Build the optional Swish payment QR.
*
* Why the logo needs resolving (issue #772: "Logotyp kommer inte med på
* fakturor"): @react-pdf/renderer's <Image> only decodes JPG and PNG, but the
* logo upload route and the `logos` storage bucket both accept SVG and WebP.
* When the logo is an SVG/WebP, @react-pdf fails to decode it and *silently*
* swallows the error (a console.warn inside a try/catch in its fetchImage step):
* so the invoice renders fine but with no logo, and nothing surfaces.
*
* Fix: fetch the stored logo and re-encode it to a PNG data URL via sharp, then
* hand the template a company whose `logo_url` is that data URL. This makes the
* logo render regardless of the uploaded format and removes the render-time
* dependency on a remote fetch succeeding inside @react-pdf.
*/
import QRCode from 'qrcode'
import type { CompanySettings, Currency, Invoice, InvoicePaymentAccount } from '@/types'
import { brandingFromCompanySettings, SHOW_SWISH_ON_INVOICE, type InvoiceBranding } from '@/lib/invoices/pdf-template'
import { buildSwishQrPayload } from '@/lib/payments/swish'
import { getAmountToPay } from '@/lib/invoices/rounding'
import { createLogger } from '@/lib/logger'
import { isUnsafeUrlError, readBodyWithCap, safeFetch } from '@/lib/http/safe-fetch'
import { LOGO_UPLOAD_MAX_BYTES } from '@/lib/invoices/branding-constants'
import { prepareInvoiceFont } from '@/lib/invoices/pdf-fonts'
import {
assertInvoicePaymentAccountForRender,
companyWithInvoicePaymentAccount,
} from '@/lib/invoices/payment-accounts'
const log = createLogger('invoice.swish-qr')
const paymentLinkLog = createLogger('invoice.payment-link-qr')
const logoLog = createLogger('invoice.logo')
export interface InvoicePdfRenderExtras {
branding: InvoiceBranding
/**
* The company settings to pass to InvoicePDF. Identical to the input except
* `logo_url` is replaced by an embedded PNG data URL when the stored logo
* could be fetched and re-encoded, or set to null when the stored URL was
* refused by the outbound URL guard (the invoice then renders without a
* logo). A transient failure keeps the original URL only when it points at
* the deployment's own storage origin; @react-pdf must never be handed an
* arbitrary remote URL to fetch unguarded.
*/
company: CompanySettings
}
export interface InvoicePdfRenderOptions {
paymentAccountRequired?: boolean
/**
* The invoice's own frozen payee (invoices.payment_details) when it chose
* a bank account. Null/undefined = the company's default for the currency.
*/
payee?: Partial<InvoicePaymentAccount> | null
}
// A company's logo is reused across every invoice render, and twice per send
// (preflight + final render), and once per invoice in recurring/batch loops:
// so cache the re-encoded result keyed by logo URL. Only successes are cached
// (with a short TTL); a transient fetch blip is retried on the next render
// rather than sticking around as a logo-less invoice. Bounded so a long-lived
// self-hosted process doesn't grow the map without limit.
const LOGO_CACHE_TTL_MS = 5 * 60 * 1000
const LOGO_CACHE_MAX = 50
const logoDataUrlCache = new Map<string, { dataUrl: string; at: number }>()
// The invoice draws the logo at up to 240pt by 80pt, so 600px keeps it crisp
// while bounding the embedded base64 payload.
const LOGO_MAX_PX = 600
// Bound the logo fetch so a slow or oversized response can't hang or balloon an
// invoice render. The upload route only ever writes Supabase `logos`-bucket
// URLs, but company members can PATCH `company_settings.logo_url` directly
// through PostgREST, so the stored value is tenant-controlled input that this
// server fetches: it goes through `safeFetch` (public address only, no
// redirects) unless it sits on the deployment's own storage origin.
const LOGO_FETCH_TIMEOUT_MS = 5_000
/**
* What became of a stored logo URL:
* embedded: fetched, re-encoded, safe to hand to @react-pdf as a data URL
* refused: the outbound URL guard said no (private address, non-http(s),
* redirect); the invoice renders without a logo
* failed: transient or decode failure after the guard passed
*/
type LogoResolution =
| { kind: 'embedded'; dataUrl: string }
| { kind: 'refused' }
| { kind: 'failed' }
// Coalesce concurrent renders of the same logo (preflight + final on a send, and
// every invoice in a recurring/batch loop) onto one in-flight fetch+encode
// instead of each doing the full round-trip before the first result is cached.
const logoInflight = new Map<string, Promise<LogoResolution>>()
/**
* The origin the app's own Supabase storage lives on. Logos uploaded through
* the app always resolve here, and on a self-hosted install this origin may
* legitimately be a private address (a NAS on the LAN), so it is exempt from
* the public-address check. Redirect refusal and the size cap still apply.
*/
function trustedLogoOrigins(): string[] {
const raw = process.env.NEXT_PUBLIC_SUPABASE_URL
if (!raw) return []
try {
return [new URL(raw).origin]
} catch {
return []
}
}
function isTrustedLogoOrigin(logoUrl: string): boolean {
try {
return trustedLogoOrigins().includes(new URL(logoUrl).origin)
} catch {
return false
}
}
/**
* Fetch a stored logo and re-encode it to a PNG data URL. Concurrent calls
* for the same URL share a single in-flight request; only successes are
* cached so a transient blip is retried on the next render.
*/
async function resolveLogoDataUrl(logoUrl: string): Promise<LogoResolution> {
// Already embedded: nothing to fetch or convert.
if (logoUrl.startsWith('data:')) return { kind: 'embedded', dataUrl: logoUrl }
const cached = logoDataUrlCache.get(logoUrl)
if (cached && Date.now() - cached.at < LOGO_CACHE_TTL_MS) {
return { kind: 'embedded', dataUrl: cached.dataUrl }
}
const inflight = logoInflight.get(logoUrl)
if (inflight) return inflight
const work = encodeLogo(logoUrl)
logoInflight.set(logoUrl, work)
try {
return await work
} finally {
// Only successes are cached (in encodeLogo); dropping the in-flight entry
// here lets a transient failure be retried on the next render.
logoInflight.delete(logoUrl)
}
}
async function encodeLogo(logoUrl: string): Promise<LogoResolution> {
let res: Response
try {
res = await safeFetch(
logoUrl,
{ signal: AbortSignal.timeout(LOGO_FETCH_TIMEOUT_MS) },
{ trustedOrigins: trustedLogoOrigins() },
)
} catch (err) {
if (isUnsafeUrlError(err)) {
logoLog.warn('logo URL refused by outbound URL guard; rendering without logo', {
reason: err.reason,
detail: err.detail,
})
return { kind: 'refused' }
}
return { kind: 'failed' }
}
try {
if (!res.ok) return { kind: 'failed' }
// Declared Content-Length is checked before any byte is read, and the
// stream is cut off at the cap in case the header lied or was absent.
const input = await readBodyWithCap(res, LOGO_UPLOAD_MAX_BYTES)
if (!input) return { kind: 'failed' }
// SVGs must be rasterized at a higher density or sharp renders them at
// their intrinsic (often tiny) pixel size and the result looks blurry.
const contentType = res.headers.get('content-type') ?? ''
const isSvg =
/svg/i.test(contentType) ||
input.subarray(0, 256).toString('utf8').trimStart().startsWith('<')
// Lazy, isolated import: if sharp ever fails to load in a given runtime we
// degrade instead of breaking invoice sending entirely.
const { default: sharp } = await import('sharp')
const png = await sharp(input, isSvg ? { density: 288 } : {})
.resize({
width: LOGO_MAX_PX,
height: LOGO_MAX_PX,
fit: 'inside',
withoutEnlargement: true,
})
.png()
.toBuffer()
const dataUrl = `data:image/png;base64,${png.toString('base64')}`
// Refresh insertion order so eviction is LRU-ish, then bound the cache.
logoDataUrlCache.delete(logoUrl)
if (logoDataUrlCache.size >= LOGO_CACHE_MAX) {
const oldest = logoDataUrlCache.keys().next().value
if (oldest !== undefined) logoDataUrlCache.delete(oldest)
}
logoDataUrlCache.set(logoUrl, { dataUrl, at: Date.now() })
return { kind: 'embedded', dataUrl }
} catch {
return { kind: 'failed' }
}
}
/**
* Apply the logo resolution to the company handed to the PDF template.
*
* On a transient failure the original URL is kept only when it points at our
* own storage origin (the pre-existing "never worse than before" fallback:
* @react-pdf can still draw a PNG/JPEG from there). For any other origin the
* logo is dropped instead: handing @react-pdf a remote URL means it fetches
* it with a plain, redirect-following fetch, which is exactly the unguarded
* request this module exists to prevent.
*/
function applyLogoResolution(company: CompanySettings, resolution: LogoResolution): CompanySettings {
if (resolution.kind === 'embedded') {
return resolution.dataUrl === company.logo_url
? company
: { ...company, logo_url: resolution.dataUrl }
}
if (resolution.kind === 'refused') return { ...company, logo_url: null }
return company.logo_url && isTrustedLogoOrigin(company.logo_url)
? company
: { ...company, logo_url: null }
}
export async function prepareInvoicePdfRender(
company: CompanySettings,
currency?: Currency,
options: InvoicePdfRenderOptions = {},
): Promise<InvoicePdfRenderExtras> {
if (currency && options.paymentAccountRequired !== false) {
assertInvoicePaymentAccountForRender(company, currency, options.payee ?? null)
}
const branding = await prepareInvoiceFont(
company,
brandingFromCompanySettings(company),
)
const paymentCompany = currency
? companyWithInvoicePaymentAccount(company, currency, options.payee ?? null)
: company
if (!paymentCompany.logo_url) return { branding, company: paymentCompany }
const resolution = await resolveLogoDataUrl(paymentCompany.logo_url)
return { branding, company: applyLogoResolution(paymentCompany, resolution) }
}
/**
* Build the payment-link QR for an invoice as a PNG data URL, or null when the
* invoice carries no payment_link_url or it isn't a payable document (credit
* notes, proformas and delivery notes show no payment box). The URL was
* https-validated at write time (lib/api/schemas.ts); the QR simply encodes it
* locally with the `qrcode` lib: no call to any payment provider.
*/
export async function buildPaymentLinkQrDataUrl(invoice: Invoice): Promise<string | null> {
const url = invoice.payment_link_url?.trim()
if (!url) return null
const docType = invoice.document_type || 'invoice'
if (docType !== 'invoice' || invoice.credited_invoice_id) return null
try {
return await QRCode.toDataURL(url, { margin: 1, width: 240, errorCorrectionLevel: 'M' })
} catch (err) {
paymentLinkLog.warn('payment link QR generation failed', {
invoiceId: invoice.id,
error: err instanceof Error ? err.message : String(err),
})
return null
}
}
/**
* Build the Swish payment QR for an invoice as a PNG data URL, or null when:
* Swish display is off, the document isn't a payable invoice (credit notes,
* proformas and delivery notes collect no payment), there's no/invalid Swish
* number, the invoice isn't in SEK (Swish is SEK-only), or the amount to pay
* is not positive. The encoded amount is the customer-facing "Att betala"
* from getAmountToPay: the rounded total minus any ROT/RUT deduction, the
* same figure the PDF totals block and the invoice email state. The Swish payload locks the amount (editmask 0),
* so encoding anything else makes the customer overpay with no way to correct
* it in the app. A fully deducted invoice (toPay = 0) therefore renders no QR.
* Generated locally with the `qrcode` lib: no call to any Swish API. Pass the
* result to InvoicePDF's `swishQrDataUrl` prop; the template gates rendering
* on the same payment box that already shows the Swish number.
*/
export async function buildSwishQrDataUrl(
company: CompanySettings,
invoice: Invoice,
): Promise<string | null> {
// Swish on invoices is "coming soon": gated off in pdf-template. Bail before
// any work while the feature is disabled.
if (!SHOW_SWISH_ON_INVOICE) return null
// Swish display off is the normal "no QR" case: stay quiet. Every other
// skip is logged so a missing QR is diagnosable instead of silent.
if (!(company.invoice_show_swish ?? false)) return null
// Non-payable documents: the PDF hides the whole payment box for them, and
// a locked payment QR on a kreditfaktura (a refund document, "Er tillgodo")
// must stay impossible even if a template regression ever exposed the
// corner. Same gate as buildPaymentLinkQrDataUrl; quiet like display-off.
const docType = invoice.document_type || 'invoice'
if (docType !== 'invoice' || invoice.credited_invoice_id) return null
if ((invoice.currency ?? 'SEK') !== 'SEK') {
log.info('swish QR skipped: invoice not in SEK', { invoiceId: invoice.id, currency: invoice.currency })
return null
}
const amount = getAmountToPay(invoice, company).toPay
const payload = buildSwishQrPayload(company.swish, amount, invoice.invoice_number ?? '')
if (!payload) {
log.warn('swish QR skipped: invalid number or non-positive amount', {
invoiceId: invoice.id,
hasSwish: !!company.swish,
amount,
})
return null
}
try {
return await QRCode.toDataURL(payload, { margin: 1, width: 240, errorCorrectionLevel: 'M' })
} catch (err) {
log.warn('swish QR generation failed', {
invoiceId: invoice.id,
error: err instanceof Error ? err.message : String(err),
})
return null
}
}