@sinete/nfe 0.2.0 → 0.4.0

package/src/rtc.ts

@@ -28,7 +28,13 @@ import { calcular, ErroClassificacao, ErroRegimeNaoSuportado } from '@sinete/ibs
 import type { Regra } from '@sinete/ibs-cbs/validar';
 import { documentoDoRoc, validar } from '@sinete/ibs-cbs/validar';
 import type { DatasetIbsCbs } from '@sinete/ibs-cbs-dados';
-import type { CalculadoraIbsCbs, PedidoIbsCbsItem, PedidoIbsCbsNota, RespostaIbsCbs } from './ports.ts';
+import type {
+  AliquotaIbsCbsInformada,
+  CalculadoraIbsCbs,
+  PedidoIbsCbsItem,
+  PedidoIbsCbsNota,
+  RespostaIbsCbs,
+} from './ports.ts';
 
 /** Grupo `IBSCBS` do item, como o `@sinete/nfe` o recebe. */
 export type GrupoIbsCbs = RespostaIbsCbs['itens'][number]['IBSCBS'];
@@ -109,15 +115,42 @@ function grupoDoLeiaute(g: IBSCBS, indDoacao: '1' | undefined): GrupoIbsCbs {
   } as GrupoIbsCbs;
 }
 
-/** Erro do motor ou das alíquotas como ocorrência no item (ou na nota, quando o erro não diz o item). */
-function ocorrenciaDoMotor(e: unknown, itens: readonly PedidoIbsCbsItem[]): Ocorrencia | undefined {
+/**
+ * Erro do motor ou das alíquotas como uma ocorrência no caminho do item (o primeiro, quando o erro não diz o item).
+ * `semAliquota` acha o item que pediu a alíquota desconhecida: o erro do provedor diz o tributo e a data, não o item.
+ */
+function ocorrenciaDoMotor(
+  e: unknown,
+  itens: readonly PedidoIbsCbsItem[],
+  semAliquota: () => number | undefined,
+): Ocorrencia | undefined {
   if (e instanceof ErroClassificacao || e instanceof ErroRegimeNaoSuportado) {
     const path = e.item !== undefined ? caminho(e.item) : caminho(itens[0]?.nItem ?? 1);
     return { caminho: path, code: e.code, mensagem: e.message, origem: 'entrada' };
   }
   // Alíquota que o sinete não conhece para a data: falta de dado do pacote, não da nota.
-  if (e instanceof ErroAliquotaDesconhecida)
-    return { caminho: 'impostos.ibsCbs', code: e.code, mensagem: e.message, origem: 'montagem' };
+  if (e instanceof ErroAliquotaDesconhecida) {
+    const n = semAliquota() ?? itens[0]?.nItem ?? 1;
+    return { caminho: caminho(n), code: e.code, mensagem: e.message, origem: 'montagem' };
+  }
+  return undefined;
+}
+
+/**
+ * O primeiro item (pela ordem de `nItem`, a do motor) cujo cálculo sozinho pede uma alíquota desconhecida. Só roda na
+ * recusa, para pôr a ocorrência no item em vez de na nota.
+ */
+function primeiroItemSemAliquota(
+  op: OperacaoClassificada,
+  calc: (op: OperacaoClassificada) => unknown,
+): number | undefined {
+  for (const it of [...op.itens].sort((a, b) => a.n - b.n)) {
+    try {
+      calc({ ...op, itens: [it] });
+    } catch (e) {
+      if (e instanceof ErroAliquotaDesconhecida) return it.n;
+    }
+  }
   return undefined;
 }
 
@@ -234,16 +267,18 @@ function calcularCom(
     itens: classificados,
   };
   const time = contextoDeTempo({ emissao: relogioFixo(nota.emissao), fatoGerador: relogioFixo(nota.fatoGerador) });
-  let roc: Roc;
-  try {
-    roc = calcular(op, {
+  const calc = (o: OperacaoClassificada): Roc =>
+    calcular(o, {
       dataset,
       aliquotas: rates,
       tempo: time,
       ...(options.deslocamentoMin === undefined ? {} : { deslocamentoMin: options.deslocamentoMin }),
     });
+  let roc: Roc;
+  try {
+    roc = calc(op);
   } catch (e) {
-    const issue = ocorrenciaDoMotor(e, itens);
+    const issue = ocorrenciaDoMotor(e, itens, () => primeiroItemSemAliquota(op, calc));
     if (issue === undefined) throw e;
     return { itens: [], ocorrencias: [issue] };
   }
@@ -295,11 +330,17 @@ function calcularCom(
   }
 
   const porItem = new Map(itens.map((it) => [it.nItem, it]));
+  const informadas: AliquotaIbsCbsInformada[] = roc.itens.flatMap((r) =>
+    r.aliquotas
+      .filter((a) => a.situacao === 'informada')
+      .map((a) => ({ nItem: r.nItem, tributo: a.tributo, valor: a.valor, motivo: a.motivo ?? '' })),
+  );
   return {
     itens: roc.itens.map((r) => ({
       nItem: r.nItem,
       IBSCBS: grupoDoLeiaute(r.IBSCBS, porItem.get(r.nItem)?.indDoacao),
     })),
+    ...(informadas.length === 0 ? {} : { aliquotasInformadas: informadas }),
     ...(issues.length === 0 ? {} : { ocorrencias: issues }),
   };
 }

package/src/services/recuperar.ts

@@ -11,7 +11,7 @@
 
 import type { DocumentoXml, ElementoXml } from '@sinete/core/xml';
 import { lerXml, primeiroFilho, textoDe } from '@sinete/core/xml';
-import type { ClienteNfe, EventoRegistrado, ResultadoConsulta } from './client.ts';
+import type { ClienteNfe, EnvioOpcoes, EventoRegistrado, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
 import { NFE_NS, recortarElemento } from './proc.ts';
 
@@ -73,14 +73,16 @@ function lerProcEvento(xml: string): EventoRegistrado | undefined {
  * vários, como na CC-e; com `nSeqEvento`, só o dessa sequência). Serve depois de um pedido de evento sem resposta ou
  * respondido com 573 ou 580: nunca conclua que o evento existe só pelo `cStat` do pedido. `registrado: false` quer
  * dizer que a consulta não mostrou o evento (ou não decidiu: veja `consulta`); não quer dizer que o evento não existe.
+ * `opcoes.signal` cancela a consulta.
  */
 export async function recuperarEventoRegistrado(
   cliente: ClienteNfe,
   chave: string,
   tpEvento: string,
   nSeqEvento?: number,
+  opcoes?: EnvioOpcoes,
 ): Promise<RecuperacaoEvento> {
-  const consulta = await cliente.consultar(chave);
+  const consulta = await cliente.consultar(chave, undefined, opcoes);
   if (consulta.tipo !== 'autorizado' && consulta.tipo !== 'denegado') return { registrado: false, consulta };
   let achado: EventoRegistrado | undefined;
   for (const xml of consulta.valor.eventos) {

package/src/services/resolver.ts

@@ -28,7 +28,7 @@
 
 import type { Recusado } from '@sinete/core';
 import { criarAutorizado, criarDenegado } from '@sinete/core';
-import type { ClienteNfe, ProtocoloNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.ts';
+import type { ClienteNfe, EnvioOpcoes, ProtocoloNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
 import { documentoAssinado } from './proc.ts';
 
@@ -85,12 +85,14 @@ export function chaveDaDuplicidade(xMotivo: string): string | undefined {
 
 /**
  * Resolve um envio de autorização sem resposta, ou cuja resposta foi 204 ou 539, consultando a chave da NF-e
- * assinada. `anterior` é o desfecho do envio, quando houve um.
+ * assinada. `anterior` é o desfecho do envio, quando houve um. `opcoes.signal` cancela a consulta (lança o
+ * `ErroTransporte` com `code: 'cancelado'`).
  */
 export async function resolverEnvioSemResposta(
   cliente: ClienteNfe,
   nfeAssinada: string,
   anterior?: ResultadoAutorizacao,
+  opcoes?: EnvioOpcoes,
 ): Promise<ResolucaoEnvio> {
   const a = documentoAssinado(nfeAssinada, 'NFe', 'infNFe');
   const chave = a.id.slice(3);
@@ -98,7 +100,7 @@ export async function resolverEnvioSemResposta(
     const outra = chaveDaDuplicidade(anterior.xMotivo);
     return { acao: 'divergente', motivo: anterior, ...(outra === undefined ? {} : { chNFe: outra }) };
   }
-  const consulta = await cliente.consultar(chave, nfeAssinada);
+  const consulta = await cliente.consultar(chave, nfeAssinada, opcoes);
   if (consulta.tipo === 'recusado') {
     if (cstatEm(consulta.cStat, 'naoConsta')) return { acao: 'reenviar', nfeAssinada: a.xml };
     // 561, 562 e 613 na consulta: a chave local não consta, mas a numeração dela tem outra NF-e (outro mês, outro cNF

package/src/versao-gerada.ts

@@ -1,3 +1,3 @@
 // GERADO por scripts/versao-gerada.ts a partir do package.json. Não edite: rode `bun scripts/versao-gerada.ts`.
 /** Versão de `@sinete/nfe`, para o padrão de `verProc`/`verAplic` (`formatarVerProc` do @sinete/core). */
-export const VERSAO_PACOTE = '0.2.0';
+export const VERSAO_PACOTE = '0.4.0';