Como usar a API corretamente para implementar uma sincronização com DB

[vcdomith]

Gostaria de agradecer enormemente a implementação dessa API!
Estou tentando implementação a funcionalidade de buscar de NFes e CTes na minha aplicação, idealmente usaria apenas o método de consultaChave(), porém o WebService de CTes parece que não suporta ainda essa funcionalidade, se olhar no Schema XML dele

distDFeInt_v1.00.xsd

<xs:element name="tpAmb" type="TAmb">
  <xs:annotation>
    <xs:documentation>
      Identificação do Ambiente:
      1 - Produção
      2 - Homologação
    </xs:documentation>
  </xs:annotation>
</xs:element>

<xs:element name="cUFAutor" type="TCodUfIBGE">
  <xs:annotation>
    <xs:documentation>Código da UF do Autor</xs:documentation>
  </xs:annotation>
</xs:element>

<xs:element name="CNPJ" type="TCnpj">
  <xs:annotation>
    <xs:documentation>CNPJ do interessado no DF-e</xs:documentation>
  </xs:annotation>
</xs:element>

<xs:element name="CPF" type="TCpf">
  <xs:annotation>
    <xs:documentation>CPF do interessado no DF-e</xs:documentation>
  </xs:annotation>
</xs:element>

<xs:element name="distNSU">
  <xs:annotation>
    <xs:documentation>Grupo para distribuir DF-e de interesse</xs:documentation>
  </xs:annotation>
  <xs:complexType>
    <xs:sequence>
      <xs:element name="ultNSU" type="TNSU">
        <xs:annotation>
          <xs:documentation>Último NSU recebido pelo ator. Caso seja informado com zero, ou com um NSU muito antigo, a consulta retornará unicamente as informações resumidas e documentos fiscais eletrônicos que tenham sido recepcionados pelo Ambiente Nacional nos últimos 3 meses.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

<xs:element name="consNSU">
  <xs:annotation>
    <xs:documentation>Grupo para consultar um DF-e a partir de um NSU específico</xs:documentation>
  </xs:annotation>
  <xs:complexType>
    <xs:sequence>
      <xs:element name="NSU" type="TNSU">
        <xs:annotation>
          <xs:documentation>Número Sequencial Único. Geralmente esta consulta será utilizada quando identificado pelo interessado um NSU faltante. O Web Service retornará o documento ou informará que o NSU não existe no Ambiente Nacional. Assim, esta consulta fechará a lacuna do NSU identificado como faltante.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

Parece que o CTe usa uma versão mais antiga desse serviço, então tive que implementar com o uso do ultNSU para consultar um lote de CTes, mas apenas queria os 50 mais recentes, pois não há necessidade de suportar documentos mais antigos.

const distribuição = new DistribuicaoCTe({
        pfx: certBuffer,
        passphrase: process.env.NFE_CERT_SECRET!,
        cnpj: '05079279000164',
        cUFAutor: chCTe.slice(0,2) as COD_UF,
        tpAmb: '1',
    })

    if (nsu?.cte === null) {

        //Consulta distribuicao.consultaNSU(0)
        const consultaMaxNsu = await distribuição.consultaNSU('0')
        console.log('consultaMaxNsu', consultaMaxNsu);

        //Get maxNsu da resposta
        const maxNSU = consultaMaxNsu.data.maxNSU

        //Consulta distribuicao.consultaUltNSU(maxNSu - 100)
        console.log('Fazendo consulta initial e alimentando DB...');
        const consulta = await distribuição.consultaUltNSU((parseInt(maxNSU) - 50).toString())
        console.log('consulta', consulta);

        //Filtra, transforma os resultados para o seguinte formato: {nsu: string, chCTe: string}[]
        const ultNsu = consulta.data.ultNSU
        const dados = consulta.data.docZip
        const resFiltrado = dados
            .filter( dado => dado.schema.includes('procCTe'))
            .map((registro) => ({
                criado_em: registro.json.cteProc.CTe.infCte.ide.dhEmi,
                nsu: registro.nsu,
                chCTe: registro.json.cteProc.CTe.infCte['@_Id'].slice(3),
                xml: registro.xml,
            }))
        // console.log('resFiltrado', resFiltrado);

        //Registra relações nsu e ch para db
        const { data, error } = await supabase
            .from('ctes')
            .insert(resFiltrado)
        if (error) console.log(error);

        // //Cria row ultNSU com o ultNsu Cte na db
        const { data: dataNsu, error: errorNsu } = await supabase
            .from('ultNSU')
            .update({ cte: ultNsu })
            .eq('id', 1)
            .select()
        if (errorNsu) console.log(errorNsu);

        const resCh = resFiltrado.filter( cadastro => cadastro.chCTe === chCTe )
        console.log('resCh', resCh );

        if (resCh.length > 0) {

            return new Response(JSON.stringify(resCh[0].xml), {
                status: 200,
                headers: {
                    'Content-Type': 'application/json'
                }
            })
        }

        return new Response(JSON.stringify(`Nenhuma CTe com a chave ${chCTe} foi encontrado`), {
            status: 404
        })

    }

Essa implementação inicial para CTes funciona, primeiro eu passo um NSU que não vai retornar nada só para conseguir o maxNSU e então uso ele para calcular os 50 últimos e então populo a table de CTes para consultas futuras.
Porém quando tento usar a mesma lógica para NFes tomo erro de Consumo Indevido (fiquei ontem o dia todo tentando testar isso e esse bloqueio dá vontade de arrancar o cabelo kk). Tentei também usar o consultaUltNsu só que aí teria que ir de 50 em 50 por 300k cadastros? Não entendi muito bem como usar o ultNSU, se usar o seguinte:

//consulta incial do nsu 0 ao 50
await distribuicao.consultaUltNsu('0')
// loop que espera o retorno e vê o cStat e continua fazendo consulta com o ultNsu que é 50 e assim vai até chegar no maxNsu

[lucashpmelo]

Bom dia,

Na consulta por ultNSU você sempre deve seguir a sequencia retornada pela Sefaz para evitar o consumo indevido.

A primeira consulta pode ser feita passando o valor de NSU '000000000000000', no retorno da requisição terá os valores de ultNSU e maxNSU. O ultNSU é o valor que deve ser usado na próxima consulta, e o maxNSU é a quantidade máxima de NSU gerados até o momento. É importante salvar o valor do ultNSU retornado para sempre iniciar a próxima consulta com ele, assim você evita ao máximo tomar o consumo indevido.

[vcdomith]

Essa funcionalidade do WebService consultaUltNSu espera que seja usado em um loop até que o ultNSU chegue no valor do maxNSU, de forma sequencial pra não tomar um consumo indevido, correto?

[lucashpmelo]

Correto.

[vcdomith]

Muito obrigado!