@dwast/verifactu-lib 0.1.0-beta.6 → 0.1.0-beta.8

package/src/integration/validate.ts

@@ -0,0 +1,171 @@
+import { VerifactuClient, type VerifactuEnv } from '../aeat/client.js';
+import { readP12, decodeCertificate, extractCertificateInfo, type DecodedCertificate } from './p12.js';
+import { computeRegistroAlta } from '../core/hash/chain.js';
+import { generateInvoiceXml, generateSuministroXml, buildCabecera } from '../core/xml/generator.js';
+import { nowIsoWithOffset } from '../core/utils/date.js';
+import type { Invoice } from '../core/models/invoice.js';
+
+/**
+ * Respuesta de AEAT a la factura de prueba de validación.
+ */
+export interface AeatValidationResponse {
+  /** Estado devuelto por AEAT (`OK` | `ERROR`). */
+  status: string;
+  /** Mensaje de AEAT. */
+  message?: string;
+  /** CSV de la factura de prueba (si AEAT la aceptó). */
+  csv?: string;
+  /** Identificador de la operación. */
+  operationId?: string;
+}
+
+/**
+ * Resultado de la validación de un `.p12` contra AEAT.
+ */
+export interface P12ValidationResult {
+  /** `true` si AEAT aceptó la factura de prueba con este certificado. */
+  valid: boolean;
+  /** Campos decodificados del certificado (para mostrar/validar la pass). */
+  certificate?: DecodedCertificate;
+  /** Respuesta de AEAT a la factura de prueba. */
+  aeat?: AeatValidationResponse;
+  /** Mensaje informativo. */
+  message?: string;
+  /** Descripción del error cuando la validación falla. */
+  error?: string;
+}
+
+export interface ValidateP12Options {
+  /** Entorno contra el que validar. Por defecto `test` (desarrollo). */
+  env?: VerifactuEnv;
+  /** Timeout de la petición en ms. */
+  timeoutMs?: number;
+}
+
+/** Convierte una fecha a `DD-MM-YYYY` (formato XSD `fecha` de AEAT). */
+function toDdMmYyyy(d: Date): string {
+  const dd = String(d.getDate()).padStart(2, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  return `${dd}-${mm}-${d.getFullYear()}`;
+}
+
+/**
+ * Valida un `.p12`/`.pfx` contra el entorno de AEAT indicado (por defecto el
+ * de **pruebas/desarrollo**).
+ *
+ * Pasos:
+ * 1. Lee el `.p12` y extrae certificado + clave privada (valida la contraseña).
+ * 2. Decodifica los campos del certificado (NIF, nombre, validez, emisor...).
+ * 3. Construye un `VerifactuClient` con mTLS y **emite una factura de prueba**
+ *    en el entorno indicado. Si AEAT la acepta, el certificado es válido.
+ *
+ * Devuelve los campos decodificados (para mostrar) y la respuesta de AEAT.
+ *
+ * @param buffer   Contenido del `.p12`/`.pfx`.
+ * @param password Contraseña del `.p12`.
+ * @param options  Entorno y timeout.
+ */
+export async function validateP12AgainstAEAT(
+  buffer: Buffer,
+  password: string,
+  options: ValidateP12Options = {},
+): Promise<P12ValidationResult> {
+  const env = options.env ?? 'test';
+
+  let content;
+  try {
+    content = readP12(buffer, password);
+  } catch (e) {
+    return { valid: false, error: `No se pudo leer el .p12: ${(e as Error).message}` };
+  }
+
+  const cert = content.certificates[0];
+  const key = content.keys[0];
+  if (!cert || !key) {
+    return { valid: false, error: 'El .p12 no contiene certificado y clave privada.' };
+  }
+
+  const certificate = decodeCertificate(cert);
+  // El emisor de la factura es el OBLIGADO (representado). Si el certificado es
+  // de un representante, el NIF del obligado está en `representedNif`.
+  const obligadoNif = certificate.representedNif ?? certificate.nif ?? '';
+  const nombreRazon = certificate.nombreRazon ?? '';
+
+  const client = new VerifactuClient({
+    env,
+    cert,
+    key,
+    timeoutMs: options.timeoutMs ?? 15_000,
+  });
+
+  // Factura de prueba mínima para validar el certificado end-to-end.
+  const now = new Date();
+  const numeroInstalacion = `VAL${Date.now()}`;
+  const invoice: Invoice = {
+    id: { serie: 'T', numero: `VAL${Date.now()}`, fechaExpedicion: toDdMmYyyy(now) },
+    emisor: { nif: obligadoNif, nombreRazon },
+    tipoFactura: 'F1',
+    tipoDesglose: 'S1',
+    descripcion: 'Factura de prueba de validación de certificado',
+    destinatarios: [{ nombreRazon, nif: obligadoNif }],
+    desglose: {
+      detalles: [
+        { calificacionOperacion: 'S1', claveRegimen: '01', tipoImpositivo: 21, baseImponible: 1, cuotaRepercutida: 0.21 },
+      ],
+      cuotaTotal: 0.21,
+      importeTotal: 1.21,
+    },
+    sistemaInformatico: {
+      nombreRazon,
+      nif: obligadoNif,
+      nombreSistemaInformatico: 'VALIDACION',
+      idSistemaInformatico: '01',
+      version: '1.0',
+      numeroInstalacion,
+    },
+    fechaHoraHusoGenRegistro: nowIsoWithOffset(),
+    huella: '',
+  };
+
+  try {
+    // El hash se calcula sobre el MISMO `fechaHoraHusoGenRegistro` que va en el
+    // XML (si no, la huella no coincide con el contenido y AEAT lo rechaza).
+    const hash = computeRegistroAlta({
+      idEmisorFactura: obligadoNif,
+      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: null,
+      fechaHoraHusoGenRegistro: invoice.fechaHoraHusoGenRegistro,
+    });
+    invoice.huella = hash;
+
+    const registroAltaXml = generateInvoiceXml(invoice, null);
+    const cabecera = buildCabecera({ nombreRazon, nif: obligadoNif }, cert, extractCertificateInfo);
+    const xml = generateSuministroXml(registroAltaXml, cabecera);
+    const result = await client.sendRecord(xml);
+
+    return {
+      valid: result.status === 'OK',
+      certificate,
+      aeat: {
+        status: result.status,
+        message: result.message,
+        csv: result.registro?.csv,
+        operationId: result.operationId,
+      },
+      message:
+        result.status === 'OK'
+          ? `Certificado aceptado por AEAT (${env}). Factura de prueba enviada.`
+          : `AEAT respondió con error: ${result.message ?? result.errorCode ?? ''}`,
+    };
+  } catch (e) {
+    return {
+      valid: false,
+      certificate,
+      error: `AEAT rechazó el certificado: ${(e as Error).message}`,
+    };
+  }
+}