Å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.
336 lines
14 KiB
TypeScript
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
|
|
}
|
|
}
|