ghinfe 0.6.0

package/schemas/nfe/PL_009_V4/xmldsig-core-schema_v1.01.xsd

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- ***************************************************-->
+<!-- ***   Schema específico para assinaturas XML    ***-->
+<!-- *** a partir de certificados do padrão (X509)   ***-->
+<!-- *** ICP-Brasil - Projeto Nota Fiscal Eletrônica ***-->
+<!-- ***************************************************-->
+<!-- Schema for XML Signatures-->
+<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" targetNamespace="http://www.w3.org/2000/09/xmldsig#" elementFormDefault="qualified" attributeFormDefault="unqualified" version="0.1">
+	<element name="Signature" type="ds:SignatureType"/>
+	<complexType name="SignatureType">
+		<sequence>
+			<element name="SignedInfo" type="ds:SignedInfoType"/>
+			<element name="SignatureValue" type="ds:SignatureValueType"/>
+			<element name="KeyInfo" type="ds:KeyInfoType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="SignatureValueType">
+		<simpleContent>
+			<extension base="base64Binary">
+				<attribute name="Id" type="ID" use="optional"/>
+			</extension>
+		</simpleContent>
+	</complexType>
+	<complexType name="SignedInfoType">
+		<sequence>
+			<element name="CanonicalizationMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+				</complexType>
+			</element>
+			<element name="SignatureMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
+				</complexType>
+			</element>
+			<element name="Reference" type="ds:ReferenceType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="ReferenceType">
+		<sequence>
+			<element name="Transforms" type="ds:TransformsType">
+				<!-- Garante a unicidade do atributo -->
+				<unique name="unique_Transf_Alg">
+					<selector xpath="./*"/>
+					<field xpath="@Algorithm"/>
+				</unique>
+			</element>
+			<element name="DigestMethod">
+				<complexType>
+					<attribute name="Algorithm" type="anyURI" use="required" fixed="http://www.w3.org/2000/09/xmldsig#sha1"/>
+				</complexType>
+			</element>
+			<element name="DigestValue" type="ds:DigestValueType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+		<attribute name="URI" use="required">
+			<simpleType>
+				<restriction base="anyURI">
+					<minLength value="2"/>
+				</restriction>
+			</simpleType>
+		</attribute>
+		<attribute name="Type" type="anyURI" use="optional"/>
+	</complexType>
+	<complexType name="TransformsType">
+		<sequence>
+			<element name="Transform" type="ds:TransformType" minOccurs="2" maxOccurs="2"/>
+		</sequence>
+	</complexType>
+	<complexType name="TransformType">
+		<sequence minOccurs="0" maxOccurs="unbounded">
+			<element name="XPath" type="string"/>
+		</sequence>
+		<attribute name="Algorithm" type="ds:TTransformURI" use="required"/>
+	</complexType>
+	<complexType name="KeyInfoType">
+		<sequence>
+			<element name="X509Data" type="ds:X509DataType"/>
+		</sequence>
+		<attribute name="Id" type="ID" use="optional"/>
+	</complexType>
+	<complexType name="X509DataType">
+		<sequence>
+			<element name="X509Certificate" type="base64Binary"/>
+		</sequence>
+	</complexType>
+	<simpleType name="DigestValueType">
+		<restriction base="base64Binary"/>
+	</simpleType>
+	<simpleType name="TTransformURI">
+		<restriction base="anyURI">
+			<enumeration value="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
+			<enumeration value="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+		</restriction>
+	</simpleType>
+</schema>

package/scripts/download-schemas.js

@@ -0,0 +1,39 @@
+/**
+ * Baixa schemas XSD oficiais NF-e/NFC-e (PL_009_V4) do repositório nfephp-org/sped-nfe.
+ * Execute: node scripts/download-schemas.js
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const OUT_DIR = path.resolve(__dirname, '../schemas/nfe/PL_009_V4');
+const BASE = 'https://raw.githubusercontent.com/nfephp-org/sped-nfe/master/schemes/PL_009_V4';
+
+const FILES = [
+  'nfe_v4.00.xsd',
+  'leiauteNFe_v4.00.xsd',
+  'tiposBasico_v4.00.xsd',
+  'xmldsig-core-schema_v1.01.xsd',
+  'enviNFe_v4.00.xsd',
+  'inutNFe_v4.00.xsd',
+  'consReciNFe_v4.00.xsd',
+  'consSitNFe_v4.00.xsd',
+  'consStatServ_v4.00.xsd',
+];
+
+fs.mkdirSync(OUT_DIR, { recursive: true });
+
+for (const file of FILES) {
+  const url = `${BASE}/${file}`;
+  const dest = path.join(OUT_DIR, file);
+  const res = await fetch(url);
+  if (!res.ok) {
+    console.warn(`⚠ Não foi possível baixar: ${file}`);
+    continue;
+  }
+  fs.writeFileSync(dest, await res.text());
+  console.log(`✓ ${file}`);
+}
+
+console.log(`\nSchemas salvos em: ${OUT_DIR}`);

package/scripts/test-xsd.js

@@ -0,0 +1,34 @@
+import libxmljs from 'libxmljs2';
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { NFeService } from '../src/index.js';
+
+const dir = path.resolve('schemas/nfe/PL_009_V4');
+const baseUrl = pathToFileURL(dir + path.sep).href;
+const xsd = libxmljs.parseXml(fs.readFileSync(path.join(dir, 'nfe_v4.00.xsd'), 'utf8'), { baseUrl });
+
+const documento = {
+  chaveAcesso: '35260712345678000199550010000000011000000011',
+  ambiente: 2,
+  ide: { uf: 'SP', codigoMunicipio: '3550308', serie: 1, numero: 1 },
+  emitente: {
+    cnpj: '12345678000199', razaoSocial: 'EMPRESA EXEMPLO LTDA', ie: '123456789012', crt: '3',
+    endereco: { logradouro: 'Rua Exemplo', numero: '100', bairro: 'Centro', codigoMunicipio: '3550308', municipio: 'Sao Paulo', uf: 'SP', cep: '01001000' },
+  },
+  destinatario: {
+    cpf: '12345678909', razaoSocial: 'CONSUMIDOR', indIEDest: 9,
+    endereco: { logradouro: 'Rua B', numero: '2', bairro: 'Centro', codigoMunicipio: '3550308', municipio: 'Sao Paulo', uf: 'SP', cep: '01001000' },
+  },
+  itens: [{ codigo: '001', descricao: 'PRODUTO TESTE', ncm: '84713012', cfop: '5102', unidade: 'UN', quantidade: 1, valorUnitario: 100, valorTotal: 100 }],
+};
+
+let xml = new NFeService().gerarXml(documento);
+const id = `NFe${documento.chaveAcesso}`;
+const stub = `<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>ZHVtbXk=</DigestValue></Reference></SignedInfo><SignatureValue>ZHVtbXk=</SignatureValue><KeyInfo><X509Data><X509Certificate>ZHVtbXk=</X509Certificate></X509Data></KeyInfo></Signature>`;
+xml = xml.replace('</NFe>', `${stub}</NFe>`);
+
+const doc = libxmljs.parseXml(xml);
+const valid = doc.validate(xsd);
+console.log('valid:', valid);
+if (!valid) doc.validationErrors.forEach((e) => console.log(e.message));

package/src/api/server.js

@@ -0,0 +1,316 @@
+import 'dotenv/config';
+import express from 'express';
+import swaggerUi from 'swagger-ui-express';
+import YAML from 'yamljs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { NFeService } from '../nfe/services/NFeService.js';
+import { NFCeService } from '../nfce/services/NFCeService.js';
+import { NFSeService } from '../nfse/services/NFSeService.js';
+import { SefazEndpointResolver } from '../sefaz/SefazEndpointResolver.js';
+import { NFSeMunicipioResolver } from '../nfse/NFSeMunicipioResolver.js';
+import { SefazError } from '../errors/SefazError.js';
+import { GhinfeError } from '../errors/GhinfeError.js';
+import { XsdValidationError } from '../errors/XsdValidationError.js';
+import { NFSeSoapError } from '../nfse/services/NFSeSoapService.js';
+import { NFSE_LAYOUTS } from '../nfse/constants/municipios.js';
+import { DanfeService } from '../danfe/DanfeService.js';
+import { calcularIBSCBS, buildFragmentoIBSCBS } from '../reforma/ibscbs.js';
+import { SEFAZ_MOCK_RESPONSES } from '../nfe/mocks/sefaz-responses.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const openapiPath = path.join(__dirname, '../../docs/openapi.yaml');
+const swaggerDocument = YAML.load(openapiPath);
+
+const app = express();
+const port = process.env.PORT ?? 3333;
+
+app.use(express.json({ limit: '2mb' }));
+app.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument, {
+  customSiteTitle: 'GHINFE API — Swagger',
+}));
+app.use('/guia', express.static(path.join(__dirname, '../../docs')));
+
+app.get('/health', (_req, res) => {
+  res.json({ status: 'ok', library: 'ghinfe', version: '0.6.0' });
+});
+
+app.post('/nfe/xml', (req, res) => {
+  try {
+    const validar = req.query.validarXsd === 'true';
+    const service = new NFeService({ validarXsd: validar });
+    const doc = service.resolverDocumento(req.body);
+    const xml = service.gerarXml(doc, { validarXsd: validar });
+    res.json({ chaveAcesso: doc.chaveAcesso, xml, xsdValidado: validar });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfe/validar-xsd', (req, res) => {
+  try {
+    const service = new NFeService();
+    const resultado = service.validarXsd(req.body.xml, { preAssinatura: !req.body.xml.includes('</Signature>') });
+    res.json(resultado);
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfce/xml', (req, res) => {
+  try {
+    const service = new NFCeService();
+    const doc = service.resolverDocumento(req.body);
+    const xml = service.gerarXml(doc);
+    res.json({ chaveAcesso: doc.chaveAcesso, xml, observacao: 'QR Code v3 é adicionado após assinatura' });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfce/enviar-mock', async (req, res) => {
+  try {
+    const service = new NFCeService({ mock: true });
+    const doc = service.resolverDocumento(req.body);
+    const xml = service.gerarXml(doc);
+    const retorno = await service.enviar(xml, doc.chaveAcesso);
+    res.json({ chaveAcesso: doc.chaveAcesso, xmlGerado: xml, retorno, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfe/chave', (req, res) => {
+  try {
+    const service = new NFeService();
+    const chaveAcesso = service.gerarChaveAcesso(req.body);
+    res.json({ chaveAcesso, valida: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfe/cancelar-mock', async (req, res) => {
+  try {
+    const service = new NFeService({ mock: true, mockEventoScenario: 'registrado' });
+    const xml = service.gerarXmlCancelamento(req.body);
+    const retorno = await service.enviarEventoMock(
+      xml,
+      req.body.chaveAcesso,
+      '110111'
+    );
+    res.json({ xmlGerado: xml, retorno, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfe/cce-mock', async (req, res) => {
+  try {
+    const service = new NFeService({ mock: true, mockEventoScenario: 'registrado' });
+    const xml = service.gerarXmlCartaCorrecao(req.body);
+    const retorno = await service.enviarEventoMock(
+      xml,
+      req.body.chaveAcesso,
+      '110110'
+    );
+    res.json({ xmlGerado: xml, retorno, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfe/enviar-mock', async (req, res) => {
+  try {
+    const cenario = req.query.cenario ?? 'autorizado';
+    const service = new NFeService({ mock: true, mockScenario: cenario });
+
+    const doc = service.resolverDocumento(req.body);
+    const xml = service.gerarXml(doc);
+    const retorno = await service.enviar(xml, doc.chaveAcesso);
+
+    res.json({
+      chaveAcesso: doc.chaveAcesso,
+      xmlGerado: xml,
+      retorno,
+      mock: true,
+    });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.get('/sefaz/endpoints/:uf', (req, res) => {
+  try {
+    const ambiente = parseInt(req.query.ambiente ?? '2', 10);
+    const info = SefazEndpointResolver.obterEndpoints(req.params.uf, ambiente);
+    res.json(info);
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.get('/sefaz/ufs', (_req, res) => {
+  res.json({ ufs: SefazEndpointResolver.listarUFs() });
+});
+
+app.get('/sefaz/status/:uf', async (req, res) => {
+  try {
+    const ambiente = parseInt(req.query.ambiente ?? '2', 10);
+    const service = new NFeService({ mock: true, uf: req.params.uf, ambiente });
+    if (req.query.cenario) service.soapService.setMockStatusScenario(req.query.cenario);
+    const status = await service.consultarStatus(req.params.uf, ambiente);
+    res.json(status);
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.get('/nfse/layouts', (_req, res) => {
+  res.json({ layouts: Object.values(NFSE_LAYOUTS) });
+});
+
+app.post('/nfse/xml', (req, res) => {
+  try {
+    const layout = req.query.layout ?? req.body.layout;
+    const service = new NFSeService({ layout });
+    const xml = service.gerarXml(req.body, layout);
+    res.json({ layout: layout ?? service.resolverLayout(req.body), xml });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/reforma/calcular', (req, res) => {
+  try {
+    const { baseCalculo, aliquotas } = req.body;
+    const reforma = calcularIBSCBS(baseCalculo, aliquotas ?? {});
+    res.json({ reforma, fragmentoXml: buildFragmentoIBSCBS(reforma) });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfse/enviar-mock', async (req, res) => {
+  try {
+    const layout = req.query.layout ?? req.body.layout;
+    const service = new NFSeService({ mock: true, layout });
+    const resultado = await service.emitir(req.body);
+    res.json({ ...resultado, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfse/cancelar-mock', async (req, res) => {
+  try {
+    const service = new NFSeService({ mock: true });
+    const resultado = await service.cancelar(req.body);
+    res.json({ ...resultado, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/nfse/substituir-mock', async (req, res) => {
+  try {
+    const service = new NFSeService({ mock: true });
+    const resultado = await service.substituir(req.body);
+    res.json({ ...resultado, mock: true });
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.post('/danfe', async (req, res) => {
+  try {
+    const service = new DanfeService();
+    const resultado = await service.gerar(req.body.xml, {
+      protocolo: req.body.protocolo,
+      qrCodeUrl: req.body.qrCodeUrl,
+    });
+    if (req.query.format === 'html') {
+      res.type('html').send(resultado.html);
+      return;
+    }
+    res.json(resultado);
+  } catch (error) {
+    handleError(res, error);
+  }
+});
+
+app.get('/nfse/municipios', (_req, res) => {
+  const municipios = NFSeMunicipioResolver.listarMunicipios()
+    .filter((c) => c !== 'mock')
+    .map((codigo) => {
+      const info = NFSeMunicipioResolver.resolver(codigo, 2);
+      return { codigo, ...info };
+    });
+  res.json({ municipios, layouts: Object.values(NFSE_LAYOUTS) });
+});
+
+app.get('/nfe/cenarios-mock', (_req, res) => {
+  res.json({
+    cenarios: [
+      { id: 'autorizado', descricao: 'NF-e autorizada (cStat 100)', cStat: '100' },
+      { id: 'duplicidade', descricao: 'Rejeição por duplicidade (cStat 204)', cStat: '204' },
+      { id: 'schema', descricao: 'Rejeição por schema inválido (cStat 225)', cStat: '225' },
+      { id: 'certificado', descricao: 'Certificado inválido (cStat 280)', cStat: '280' },
+      { id: 'paralisado', descricao: 'Serviço paralisado (cStat 108)', cStat: '108' },
+    ],
+    responses: SEFAZ_MOCK_RESPONSES,
+  });
+});
+
+/**
+ * @param {import('express').Response} res
+ * @param {unknown} error
+ */
+function handleError(res, error) {
+  if (error instanceof SefazError) {
+    return res.status(422).json({
+      error: error.name,
+      code: error.code,
+      cStat: error.cStat,
+      xMotivo: error.xMotivo,
+      details: error.details,
+    });
+  }
+
+  if (error instanceof NFSeSoapError) {
+    return res.status(422).json({
+      error: error.name,
+      code: error.code,
+      codigo: error.codigo,
+      message: error.message,
+    });
+  }
+
+  if (error instanceof XsdValidationError) {
+    return res.status(422).json({
+      error: error.name,
+      code: error.code,
+      message: error.message,
+      erros: error.erros,
+      schema: error.schema,
+    });
+  }
+
+  if (error instanceof GhinfeError) {
+    return res.status(400).json({
+      error: error.name,
+      code: error.code,
+      message: error.message,
+      details: error.details,
+    });
+  }
+
+  console.error(error);
+  res.status(500).json({ error: 'InternalServerError', message: 'Erro interno' });
+}
+
+app.listen(port, () => {
+  console.log(`GHINFE API rodando em http://localhost:${port}`);
+  console.log(`Swagger UI: http://localhost:${port}/docs`);
+  console.log(`Guia do desenvolvedor: http://localhost:${port}/guia/developer-guide.html`);
+});

package/src/constants/sefaz.js

@@ -0,0 +1,69 @@
+/** Códigos de UF conforme tabela IBGE (últimos 2 dígitos da chave NF-e). */
+export const UF_IBGE = {
+  AC: '12',
+  AL: '27',
+  AM: '13',
+  AP: '16',
+  BA: '29',
+  CE: '23',
+  DF: '53',
+  ES: '32',
+  GO: '52',
+  MA: '21',
+  MG: '31',
+  MS: '50',
+  MT: '51',
+  PA: '15',
+  PB: '25',
+  PE: '26',
+  PI: '22',
+  PR: '41',
+  RJ: '33',
+  RN: '24',
+  RO: '11',
+  RR: '14',
+  RS: '43',
+  SC: '42',
+  SE: '28',
+  SP: '35',
+  TO: '17',
+};
+
+/** 1 = Produção, 2 = Homologação. */
+export const AMBIENTE = {
+  PRODUCAO: 1,
+  HOMOLOGACAO: 2,
+};
+
+/** Layout NF-e versão 4.00. */
+export const NFE_VERSAO = '4.00';
+
+/** Endpoints SEFAZ (homologação) — variam por UF; use como referência. */
+export const SEFAZ_URLS = {
+  SP: {
+    autorizacao: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfeautorizacao4.asmx',
+    retAutorizacao: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nferetautorizacao4.asmx',
+    consulta: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfeconsultaprotocolo4.asmx',
+    evento: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nferecepcaoevento4.asmx',
+  },
+};
+
+/** cStat mais comuns retornados pela SEFAZ. */
+export const SEFAZ_STATUS = {
+  AUTORIZADO: '100',
+  CANCELADO: '101',
+  LOTE_RECEBIDO: '103',
+  LOTE_PROCESSADO: '104',
+  LOTE_EM_PROCESSAMENTO: '105',
+  SERVICO_EM_OPERACAO: '107',
+  SERVICO_PARALISADO: '108',
+  SERVICO_PARALISADO_SEM_PREVISAO: '109',
+  USO_DENEGADO: '110',
+  REJEICAO_DUPLICIDADE: '204',
+  REJEICAO_CHAVE_INVALIDA: '236',
+  REJEICAO_CERTIFICADO: '280',
+  REJEICAO_SCHEMA: '225',
+  EVENTO_REGISTRADO: '135',
+  EVENTO_LOTE_PROCESSADO: '128',
+  EVENTO_REJEICAO: '491',
+};