ghinfe 0.6.0

package/src/utils/chave.utils.js

@@ -0,0 +1,117 @@
+import { UF_IBGE } from '../constants/sefaz.js';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Gera código numérico aleatório de 8 dígitos (cNF).
+ * @returns {string}
+ */
+export function gerarCodigoNumerico() {
+  const valor = Math.floor(Math.random() * 99_999_999) + 1;
+  return String(valor).padStart(8, '0');
+}
+
+/**
+ * Calcula dígito verificador da chave NF-e (módulo 11).
+ * @param {string} chave43 Primeiros 43 dígitos da chave (sem DV)
+ * @returns {string} Dígito verificador (0-9)
+ */
+export function calcularDigitoVerificador(chave43) {
+  if (!/^\d{43}$/.test(chave43)) {
+    throw new GhinfeError('Chave deve conter exatamente 43 dígitos para cálculo do DV', 'CHAVE_INVALID_LENGTH');
+  }
+
+  const pesos = [2, 3, 4, 5, 6, 7, 8, 9];
+  let soma = 0;
+  let pesoIndex = 0;
+
+  for (let i = chave43.length - 1; i >= 0; i--) {
+    soma += parseInt(chave43[i], 10) * pesos[pesoIndex];
+    pesoIndex = (pesoIndex + 1) % pesos.length;
+  }
+
+  const resto = soma % 11;
+  return String(resto < 2 ? 0 : 11 - resto);
+}
+
+/**
+ * Valida se a chave de acesso possui DV correto.
+ * @param {string} chaveAcesso 44 dígitos
+ * @returns {boolean}
+ */
+export function validarChaveAcesso(chaveAcesso) {
+  const chave = chaveAcesso.replace(/\D/g, '');
+  if (chave.length !== 44) return false;
+  const dvCalculado = calcularDigitoVerificador(chave.substring(0, 43));
+  return dvCalculado === chave[43];
+}
+
+/**
+ * Gera chave de acesso NF-e/NFC-e (44 dígitos) conforme layout SEFAZ.
+ *
+ * Composição: cUF(2) + AAMM(4) + CNPJ(14) + mod(2) + serie(3) + nNF(9) + tpEmis(1) + cNF(8) + cDV(1)
+ *
+ * @param {{
+ *   uf: string,
+ *   cnpj: string,
+ *   modelo?: string|number,
+ *   serie: number,
+ *   numero: number,
+ *   tipoEmissao?: number,
+ *   codigoNumerico?: string,
+ *   dataEmissao?: Date,
+ * }} params
+ * @returns {string}
+ */
+export function gerarChaveAcesso(params) {
+  const uf = params.uf?.toUpperCase();
+  const cUF = UF_IBGE[uf];
+
+  if (!cUF) {
+    throw new GhinfeError(`UF inválida: ${params.uf}`, 'UF_INVALIDA');
+  }
+
+  const data = params.dataEmissao ?? new Date();
+  const ano = String(data.getFullYear()).slice(-2);
+  const mes = String(data.getMonth() + 1).padStart(2, '0');
+  const aamm = `${ano}${mes}`;
+
+  const cnpj = params.cnpj.replace(/\D/g, '');
+  if (cnpj.length !== 14) {
+    throw new GhinfeError('CNPJ deve conter 14 dígitos', 'CNPJ_INVALIDO');
+  }
+
+  const modelo = String(params.modelo ?? '55').padStart(2, '0');
+  const serie = String(params.serie).padStart(3, '0');
+  const numero = String(params.numero).padStart(9, '0');
+  const tpEmis = String(params.tipoEmissao ?? 1);
+  const cNF = (params.codigoNumerico ?? gerarCodigoNumerico()).padStart(8, '0');
+
+  const chave43 = `${cUF}${aamm}${cnpj}${modelo}${serie}${numero}${tpEmis}${cNF}`;
+  const cDV = calcularDigitoVerificador(chave43);
+
+  return chave43 + cDV;
+}
+
+/**
+ * Extrai campos da chave de acesso para conferência.
+ * @param {string} chaveAcesso
+ */
+export function parseChaveAcesso(chaveAcesso) {
+  const chave = chaveAcesso.replace(/\D/g, '');
+  if (chave.length !== 44) {
+    throw new GhinfeError('Chave de acesso deve ter 44 dígitos', 'CHAVE_INVALID_LENGTH');
+  }
+
+  return {
+    cUF: chave.substring(0, 2),
+    aamm: chave.substring(2, 6),
+    cnpj: chave.substring(6, 20),
+    modelo: chave.substring(20, 22),
+    serie: parseInt(chave.substring(22, 25), 10),
+    numero: parseInt(chave.substring(25, 34), 10),
+    tipoEmissao: parseInt(chave[34], 10),
+    codigoNumerico: chave.substring(35, 43),
+    digitoVerificador: chave[43],
+    valida: validarChaveAcesso(chave),
+  };
+}

package/src/utils/date.utils.js

@@ -0,0 +1,26 @@
+/**
+ * Formata data para padrão SEFAZ: AAAA-MM-DDTHH:mm:ss-03:00
+ * @param {Date} [date]
+ * @returns {string}
+ */
+export function formatSefazDateTime(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const offset = -date.getTimezoneOffset();
+  const sign = offset >= 0 ? '+' : '-';
+  const abs = Math.abs(offset);
+  const tz = `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+
+  return (
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+    `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${tz}`
+  );
+}
+
+/**
+ * @param {Date} [date]
+ * @returns {string} AAAA-MM-DD
+ */
+export function formatSefazDate(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}

package/src/utils/xml.utils.js

@@ -0,0 +1,44 @@
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
+
+/**
+ * @param {string} xml
+ * @returns {string}
+ */
+export function minifyXml(xml) {
+  return xml.replace(/>\s+</g, '><').trim();
+}
+
+/**
+ * @param {string} xml
+ * @returns {Document}
+ */
+export function parseXml(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, 'text/xml');
+  const parseError = doc.getElementsByTagName('parsererror')[0];
+  if (parseError) {
+    throw new Error(`XML inválido: ${parseError.textContent}`);
+  }
+  return doc;
+}
+
+/**
+ * @param {Document|Element} node
+ * @returns {string}
+ */
+export function serializeXml(node) {
+  return new XMLSerializer().serializeToString(node);
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/src/validation/XsdValidator.js

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import path from 'path';
+import libxmljs from 'libxmljs2';
+import { pathToFileURL } from 'url';
+import { XsdValidationError } from '../errors/XsdValidationError.js';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+const schemaCache = new Map();
+
+/**
+ * Validador XSD genérico usando libxmljs2 e schemas oficiais SEFAZ.
+ */
+export class XsdValidator {
+  /**
+   * @param {string} xsdPath Caminho absoluto do arquivo .xsd
+   */
+  static loadSchema(xsdPath) {
+    if (schemaCache.has(xsdPath)) {
+      return schemaCache.get(xsdPath);
+    }
+
+    if (!fs.existsSync(xsdPath)) {
+      throw new GhinfeError(
+        `Schema XSD não encontrado: ${xsdPath}. Execute: node scripts/download-schemas.js`,
+        'XSD_SCHEMA_NOT_FOUND'
+      );
+    }
+
+    const dir = path.dirname(xsdPath);
+    const baseUrl = pathToFileURL(dir + path.sep).href;
+    const content = fs.readFileSync(xsdPath, 'utf8');
+    const schema = libxmljs.parseXml(content, { baseUrl });
+
+    schemaCache.set(xsdPath, schema);
+    return schema;
+  }
+
+  /**
+   * Valida XML contra schema XSD.
+   * @param {string} xml
+   * @param {string} xsdPath
+   * @param {{ injetarAssinaturaStub?: boolean, modelo?: '55'|'65' }} [options]
+   * @returns {{ valido: true, avisos: string[] }}
+   */
+  static validar(xml, xsdPath, options = {}) {
+    let xmlParaValidar = xml;
+
+    if (options.injetarAssinaturaStub) {
+      xmlParaValidar = this.#prepararXmlEstrutural(xml, options.modelo ?? '55');
+    }
+
+    const schema = this.loadSchema(xsdPath);
+    const doc = libxmljs.parseXml(xmlParaValidar);
+
+    const valido = doc.validate(schema);
+    if (valido) {
+      return { valido: true, avisos: [] };
+    }
+
+    const erros = doc.validationErrors.map((e) => e.message).filter(Boolean);
+    throw new XsdValidationError(erros, path.basename(xsdPath));
+  }
+
+  /**
+   * Valida e retorna boolean (sem lançar exceção).
+   * @param {string} xml
+   * @param {string} xsdPath
+   * @param {object} [options]
+   */
+  static tentarValidar(xml, xsdPath, options = {}) {
+    try {
+      return this.validar(xml, xsdPath, options);
+    } catch (error) {
+      if (error instanceof XsdValidationError) {
+        return { valido: false, erros: error.erros };
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Injeta elementos exigidos pelo XSD para validação estrutural pré-assinatura.
+   * O schema exige Signature (NF-e) ou infNFeSupl + Signature (NFC-e).
+   * @param {string} xml
+   * @param {'55'|'65'} modelo
+   */
+  static #prepararXmlEstrutural(xml, modelo) {
+    if (xml.includes('</Signature>')) return xml;
+
+    const idMatch = xml.match(/Id="(NFe\d{44})"/);
+    const id = idMatch?.[1];
+    if (!id) return xml;
+
+    let complemento = '';
+
+    if (modelo === '65' && !xml.includes('infNFeSupl')) {
+      const qrStub = 'https://nfce.sefaz.example/qr?p=STUB';
+      complemento += `<infNFeSupl><qrCode><![CDATA[${qrStub}]]></qrCode><urlChave>${qrStub}</urlChave></infNFeSupl>`;
+    }
+
+    complemento += this.#assinaturaStub(id);
+    return xml.replace('</NFe>', `${complemento}</NFe>`);
+  }
+
+  /** @param {string} id */
+  static #assinaturaStub(id) {
+    return `<Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/><SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/><Reference URI="#${id}"><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><DigestValue>WCF0TVY=</DigestValue></Reference></SignedInfo><SignatureValue>WCF0TVY=</SignatureValue><KeyInfo><X509Data><X509Certificate>WCF0TVY=</X509Certificate></X509Data></KeyInfo></Signature>`;
+  }
+
+  /** Limpa cache de schemas (útil em testes). */
+  static limparCache() {
+    schemaCache.clear();
+  }
+}

package/src/validation/schemas.js

@@ -0,0 +1,14 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCHEMAS_ROOT = path.resolve(__dirname, '../../schemas');
+
+/** Caminhos dos schemas XSD oficiais (PL_009_V4 — NF-e/NFC-e 4.00). */
+export const XSD_SCHEMAS = {
+  NFE: path.join(SCHEMAS_ROOT, 'nfe/PL_009_V4/nfe_v4.00.xsd'),
+  ENVI_NFE: path.join(SCHEMAS_ROOT, 'nfe/PL_009_V4/enviNFe_v4.00.xsd'),
+  EVENTO: path.join(SCHEMAS_ROOT, 'nfe/PL_009_V4/leiauteNFe_v4.00.xsd'),
+};
+
+export const SCHEMAS_ROOT_PATH = SCHEMAS_ROOT;