@dainamite/billing 0.21.0 → 0.22.0

package/src/modules/billing/__tests__/lib/invoiceDelivery.test.ts

@@ -97,6 +97,23 @@ describe('sendInvoice', () => {
     spy.mockRestore()
   })
 
+  it('loads the translator for the resolved document language (snapshot first, then account, else default)', async () => {
+    const spyLoader = jest.fn(async (_language: string) => (_key: string, fallback: string) => fallback)
+    const sendEmail = jest.fn(async () => undefined)
+    const run = async (snapshotLanguage: unknown, accountLanguage: string) => {
+      spyLoader.mockClear()
+      const { em } = makeEm(
+        invoiceRow({ buyerSnapshot: { name: 'Jan', invoice_language: snapshotLanguage } }),
+        { invoiceLanguage: accountLanguage },
+      )
+      await sendInvoice(em as never, { invoiceId: 'inv-1', ...scope, trigger: 'manual' }, { sendEmail, loadTranslator: spyLoader, now })
+      return spyLoader.mock.calls[0]?.[0]
+    }
+    expect(await run(' PL ', 'en')).toBe('pl')
+    expect(await run(undefined, 'pl')).toBe('pl')
+    expect(await run('xx', 'pl')).toBe('en')
+  })
+
   it('refuses drafts and test documents with 409 not_posted', async () => {
     for (const overrides of [{ status: 'draft' }, { testRun: true }]) {
       const { em } = makeEm(invoiceRow(overrides))

package/src/modules/billing/__tests__/lib/invoiceLanguages.test.ts

@@ -0,0 +1,49 @@
+import {
+  DEFAULT_INVOICE_LANGUAGE,
+  INVOICE_LANGUAGE_CODES,
+  SUPPORTED_INVOICE_LANGUAGES,
+  invoiceIntlLocale,
+  isSupportedInvoiceLanguage,
+  resolveInvoiceLanguage,
+} from '../../lib/invoiceLanguages'
+import { documentLocale } from '../../lib/pdf/invoiceModel'
+
+describe('invoice language registry', () => {
+  it('lists the default first and derives the code list from the registry', () => {
+    expect(SUPPORTED_INVOICE_LANGUAGES[0].code).toBe(DEFAULT_INVOICE_LANGUAGE)
+    expect(INVOICE_LANGUAGE_CODES).toEqual(SUPPORTED_INVOICE_LANGUAGES.map((l) => l.code))
+    expect(new Set(INVOICE_LANGUAGE_CODES).size).toBe(INVOICE_LANGUAGE_CODES.length)
+  })
+
+  it('gives every language an endonym label and a valid Intl locale', () => {
+    for (const language of SUPPORTED_INVOICE_LANGUAGES) {
+      expect(language.label.trim()).not.toBe('')
+      expect(Intl.DateTimeFormat.supportedLocalesOf([language.intlLocale])).toEqual([language.intlLocale])
+      expect(language.intlLocale.toLowerCase().startsWith(`${language.code}-`)).toBe(true)
+    }
+  })
+
+  it('resolves stored values: normalizes case / whitespace, falls back to the default', () => {
+    expect(resolveInvoiceLanguage(' PL ')).toBe('pl')
+    expect(resolveInvoiceLanguage('en')).toBe('en')
+    expect(resolveInvoiceLanguage('xx')).toBe(DEFAULT_INVOICE_LANGUAGE)
+    expect(resolveInvoiceLanguage('')).toBe(DEFAULT_INVOICE_LANGUAGE)
+    expect(resolveInvoiceLanguage(null)).toBe(DEFAULT_INVOICE_LANGUAGE)
+    expect(resolveInvoiceLanguage(undefined)).toBe(DEFAULT_INVOICE_LANGUAGE)
+  })
+
+  it('checks support strictly (no normalization)', () => {
+    expect(isSupportedInvoiceLanguage('pl')).toBe(true)
+    expect(isSupportedInvoiceLanguage('PL')).toBe(false)
+    expect(isSupportedInvoiceLanguage('xx')).toBe(false)
+  })
+
+  it('maps languages to their Intl locale; documentLocale delegates to the registry', () => {
+    for (const language of SUPPORTED_INVOICE_LANGUAGES) {
+      expect(invoiceIntlLocale(language.code)).toBe(language.intlLocale)
+      expect(documentLocale(language.code)).toBe(language.intlLocale)
+    }
+    expect(invoiceIntlLocale('xx')).toBe('en-GB')
+    expect(documentLocale('xx')).toBe('en-GB')
+  })
+})

package/src/modules/billing/__tests__/lib/pdf/invoicePdf.test.ts

@@ -5,9 +5,14 @@ import {
   type PdfInvoice,
   type PdfLine,
 } from '../../../lib/pdf/invoiceModel'
-import { renderInvoicePdf, sanitizeForFont } from '../../../lib/pdf/invoiceTemplate'
+import fontkit from '@pdf-lib/fontkit'
+import { TABLE_COLUMNS, renderInvoicePdf, sanitizeForFont, wrap } from '../../../lib/pdf/invoiceTemplate'
+import { NOTO_SANS_BOLD_BASE64 } from '../../../lib/pdf/fonts/embeddedFonts'
 import en from '../../../i18n/en.json'
 import pl from '../../../i18n/pl.json'
+import es from '../../../i18n/es.json'
+import de from '../../../i18n/de.json'
+import type { InvoiceLanguageCode } from '../../../lib/invoiceLanguages'
 
 const translator = (dict: Record<string, string>): DocumentTranslate => (key, fallback) => dict[key] ?? fallback
 
@@ -58,14 +63,16 @@ const seller = {
 
 const buyer = { name: 'Jan Kowalski', address: { line1: 'ul. Testowa 1', city: 'Warszawa', postal_code: '00-001', country: 'PL' }, taxId: null }
 
-function model(language: 'en' | 'pl', overrides: Partial<PdfInvoice> = {}, docLines: PdfLine[] = lines) {
+const DICTIONARIES: Record<InvoiceLanguageCode, Record<string, string>> = { en, pl, es, de }
+
+function model(language: InvoiceLanguageCode, overrides: Partial<PdfInvoice> = {}, docLines: PdfLine[] = lines) {
   return buildInvoiceDocumentModel({
     invoice: { ...invoice, ...overrides },
     lines: docLines,
     seller,
     buyer,
     language,
-    translate: translator(language === 'pl' ? (pl as Record<string, string>) : (en as Record<string, string>)),
+    translate: translator(DICTIONARIES[language]),
   })
 }
 
@@ -96,6 +103,43 @@ describe('buildInvoiceDocumentModel', () => {
     expect(m.seller.heading).toBe('Sprzedawca')
   })
 
+  it('builds Spanish labels and es-ES money / dates (invoice and credit memo)', () => {
+    const m = model('es', { currencyCode: 'EUR', totalGross: '1234.5600' })
+    expect(m.title).toBe('Factura')
+    expect(m.meta).toEqual(expect.arrayContaining([['Fecha de emisión', '14/11/2026']]))
+    expect(m.table.headers).toEqual(expect.arrayContaining(['Cant.', 'Precio unit.', '% IVA', 'IVA']))
+    expect(m.totals[0][0]).toBe('Base imponible')
+    expect(m.totals[2]).toEqual(['Total a pagar', '1234,56 €'])
+    // The payment matcher looks for the invoice number in the transfer title.
+    expect(m.payment?.lines).toContain('Concepto: INV/2026/11/0007')
+    expect(m.seller.heading).toBe('Emisor')
+    expect(m.buyer.heading).toBe('Cliente')
+    expect(m.vatSummary.heading).toBe('Resumen de IVA')
+    expect(m.pageLabel(1, 2)).not.toContain('{')
+    const memo = model('es', { documentType: 'credit_memo', correctsNumber: 'INV/2026/10/0003', correctsIssueDate: '2026-10-05' })
+    expect(memo.title).toBe('Factura rectificativa')
+    expect(memo.meta).toEqual(expect.arrayContaining([['Rectifica', 'INV/2026/10/0003 de 05/10/2026']]))
+    expect(memo.totals[2][0]).toBe('Total abonado')
+    expect(memo.payment?.lines.join(' ')).toContain('INV/2026/10/0003')
+    expect(model('es', { status: 'draft' }).watermark).toBe('BORRADOR')
+  })
+
+  it('builds German labels and de-DE money / dates (invoice and credit memo)', () => {
+    const m = model('de', { currencyCode: 'EUR', totalGross: '1234.5600' })
+    expect(m.title).toBe('Rechnung')
+    expect(m.meta).toEqual(expect.arrayContaining([['Leistungszeitraum', '01.11.2026 – 30.11.2026']]))
+    expect(m.table.headers).toEqual(expect.arrayContaining(['Anz.', 'Einzelpreis netto', 'USt. %', 'USt.']))
+    expect(m.totals[2]).toEqual(['Zahlbetrag', '1.234,56 €'])
+    expect(m.payment?.lines).toContain('Verwendungszweck: INV/2026/11/0007')
+    expect(m.seller.heading).toBe('Rechnungssteller')
+    expect(m.buyer.heading).toBe('Rechnungsempfänger')
+    const memo = model('de', { documentType: 'credit_memo', correctsNumber: 'INV/2026/10/0003', correctsIssueDate: '2026-10-05' })
+    expect(memo.title).toBe('Rechnungskorrektur')
+    expect(memo.meta).toEqual(expect.arrayContaining([['Korrigiert', 'INV/2026/10/0003 vom 05.10.2026']]))
+    expect(memo.totals[2][0]).toBe('Gutgeschriebener Betrag')
+    expect(model('de', { status: 'draft' }).watermark).toBe('ENTWURF')
+  })
+
   it('groups the VAT summary by rate (highest first) and it adds up to the totals', () => {
     const m = model('en')
     expect(m.vatSummary.rows.map((r) => r[0])).toEqual(['23 %', '8 %', '0 %'])
@@ -149,8 +193,8 @@ describe('buildInvoiceDocumentModel', () => {
 
   it('splits the footer into lines and falls back to English for unknown languages', () => {
     expect(model('en').footer).toEqual(['KRS 0000000000', 'Kapitał zakładowy 5 000 zł'])
-    const de = buildInvoiceDocumentModel({ invoice, lines, seller, buyer, language: 'de', translate: translator({}) })
-    expect(de.meta[1]).toEqual(['Issue date', '14/11/2026'])
+    const unknown = buildInvoiceDocumentModel({ invoice, lines, seller, buyer, language: 'xx', translate: translator({}) })
+    expect(unknown.meta[1]).toEqual(['Issue date', '14/11/2026'])
   })
 })
 
@@ -178,6 +222,32 @@ describe('renderInvoicePdf', () => {
     expect(await pages(80)).toBe(3)
   }, 30_000)
 
+  it.each(['es', 'de'] as const)('renders a one-page %s document with its own title and diacritics', async (language) => {
+    const m = model(language, { currencyCode: 'EUR' })
+    const doc = await PDFDocument.load(await renderInvoicePdf(m))
+    expect(doc.getPageCount()).toBe(1)
+    expect(doc.getTitle()).toBe(`${m.title} INV/2026/11/0007`)
+  }, 30_000)
+
+  it.each(['en', 'es', 'de', 'pl'] as const)(
+    'fits %s column headers in their columns with the real font (no mid-word split, at most 3 lines)',
+    async (language) => {
+      const doc = await PDFDocument.create()
+      doc.registerFontkit(fontkit)
+      const bold = await doc.embedFont(Buffer.from(NOTO_SANS_BOLD_BASE64, 'base64'), { subset: true })
+      // Same size / padding the template uses for table headers (SMALL_SIZE = 8, 3pt each side).
+      model(language).table.headers.forEach((header, i) => {
+        const width = TABLE_COLUMNS[i] - 6
+        const lines = wrap(header, bold, 8, width)
+        expect({ header, lines: lines.length }).toEqual({ header, lines: expect.any(Number) })
+        expect(lines.length).toBeLessThanOrEqual(3)
+        // Every wrapped line is a whole word (or words): no word was cut by characters.
+        const words = new Set(header.split(/\s+/))
+        for (const part of lines) for (const w of part.split(' ')) expect({ header, word: w, whole: words.has(w) }).toEqual({ header, word: w, whole: true })
+      })
+    },
+  )
+
   it('wraps long descriptions instead of overflowing the column', async () => {
     const long = line({ description: 'Bardzo długi opis usługi '.repeat(12) })
     const bytes = await renderInvoicePdf(model('en', {}, [long]))

package/src/modules/billing/__tests__/validators.test.ts

@@ -398,10 +398,14 @@ describe('billingAccountCreateSchema', () => {
 
   it('rejects an invoice language the template does not support', () => {
     expect(() =>
-      billingAccountCreateSchema.parse({ ...validAccountCreate, invoiceLanguage: 'de' }),
+      billingAccountCreateSchema.parse({ ...validAccountCreate, invoiceLanguage: 'fr' }),
     ).toThrow()
   })
 
+  it.each(['en', 'es', 'de', 'pl'])('accepts the supported invoice language %s (case-insensitive)', (code) => {
+    expect(billingAccountCreateSchema.parse({ ...validAccountCreate, invoiceLanguage: ` ${code.toUpperCase()} ` }).invoiceLanguage).toBe(code)
+  })
+
   it('defaults invoiceLanguage when omitted', () => {
     const { invoiceLanguage, ...withoutLanguage } = validAccountCreate
     void invoiceLanguage

package/src/modules/billing/api/accounts/route.ts

@@ -10,6 +10,7 @@ import { fetchAccountFinancials, fetchOverdueAccountIds, financialsOrZero } from
 /** A uuid no row has — narrows an `$in` filter to nothing. */
 const NO_MATCH_ID = '00000000-0000-4000-8000-000000000000'
 import { billingEntityIds } from '../../data/entityIds'
+import { DEFAULT_INVOICE_LANGUAGE, INVOICE_LANGUAGE_CODES } from '../../lib/invoiceLanguages'
 import {
   billingAccountCreateSchema,
   billingAccountListQuerySchema,
@@ -243,7 +244,7 @@ export const openApi = createBillingCrudOpenApi({
     responseSchema: defaultCreateResponseSchema,
     description:
       'Creates a new billing account for a customer — a company or a person (`customerKind`, default `company`). ' +
-      '`invoiceLanguage` must be a language supported by the invoice template (`en`, `pl`; default `en`).',
+      `\`invoiceLanguage\` must be a language supported by the invoice template (${INVOICE_LANGUAGE_CODES.map((c) => `\`${c}\``).join(', ')}; default \`${DEFAULT_INVOICE_LANGUAGE}\`).`,
   },
   update: {
     schema: billingAccountUpdateSchema,

package/src/modules/billing/api/invoices/[id]/pdf/route.ts

@@ -4,6 +4,7 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { BillingInvoice } from '../../../../data/entities'
 import { getInvoicePdf } from '../../../../lib/pdf/invoicePdf'
+import { INVOICE_LANGUAGE_CODES } from '../../../../lib/invoiceLanguages'
 
 /**
  * `GET /api/billing/invoices/[id]/pdf` — the document PDF (Spec B).
@@ -71,7 +72,7 @@ export const openApi = {
       description:
         '`application/pdf`. Posted documents return the PDF frozen at post (an attachment); drafts ' +
         'and test documents are rendered live with a DRAFT / TEST watermark and never stored. ' +
-        'Labels follow the account invoice language (en / pl).',
+        `Labels follow the account invoice language (${INVOICE_LANGUAGE_CODES.join(' / ')}).`,
       responses: [{ status: 200, description: 'PDF document (`application/pdf`)' }],
       errors: [{ status: 404, description: 'Invoice not found in this organization' }],
     },

package/src/modules/billing/data/entities.ts

@@ -83,7 +83,8 @@ export class BillingAccount {
   @Property({ name: 'invoice_email', type: 'text' })
   invoiceEmail!: string
 
-  // ISO 639-1 (`en`, `pl`, …). Used by mailer / template renderer.
+  // ISO 639-1; allowed values come from `lib/invoiceLanguages.ts` (Zod-validated,
+  // no DB constraint). Used by mailer / template renderer.
   @Property({ name: 'invoice_language', type: 'text' })
   invoiceLanguage!: string