@dwast/verifactu-lib 0.1.0-beta.1 → 0.1.0-beta.3

package/src/integration/p12.ts

@@ -0,0 +1,155 @@
+import forge from 'node-forge';
+
+/**
+ * Un campo (bag) del `.p12`.
+ */
+export interface P12Bag {
+  /** Tipo del bag (certBag, keyBag, pkcs8ShroudedKeyBag, ...). */
+  type: string;
+  /** Contenido en formato PEM (si es un certificado o clave). */
+  pem?: string;
+  /** Valor en bruto (si no es PEM). */
+  value?: unknown;
+}
+
+/**
+ * Contenido completo de un `.p12`, con todos sus campos.
+ */
+export interface P12Content {
+  /** Todos los bags encontrados, en orden. */
+  bags: P12Bag[];
+  /** Certificados en PEM (conveniencia). */
+  certificates: string[];
+  /** Claves privadas en PEM (conveniencia). */
+  keys: string[];
+}
+
+/**
+ * Lee un certificado `.p12`/`.pfx` e itera todos sus campos (bags),
+ * devolviéndolos todos. La librería no interpreta qué campo es cada cosa:
+ * simplemente expone el contenido para que la aplicación lo use.
+ *
+ * @param buffer   Contenido del archivo `.p12`/`.pfx`.
+ * @param password Contraseña del `.p12`.
+ */
+export function readP12(buffer: Buffer, password: string): P12Content {
+  const asn1 = forge.asn1.fromDer(forge.util.createBuffer(new Uint8Array(buffer)));
+  const p12 = forge.pkcs12.pkcs12FromAsn1(asn1, password);
+
+  const bags: P12Bag[] = [];
+  const certificates: string[] = [];
+  const keys: string[] = [];
+
+  p12.safeContents.forEach((safe) => {
+    safe.safeBags.forEach((bag) => {
+      const type = bag.type ?? 'unknown';
+      let pem: string | undefined;
+      let value: unknown;
+
+      if (bag.cert) {
+        pem = forge.pki.certificateToPem(bag.cert);
+        certificates.push(pem);
+      } else if (bag.key) {
+        pem = forge.pki.privateKeyToPem(bag.key);
+        keys.push(pem);
+      } else {
+        value = bag.attributes;
+      }
+
+      bags.push({ type, pem, value });
+    });
+  });
+
+  return { bags, certificates, keys };
+}
+
+/**
+ * Extrae el NIF de un certificado en PEM.
+ *
+ * El NIF suele aparecer en el `serialNumber` (p. ej. `IDCES-74654958V`) o como
+ * primer token del `commonName` (p. ej. `74654958V ANTONIO JOSE RECHE`).
+ * Devuelve `null` si no se puede determinar.
+ */
+export function extractNifFromCertificate(pem: string): string | null {
+  try {
+    const cert = forge.pki.certificateFromPem(pem);
+    const attrs = cert.subject.attributes;
+
+    // serialNumber: "IDCES-74654958V" o directamente "B12345678"
+    const serial = attrs.find((a) => a.name === 'serialNumber')?.value;
+    if (serial) {
+      const m = String(serial).match(/IDCES-(\S+)/i) ?? String(serial).match(/^([A-Z0-9]{8,9})/i);
+      if (m && m[1]) return m[1];
+    }
+
+    // commonName: "74654958V ANTONIO JOSE RECHE (R: B18579458)"
+    const cn = attrs.find((a) => a.name === 'commonName')?.value;
+    if (cn) {
+      const m = String(cn).match(/^([A-Z0-9]{8,9})/i);
+      if (m && m[1]) return m[1];
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Información de un certificado en PEM: NIF y nombre/razón del titular.
+ */
+export interface CertificateInfo {
+  /** NIF del titular del certificado. */
+  nif: string;
+  /** Nombre o razón social del titular. */
+  nombreRazon: string;
+}
+
+/**
+ * Extrae el NIF y el nombre/razón del titular de un certificado en PEM.
+ *
+ * El NIF se obtiene del `serialNumber` (p. ej. `IDCES-74654958V`) o del primer
+ * token del `commonName`. El nombre se compone de `givenName` + `surname`, o
+ * del `commonName` sin el prefijo de NIF. Devuelve `null` si no se puede
+ * determinar el NIF.
+ */
+export function extractCertificateInfo(pem: string): CertificateInfo | null {
+  try {
+    const cert = forge.pki.certificateFromPem(pem);
+    const attrs = cert.subject.attributes;
+
+    // NIF
+    const serial = attrs.find((a) => a.name === 'serialNumber')?.value;
+    let nif: string | null = null;
+    if (serial) {
+      const m = String(serial).match(/IDCES-(\S+)/i) ?? String(serial).match(/^([A-Z0-9]{8,9})/i);
+      if (m && m[1]) nif = m[1];
+    }
+    if (!nif) {
+      const cn = attrs.find((a) => a.name === 'commonName')?.value;
+      if (cn) {
+        const m = String(cn).match(/^([A-Z0-9]{8,9})/i);
+        if (m && m[1]) nif = m[1];
+      }
+    }
+    if (!nif) return null;
+
+    // Nombre: givenName + surname, o commonName sin el NIF.
+    const given = attrs.find((a) => a.name === 'givenName')?.value;
+    const surname = attrs.find((a) => a.name === 'surname')?.value;
+    let nombreRazon = '';
+    if (given) nombreRazon += given;
+    if (surname) nombreRazon += (nombreRazon ? ' ' : '') + surname;
+    nombreRazon = nombreRazon.trim();
+    if (!nombreRazon) {
+      const cn = attrs.find((a) => a.name === 'commonName')?.value;
+      if (cn) {
+        nombreRazon = String(cn!).replace(/^[A-Z0-9]{8,9}\s*/, '').split(' (R:')[0]?.trim() ?? '';
+      }
+    }
+
+    return { nif, nombreRazon };
+  } catch {
+    return null;
+  }
+}

package/src/integration/repository.ts

@@ -1,5 +1,4 @@
 import type { Invoice } from '../core/models/invoice.js';
-import type { Event } from '../core/models/event.js';
 
 /**
  * Estado de un registro de facturación en el sistema consumidor.
@@ -19,6 +18,8 @@ export interface StoredRecord {
   id: string;
   /** Referencia a la factura (serie + número). */
   invoiceId: string;
+  /** NIF del emisor de la factura. */
+  emisorNif: string;
   /** XML Verifactu generado. */
   xml: string;
   /** Hash del propio registro (huella). */
@@ -27,6 +28,8 @@ export interface StoredRecord {
   previousHash: string | null;
   /** Payload del QR Verifactu (URL de verificación con el hash). */
   qrPayload?: string;
+  /** `true` si la huella devuelta por AEAT coincide con la calculada. */
+  hashVerified?: boolean;
   /** Estado del registro. */
   status: RecordStatus;
   /** Fecha/hora de creación. */
@@ -81,6 +84,4 @@ export interface VerifactuRepository {
   saveResponse(response: StoredResponse): Promise<void>;
   /** Obtiene las respuestas de un registro. */
   getResponses(recordId: string): Promise<StoredResponse[]>;
-  /** Guarda un evento. */
-  saveEvent(event: Event): Promise<void>;
 }

package/src/integration/schema.sql

@@ -32,20 +32,6 @@ CREATE TABLE IF NOT EXISTS verifactu_responses (
     received_at   TIMESTAMP   NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
--- Eventos (alta, anulación, modificación, eventos del sistema)
-CREATE TABLE IF NOT EXISTS verifactu_events (
-    id            VARCHAR(64)  PRIMARY KEY,
-    type          VARCHAR(16)  NOT NULL,           -- ALTA | ANULACION | MODIFICACION
-    fecha_hora    TIMESTAMP    NOT NULL,
-    invoice_id    VARCHAR(128),
-    motivo        TEXT,
-    factura_anulada VARCHAR(128),
-    hash          VARCHAR(64),
-    previous_hash VARCHAR(64),
-    created_at    TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
 -- Índices recomendados
 CREATE INDEX IF NOT EXISTS idx_records_invoice   ON verifactu_records (invoice_id);
 CREATE INDEX IF NOT EXISTS idx_responses_record  ON verifactu_responses (record_id);
-CREATE INDEX IF NOT EXISTS idx_events_invoice    ON verifactu_events (invoice_id);

package/src/integration/service.ts

@@ -1,10 +1,19 @@
 import type { Invoice } from '../core/models/invoice.js';
-import { generateInvoiceXml, generateAnulacionXml } from '../core/xml/generator.js';
-import { computeRegistroAlta, computeRegistroAnulacion } from '../core/hash/chain.js';
+import { generateInvoiceXml, generateSuministroXml, buildCabecera, generateAnulacionXml, generateEventoXml, type EventoInput } from '../core/xml/generator.js';
+import { computeRegistroAlta, computeRegistroAnulacion, computeRegistroEvento, verifyRegistroAlta } from '../core/hash/chain.js';
 import { buildQrPayload } from '../core/qr/qr.js';
+import { nowIsoWithOffset } from '../core/utils/date.js';
+import { validateInvoice } from '../core/validation/validate.js';
+import { extractCertificateInfo } from './p12.js';
 import type { VerifactuClient } from '../aeat/client.js';
 import type { VerifactuRepository, StoredRecord } from './repository.js';
 
+/** Convierte `YYYY-MM-DD` a `DD-MM-YYYY` (formato XSD `fecha` de AEAT). */
+function toDdMmYyyy(iso: string): string {
+  const [y, m, d] = iso.split('-');
+  return `${d}-${m}-${y}`;
+}
+
 /**
  * Servicio de orquestación de Verifactu.
  *
@@ -16,6 +25,7 @@ export class VerifactuService {
   constructor(
     private readonly repository: VerifactuRepository,
     private readonly client: VerifactuClient,
+    private readonly certificatePem?: string,
   ) {}
 
   /**
@@ -23,12 +33,25 @@ export class VerifactuService {
    * el registro y lo envía a AEAT, persistiendo la respuesta.
    */
   async registerInvoice(invoice: Invoice): Promise<StoredRecord> {
+    // 0. Validar la factura antes de generar el XML.
+    const validation = validateInvoice(invoice);
+    if (!validation.valid) {
+      throw new Error(`Factura inválida: ${validation.errors.join('; ')}`);
+    }
+
     // 1. Obtener el hash del último registro para encadenar.
     const last = await this.repository.getLastRecord();
     const previousHash = last?.hash ?? null;
 
     // 2. Generar XML y calcular la huella (hash) del registro.
-    const xml = generateInvoiceXml(invoice, previousHash);
+    const registroAltaXml = generateInvoiceXml(invoice, previousHash);
+    const cabecera = buildCabecera(
+      { nombreRazon: invoice.emisor.nombreRazon, nif: invoice.emisor.nif },
+      this.certificatePem,
+      extractCertificateInfo,
+    );
+    const xml = generateSuministroXml(registroAltaXml, cabecera);
+    const fechaHoraHusoGenRegistro = nowIsoWithOffset();
     const hash = computeRegistroAlta({
       idEmisorFactura: invoice.emisor.nif,
       numSerieFactura: `${invoice.id.serie ?? ''}${invoice.id.numero}`,
@@ -37,7 +60,7 @@ export class VerifactuService {
       cuotaTotal: invoice.desglose.cuotaTotal.toFixed(2),
       importeTotal: invoice.desglose.importeTotal.toFixed(2),
       huellaAnterior: previousHash,
-      fechaHoraHusoGenRegistro: new Date().toISOString(),
+      fechaHoraHusoGenRegistro,
     });
 
     // 3. Persistir el registro como PENDING.
@@ -45,6 +68,7 @@ export class VerifactuService {
     const record: StoredRecord = {
       id: `${invoice.id.serie ?? ''}${invoice.id.numero}`,
       invoiceId: `${invoice.id.serie ?? ''}${invoice.id.numero}`,
+      emisorNif: invoice.emisor.nif,
       xml,
       hash,
       previousHash,
@@ -66,11 +90,30 @@ export class VerifactuService {
       receivedAt: new Date().toISOString(),
     });
 
-    // 5. Actualizar el estado del registro según la respuesta.
+    // 5. Verificar la huella devuelta por AEAT (integridad del registro).
+    const aeatHash = result.registro?.huella;
+    const hashVerified =
+      result.status === 'OK' && aeatHash !== undefined
+        ? verifyRegistroAlta(
+            {
+              idEmisorFactura: invoice.emisor.nif,
+              numSerieFactura: `${invoice.id.serie ?? ''}${invoice.id.numero}`,
+              fechaExpedicionFactura: invoice.id.fechaExpedicion,
+              tipoFactura: invoice.tipoFactura,
+              cuotaTotal: invoice.desglose.cuotaTotal.toFixed(2),
+              importeTotal: invoice.desglose.importeTotal.toFixed(2),
+              huellaAnterior: previousHash,
+              fechaHoraHusoGenRegistro,
+            },
+            aeatHash,
+          )
+        : undefined;
+
+    // 6. Actualizar el estado del registro según la respuesta.
     const status = result.status === 'OK' ? 'CONFIRMED' : 'REJECTED';
     await this.repository.updateRecordStatus(record.id, status);
 
-    return { ...record, status };
+    return { ...record, status, hashVerified };
   }
 
   /**
@@ -79,7 +122,7 @@ export class VerifactuService {
    * Genera un registro de anulación que referencia la factura anulada,
    * lo envía a AEAT y marca la factura original como ANNULLED.
    */
-  async annulInvoice(invoiceId: string): Promise<StoredRecord> {
+  async annulInvoice(invoiceId: string, invoice?: Invoice): Promise<StoredRecord> {
     // 1. Obtener la factura original (para su huella) y el último registro.
     const original = await this.repository.getRecord(invoiceId);
     if (!original) {
@@ -87,30 +130,46 @@ export class VerifactuService {
     }
     const last = await this.repository.getLastRecord();
     const previousHash = last?.hash ?? null;
+    const fechaHoraHusoGenRegistro = nowIsoWithOffset();
+    const fechaExpedicionFacturaAnulada = toDdMmYyyy(
+      invoice?.id.fechaExpedicion ?? new Date().toISOString().slice(0, 10),
+    );
+    const sistemaInformatico = invoice?.sistemaInformatico ?? {
+      nombreRazon: 'Sistema',
+      nif: original.emisorNif,
+      nombreSistemaInformatico: 'SIF',
+      idSistemaInformatico: '01',
+      version: '1.0',
+      numeroInstalacion: '1',
+    };
 
     // 2. Generar XML de anulación y calcular la huella.
+    const hash = computeRegistroAnulacion({
+      idEmisorFacturaAnulada: original.emisorNif,
+      numSerieFacturaAnulada: original.invoiceId,
+      fechaExpedicionFacturaAnulada,
+      huellaAnterior: previousHash,
+      fechaHoraHusoGenRegistro,
+    });
     const xml = generateAnulacionXml(
       {
-        idEmisorFacturaAnulada: original.invoiceId,
+        idEmisorFacturaAnulada: original.emisorNif,
         numSerieFacturaAnulada: original.invoiceId,
-        fechaExpedicionFacturaAnulada: new Date().toISOString().slice(0, 10),
+        fechaExpedicionFacturaAnulada,
         huellaFacturaAnulada: original.hash,
+        sistemaInformatico,
+        fechaHoraHusoGenRegistro,
+        huella: hash,
       },
       previousHash,
     );
-    const hash = computeRegistroAnulacion({
-      idEmisorFacturaAnulada: original.invoiceId,
-      numSerieFacturaAnulada: original.invoiceId,
-      fechaExpedicionFacturaAnulada: new Date().toISOString().slice(0, 10),
-      huellaAnterior: previousHash,
-      fechaHoraHusoGenRegistro: new Date().toISOString(),
-    });
 
     // 3. Persistir el registro de anulación como PENDING.
     const now = new Date().toISOString();
     const record: StoredRecord = {
       id: `${invoiceId}-ANUL`,
       invoiceId,
+      emisorNif: original.emisorNif,
       xml,
       hash,
       previousHash,
@@ -155,4 +214,63 @@ export class VerifactuService {
     // 2. Emitir la factura corregida como un nuevo alta.
     return this.registerInvoice(correctedInvoice);
   }
+
+  /**
+   * Registra un evento (RegistroEvento) ante AEAT.
+   *
+   * Genera el XML del evento, calcula su huella encadenada con el último
+   * registro, persiste el evento y lo envía a AEAT.
+   */
+  async registerEvent(evento: EventoInput): Promise<StoredRecord> {
+    // 1. Obtener el hash del último registro para encadenar.
+    const last = await this.repository.getLastRecord();
+    const previousHash = last?.hash ?? null;
+
+    // 2. Generar XML y calcular la huella del evento.
+    const si = evento.sistemaInformatico;
+    const hash = computeRegistroEvento({
+      nifSistemaInformatico: si.nif,
+      id: '',
+      idSistemaInformatico: si.idSistemaInformatico,
+      version: si.version,
+      numeroInstalacion: si.numeroInstalacion,
+      nifObligado: evento.obligadoEmision.nif,
+      tipoEvento: evento.tipoEvento,
+      huellaAnterior: previousHash,
+      fechaHoraHusoGenEvento: evento.fechaHoraHusoGenEvento,
+    });
+    const xml = generateEventoXml({ ...evento, huellaEvento: hash });
+
+    // 3. Persistir el evento.
+    const now = new Date().toISOString();
+    const record: StoredRecord = {
+      id: `EV-${evento.tipoEvento}-${Date.now()}`,
+      invoiceId: evento.obligadoEmision.nif,
+      emisorNif: evento.obligadoEmision.nif,
+      xml,
+      hash,
+      previousHash,
+      status: 'PENDING',
+      createdAt: now,
+      updatedAt: now,
+    };
+    await this.repository.saveRecord(record);
+
+    // 4. Enviar a AEAT y persistir la respuesta.
+    const result = await this.client.sendRecord(xml);
+    await this.repository.saveResponse({
+      id: `${record.id}-${Date.now()}`,
+      recordId: record.id,
+      operationId: result.operationId,
+      status: result.status,
+      message: result.message,
+      receivedAt: new Date().toISOString(),
+    });
+
+    // 5. Actualizar el estado.
+    const status = result.status === 'OK' ? 'CONFIRMED' : 'REJECTED';
+    await this.repository.updateRecordStatus(record.id, status);
+
+    return { ...record, status };
+  }
 }

package/src/core/models/event.ts

@@ -1,25 +0,0 @@
-/**
- * Tipos de evento de registro Verifactu.
- * - ALTA: alta de una factura.
- * - ANULACION: anulación de una factura previamente registrada.
- * - MODIFICACION: modificación de una factura.
- */
-export type EventType = 'ALTA' | 'ANULACION' | 'MODIFICACION';
-
-/**
- * Evento de registro Verifactu.
- */
-export interface Event {
-  /** Tipo de evento. */
-  type: EventType;
-  /** Fecha/hora del evento en formato ISO 8601. */
-  fechaHora: string;
-  /** Referencia a la factura asociada. */
-  invoiceId: string;
-  /** Motivo de anulación (obligatorio si type === 'ANULACION'). */
-  motivoAnulacion?: string;
-  /** Referencia a la factura que se anula (para ANULACION). */
-  facturaAnulada?: string;
-  /** Metadatos adicionales. */
-  metadata?: Record<string, unknown>;
-}