@fast-white-cat/integration-ksef-direct 0.1.0

package/src/modules/integration_ksef_direct/lib/ksefCrypto.ts

@@ -0,0 +1,138 @@
+import crypto from 'node:crypto'
+
+type KsefEnvironment = 'test' | 'production'
+
+const BASE_URLS: Record<KsefEnvironment, string> = {
+  test: 'https://api-test.ksef.mf.gov.pl/v2',
+  production: 'https://api.ksef.mf.gov.pl/v2',
+}
+
+interface PublicKeyCacheEntry {
+  publicKeyPem: string
+  fetchedAt: number
+}
+
+const PUBLIC_KEY_CACHE = new Map<KsefEnvironment, PublicKeyCacheEntry>()
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000
+
+interface PublicKeyCertificateEntry {
+  certificate: string
+  certificateId: string
+  publicKeyId?: string
+  validFrom?: string
+  validTo?: string
+  usage?: string[]
+}
+
+async function fetchCertificates(environment: KsefEnvironment): Promise<PublicKeyCertificateEntry[]> {
+  const url = `${BASE_URLS[environment]}/security/public-key-certificates`
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: { 'Accept': 'application/json' },
+    signal: AbortSignal.timeout(10_000),
+  })
+  if (!response.ok) {
+    throw new Error(`Failed to fetch KSeF public key certificates: HTTP ${response.status}`)
+  }
+  const data = await response.json() as PublicKeyCertificateEntry[]
+  if (!Array.isArray(data)) {
+    throw new Error('KSeF public key response is not an array')
+  }
+  return data
+}
+
+function certToPem(entry: PublicKeyCertificateEntry): string {
+  const derBuffer = Buffer.from(entry.certificate, 'base64')
+  const x509 = new crypto.X509Certificate(derBuffer)
+  return x509.publicKey.export({ type: 'spki', format: 'pem' }).toString()
+}
+
+export async function fetchPublicKey(environment: KsefEnvironment): Promise<string> {
+  const cached = PUBLIC_KEY_CACHE.get(environment)
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.publicKeyPem
+  }
+
+  const certs = await fetchCertificates(environment)
+  const tokenCert = certs.find(entry => entry.usage?.includes('KsefTokenEncryption'))
+  if (!tokenCert?.certificate) {
+    throw new Error('KSeF public key response missing KsefTokenEncryption certificate')
+  }
+  const publicKeyPem = certToPem(tokenCert)
+  PUBLIC_KEY_CACHE.set(environment, { publicKeyPem, fetchedAt: Date.now() })
+  return publicKeyPem
+}
+
+export async function fetchInvoicePublicKey(
+  environment: KsefEnvironment,
+): Promise<{ publicKeyPem: string; publicKeyId?: string }> {
+  const certs = await fetchCertificates(environment)
+  const invoiceCert = certs.find(entry => entry.usage?.includes('SymmetricKeyEncryption'))
+    ?? certs.find(entry => entry.usage?.includes('KsefTokenEncryption'))
+  if (!invoiceCert?.certificate) {
+    throw new Error('KSeF public key response missing invoice encryption certificate')
+  }
+  return { publicKeyPem: certToPem(invoiceCert), publicKeyId: invoiceCert.publicKeyId }
+}
+
+export function clearPublicKeyCache(environment?: KsefEnvironment): void {
+  if (environment) {
+    PUBLIC_KEY_CACHE.delete(environment)
+  } else {
+    PUBLIC_KEY_CACHE.clear()
+  }
+}
+
+export function encryptKsefToken(token: string, timestampMs: number, publicKeyPem: string): string {
+  const plaintext = `${token}|${timestampMs}`
+  const encrypted = crypto.publicEncrypt(
+    {
+      key: publicKeyPem,
+      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+      oaepHash: 'sha256',
+    },
+    Buffer.from(plaintext, 'utf-8'),
+  )
+  return encrypted.toString('base64')
+}
+
+export function generateSymmetricKey(): { key: Buffer; iv: Buffer } {
+  return {
+    key: crypto.randomBytes(32),
+    iv: crypto.randomBytes(16),
+  }
+}
+
+export function prepareInvoicePayload(
+  xmlString: string,
+  publicKeyPem: string,
+): {
+  encryptedSymmetricKey: string
+  initializationVector: string
+  encryptedInvoiceContent: string
+  invoiceHash: string
+  invoiceSize: number
+  encryptedInvoiceHash: string
+  encryptedInvoiceSize: number
+} {
+  const { key, iv } = generateSymmetricKey()
+  const xmlBytes = Buffer.from(xmlString, 'utf-8')
+
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
+  const encryptedContent = Buffer.concat([cipher.update(xmlBytes), cipher.final()])
+
+  const encryptedSymmetricKey = crypto.publicEncrypt(
+    { key: publicKeyPem, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: 'sha256' },
+    key,
+  )
+
+  return {
+    encryptedSymmetricKey: encryptedSymmetricKey.toString('base64'),
+    initializationVector: iv.toString('base64'),
+    encryptedInvoiceContent: encryptedContent.toString('base64'),
+    invoiceHash: crypto.createHash('sha256').update(xmlBytes).digest('base64'),
+    invoiceSize: xmlBytes.length,
+    encryptedInvoiceHash: crypto.createHash('sha256').update(encryptedContent).digest('base64'),
+    encryptedInvoiceSize: encryptedContent.length,
+  }
+}

package/src/modules/integration_ksef_direct/lib/ksefFa2Xml.ts

@@ -0,0 +1,147 @@
+import type { KsefDirectDocument } from '../data/entities'
+
+export class KsefXmlGenerationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'KsefXmlGenerationError'
+  }
+}
+
+export type SellerInfo = {
+  sellerName: string
+  sellerAddressL1?: string
+  sellerCity?: string
+  sellerCountry?: string
+}
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+}
+
+function formatDate(date: Date): string {
+  return date.toISOString().split('T')[0]!
+}
+
+// vatRate → { suffix for P_13/P_14, p12Code for FaWiersz.P_12, whether VAT amount applies }
+const VAT_RATE_GROUPS: Record<string, { suffix: string; p12Code: string; hasVat: boolean }> = {
+  '23': { suffix: '1', p12Code: '23', hasVat: true },
+  '8':  { suffix: '2', p12Code: '8',  hasVat: true },
+  '5':  { suffix: '3', p12Code: '5',  hasVat: true },
+  '0':  { suffix: '4', p12Code: '0',  hasVat: false },
+  'ZW': { suffix: '5', p12Code: 'zw', hasVat: false },
+  'NP': { suffix: '6', p12Code: 'np', hasVat: false },
+}
+
+export function generateFa2Xml(document: KsefDirectDocument, seller: SellerInfo): string {
+  if (!seller.sellerName.trim()) {
+    throw new KsefXmlGenerationError('sellerName is required for FA_VAT 2.0 XML generation')
+  }
+  if (!seller.sellerAddressL1?.trim()) {
+    throw new KsefXmlGenerationError('sellerAddressL1 is required for FA_VAT 2.0 XML generation')
+  }
+
+  const now = new Date()
+  const issueDate = formatDate(document.issueDate)
+  const saleDate = document.saleDate ? formatDate(document.saleDate) : issueDate
+
+  const lineItemsXml = document.lineItems.map((item, index) => {
+    const group = VAT_RATE_GROUPS[item.vatRate]
+    const p12 = group?.p12Code ?? item.vatRate
+    return `
+  <FaWiersz>
+    <NrWierszaFa>${index + 1}</NrWierszaFa>
+    <P_7>${escapeXml(item.description)}</P_7>
+    <P_8A>${escapeXml(item.unit)}</P_8A>
+    <P_8B>${item.quantity}</P_8B>
+    <P_9A>${item.unitNetPrice.toFixed(2)}</P_9A>
+    <P_11>${item.netAmount.toFixed(2)}</P_11>
+    <P_12>${escapeXml(p12)}</P_12>
+  </FaWiersz>`
+  }).join('')
+
+  // Group by VAT rate, accumulate net + vat amounts
+  const groups = new Map<string, { net: number; vat: number; hasVat: boolean }>()
+  for (const item of document.lineItems) {
+    const group = VAT_RATE_GROUPS[item.vatRate]
+    if (!group) continue
+    const existing = groups.get(group.suffix) ?? { net: 0, vat: 0, hasVat: group.hasVat }
+    groups.set(group.suffix, {
+      net: existing.net + item.netAmount,
+      vat: existing.vat + item.vatAmount,
+      hasVat: group.hasVat,
+    })
+  }
+
+  // Sort suffix numerically for deterministic output
+  const sortedSuffixes = [...groups.keys()].sort()
+  const vatSummaryXml = sortedSuffixes.map((suffix) => {
+    const g = groups.get(suffix)!
+    const net = `\n    <P_13_${suffix}>${g.net.toFixed(2)}</P_13_${suffix}>`
+    const vat = g.hasVat ? `\n    <P_14_${suffix}>${g.vat.toFixed(2)}</P_14_${suffix}>` : ''
+    return net + vat
+  }).join('')
+
+  // TAdres: KodKraju → AdresL1 → [AdresL2] — city goes in AdresL2, no Miejscowosc element
+  const adresL2 = seller.sellerCity?.trim()
+    ? `\n      <AdresL2>${escapeXml(seller.sellerCity)}</AdresL2>`
+    : ''
+  const adresXml = `
+    <Adres>
+      <KodKraju>${escapeXml(seller.sellerCountry ?? 'PL')}</KodKraju>
+      <AdresL1>${escapeXml(seller.sellerAddressL1)}</AdresL1>${adresL2}
+    </Adres>`
+
+  const grossAmount = parseFloat(String(document.grossAmount)).toFixed(2)
+
+  // FA(2) v1-0E Fa sequence: KodWaluty → P_1 → P_2A → P_6 → VAT summaries → P_15 → Adnotacje → RodzajFaktury → FaWiersz
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Faktura xmlns="http://crd.gov.pl/wzor/2023/06/29/12648/">
+  <Naglowek>
+    <KodFormularza kodSystemowy="FA (2)" wersjaSchemy="1-0E">FA</KodFormularza>
+    <WariantFormularza>2</WariantFormularza>
+    <DataWytworzeniaFa>${now.toISOString()}</DataWytworzeniaFa>
+    <SystemInfo>OpenMercato</SystemInfo>
+  </Naglowek>
+  <Podmiot1>
+    <DaneIdentyfikacyjne>
+      <NIP>${escapeXml(document.sellerNip)}</NIP>
+      <Nazwa>${escapeXml(seller.sellerName)}</Nazwa>
+    </DaneIdentyfikacyjne>${adresXml}
+  </Podmiot1>
+  <Podmiot2>
+    <DaneIdentyfikacyjne>
+      <NIP>${escapeXml(document.buyerNip)}</NIP>
+      <Nazwa>${escapeXml(document.buyerName ?? '')}</Nazwa>
+    </DaneIdentyfikacyjne>
+  </Podmiot2>
+  <Fa>
+    <KodWaluty>${escapeXml(document.currency)}</KodWaluty>
+    <P_1>${issueDate}</P_1>
+    <P_2>${escapeXml(document.invoiceNumber)}</P_2>
+    <P_6>${saleDate}</P_6>${vatSummaryXml}
+    <P_15>${grossAmount}</P_15>
+    <Adnotacje>
+      <P_16>2</P_16>
+      <P_17>2</P_17>
+      <P_18>2</P_18>
+      <P_18A>2</P_18A>
+      <Zwolnienie>
+        <P_19N>1</P_19N>
+      </Zwolnienie>
+      <NoweSrodkiTransportu>
+        <P_22N>1</P_22N>
+      </NoweSrodkiTransportu>
+      <P_23>2</P_23>
+      <PMarzy>
+        <P_PMarzyN>1</P_PMarzyN>
+      </PMarzy>
+    </Adnotacje>
+    <RodzajFaktury>VAT</RodzajFaktury>${lineItemsXml}
+  </Fa>
+</Faktura>`
+}

package/src/modules/integration_ksef_direct/lib/ksefXmlParser.ts

@@ -0,0 +1,97 @@
+export interface ParsedReceivedInvoice {
+  invoiceNumber: string | null
+  sellerNip: string | null
+  sellerName: string | null
+  issueDate: string | null
+  currency: string | null
+  netAmount: string | null
+  vatAmount: string | null
+  grossAmount: string | null
+}
+
+function extractSection(xml: string, tag: string): string | null {
+  const match = xml.match(new RegExp(`<${tag}[\\s\\S]*?>([\\s\\S]*?)<\\/${tag}>`, 'i'))
+  return match ? match[1]! : null
+}
+
+function extractTag(xml: string, tag: string): string | null {
+  const match = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)<\\/${tag}>`, 'i'))
+  return match ? match[1]!.trim() || null : null
+}
+
+function sumTagPattern(xml: string, tagPattern: RegExp): number {
+  let sum = 0
+  for (const match of xml.matchAll(new RegExp(`<(${tagPattern.source})>([^<]*)<\\/\\1>`, 'gi'))) {
+    sum += parseFloat(match[2] ?? '0') || 0
+  }
+  return sum
+}
+
+function parseFa2Xml(xml: string): ParsedReceivedInvoice {
+  const podmiot1 = extractSection(xml, 'Podmiot1')
+  const sellerNip = podmiot1 ? extractTag(podmiot1, 'NIP') : null
+  const sellerName = podmiot1
+    ? (extractTag(podmiot1, 'PelnaNazwa') ?? extractTag(podmiot1, 'Nazwa'))
+    : null
+
+  const fa = extractSection(xml, 'Fa')
+  const issueDate = fa ? extractTag(fa, 'P_1') : null
+  const invoiceNumber = fa ? (extractTag(fa, 'P_2A') ?? extractTag(fa, 'P_2')) : null
+  const currency = fa ? extractTag(fa, 'KodWaluty') : null
+  const grossAmountRaw = fa ? extractTag(fa, 'P_15') : null
+
+  const netAmountNum = fa ? sumTagPattern(fa, /P_13_\d+/) : 0
+  const vatAmountNum = fa ? sumTagPattern(fa, /P_14_\d+/) : 0
+
+  return {
+    invoiceNumber,
+    sellerNip,
+    sellerName,
+    issueDate,
+    currency,
+    netAmount: netAmountNum > 0 ? netAmountNum.toFixed(2) : null,
+    vatAmount: vatAmountNum > 0 ? vatAmountNum.toFixed(2) : null,
+    grossAmount: grossAmountRaw,
+  }
+}
+
+function parseUpoXml(xml: string): ParsedReceivedInvoice {
+  // UPO (Potwierdzenie) format from KSeF — xmlns="http://upo.schematy.mf.gov.pl/KSeF/..."
+  // Contains metadata about an accepted invoice but not full financial data.
+  const dokument = extractSection(xml, 'Dokument')
+  const sellerNip = dokument ? extractTag(dokument, 'NipSprzedawcy') : null
+  const invoiceNumber = dokument ? extractTag(dokument, 'NumerFaktury') : null
+  const issueDate = dokument ? extractTag(dokument, 'DataWystawieniaFaktury') : null
+
+  return {
+    invoiceNumber,
+    sellerNip,
+    sellerName: null,
+    issueDate,
+    currency: null,
+    netAmount: null,
+    vatAmount: null,
+    grossAmount: null,
+  }
+}
+
+export function parseReceivedInvoiceXml(xml: string): ParsedReceivedInvoice {
+  try {
+    // Detect UPO format by namespace
+    if (xml.includes('upo.schematy.mf.gov.pl') || xml.includes('<Potwierdzenie')) {
+      return parseUpoXml(xml)
+    }
+    return parseFa2Xml(xml)
+  } catch {
+    return {
+      invoiceNumber: null,
+      sellerNip: null,
+      sellerName: null,
+      issueDate: null,
+      currency: null,
+      netAmount: null,
+      vatAmount: null,
+      grossAmount: null,
+    }
+  }
+}