ghinfe 0.6.0 → 0.6.2

package/src/queue/NFCeQueue.js

@@ -1,63 +1,63 @@
-import Bull from 'bull';
-import { NFCeService } from '../nfce/services/NFCeService.js';
-
-/**
- * Fila Bull/Redis para processamento assíncrono de NFC-e.
- */
-export class NFCeQueue {
-  /**
-   * @param {{
-   *   redis?: { host?: string, port?: number, password?: string },
-   *   queueName?: string,
-   *   nfceOptions?: ConstructorParameters<typeof NFCeService>[0],
-   * }} [options]
-   */
-  constructor(options = {}) {
-    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
-    const queueName = options.queueName ?? 'ghinfe:nfce:emissao';
-
-    this.queue = new Bull(queueName, { redis });
-    this.nfceService = new NFCeService(options.nfceOptions ?? { mock: true });
-    this.#registerProcessor();
-  }
-
-  #registerProcessor() {
-    this.queue.process(async (job) => {
-      const { documento, certificado } = job.data;
-      return this.nfceService.emitir(documento, certificado);
-    });
-  }
-
-  /**
-   * @param {{
-   *   documento: import('../nfce/types/NFCeDocument.js').NFCeDocumento,
-   *   certificado: { pfx: Buffer|string, senha: string },
-   * }} payload
-   */
-  async adicionarEmissao(payload) {
-    return this.queue.add(payload, {
-      attempts: 3,
-      backoff: { type: 'exponential', delay: 5000 },
-      removeOnComplete: 100,
-      removeOnFail: 500,
-    });
-  }
-
-  /** @param {(resultado: Awaited<ReturnType<NFCeService['emitir']>>, job: Bull.Job) => Promise<void>} handler */
-  onCompleted(handler) {
-    this.queue.on('completed', async (job, resultado) => {
-      await handler(resultado, job);
-    });
-  }
-
-  /** @param {(error: Error, job: Bull.Job) => Promise<void>} handler */
-  onFailed(handler) {
-    this.queue.on('failed', async (job, error) => {
-      await handler(error, job);
-    });
-  }
-
-  async close() {
-    await this.queue.close();
-  }
-}
+import Bull from 'bull';
+import { NFCeService } from '../nfce/services/NFCeService.js';
+
+/**
+ * Fila Bull/Redis para processamento assíncrono de NFC-e.
+ */
+export class NFCeQueue {
+  /**
+   * @param {{
+   *   redis?: { host?: string, port?: number, password?: string },
+   *   queueName?: string,
+   *   nfceOptions?: ConstructorParameters<typeof NFCeService>[0],
+   * }} [options]
+   */
+  constructor(options = {}) {
+    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
+    const queueName = options.queueName ?? 'ghinfe:nfce:emissao';
+
+    this.queue = new Bull(queueName, { redis });
+    this.nfceService = new NFCeService(options.nfceOptions ?? { mock: true });
+    this.#registerProcessor();
+  }
+
+  #registerProcessor() {
+    this.queue.process(async (job) => {
+      const { documento, certificado } = job.data;
+      return this.nfceService.emitir(documento, certificado);
+    });
+  }
+
+  /**
+   * @param {{
+   *   documento: import('../nfce/types/NFCeDocument.js').NFCeDocumento,
+   *   certificado: { pfx: Buffer|string, senha: string },
+   * }} payload
+   */
+  async adicionarEmissao(payload) {
+    return this.queue.add(payload, {
+      attempts: 3,
+      backoff: { type: 'exponential', delay: 5000 },
+      removeOnComplete: 100,
+      removeOnFail: 500,
+    });
+  }
+
+  /** @param {(resultado: Awaited<ReturnType<NFCeService['emitir']>>, job: Bull.Job) => Promise<void>} handler */
+  onCompleted(handler) {
+    this.queue.on('completed', async (job, resultado) => {
+      await handler(resultado, job);
+    });
+  }
+
+  /** @param {(error: Error, job: Bull.Job) => Promise<void>} handler */
+  onFailed(handler) {
+    this.queue.on('failed', async (job, error) => {
+      await handler(error, job);
+    });
+  }
+
+  async close() {
+    await this.queue.close();
+  }
+}

package/src/queue/NFSeQueue.js

@@ -1,59 +1,59 @@
-import Bull from 'bull';
-import { NFSeService } from '../nfse/services/NFSeService.js';
-
-/**
- * Fila Bull/Redis para processamento assíncrono de NFS-e.
- */
-export class NFSeQueue {
-  /**
-   * @param {{
-   *   redis?: { host?: string, port?: number, password?: string },
-   *   queueName?: string,
-   *   nfseOptions?: ConstructorParameters<typeof NFSeService>[0],
-   * }} [options]
-   */
-  constructor(options = {}) {
-    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
-    const queueName = options.queueName ?? 'ghinfe:nfse:emissao';
-
-    this.queue = new Bull(queueName, { redis });
-    this.nfseService = new NFSeService(options.nfseOptions ?? { mock: true });
-    this.#registerProcessor();
-  }
-
-  #registerProcessor() {
-    this.queue.process(async (job) => {
-      const { documento } = job.data;
-      return this.nfseService.emitir(documento);
-    });
-  }
-
-  /**
-   * @param {{ documento: import('../nfse/types/NFSeDocument.js').NFSeDocumento }} payload
-   */
-  async adicionarEmissao(payload) {
-    return this.queue.add(payload, {
-      attempts: 3,
-      backoff: { type: 'exponential', delay: 5000 },
-      removeOnComplete: 100,
-      removeOnFail: 500,
-    });
-  }
-
-  /** @param {(resultado: Awaited<ReturnType<NFSeService['emitir']>>, job: Bull.Job) => Promise<void>} handler */
-  onCompleted(handler) {
-    this.queue.on('completed', async (job, resultado) => {
-      await handler(resultado, job);
-    });
-  }
-
-  onFailed(handler) {
-    this.queue.on('failed', async (job, error) => {
-      await handler(error, job);
-    });
-  }
-
-  async close() {
-    await this.queue.close();
-  }
-}
+import Bull from 'bull';
+import { NFSeService } from '../nfse/services/NFSeService.js';
+
+/**
+ * Fila Bull/Redis para processamento assíncrono de NFS-e.
+ */
+export class NFSeQueue {
+  /**
+   * @param {{
+   *   redis?: { host?: string, port?: number, password?: string },
+   *   queueName?: string,
+   *   nfseOptions?: ConstructorParameters<typeof NFSeService>[0],
+   * }} [options]
+   */
+  constructor(options = {}) {
+    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
+    const queueName = options.queueName ?? 'ghinfe:nfse:emissao';
+
+    this.queue = new Bull(queueName, { redis });
+    this.nfseService = new NFSeService(options.nfseOptions ?? { mock: true });
+    this.#registerProcessor();
+  }
+
+  #registerProcessor() {
+    this.queue.process(async (job) => {
+      const { documento } = job.data;
+      return this.nfseService.emitir(documento);
+    });
+  }
+
+  /**
+   * @param {{ documento: import('../nfse/types/NFSeDocument.js').NFSeDocumento }} payload
+   */
+  async adicionarEmissao(payload) {
+    return this.queue.add(payload, {
+      attempts: 3,
+      backoff: { type: 'exponential', delay: 5000 },
+      removeOnComplete: 100,
+      removeOnFail: 500,
+    });
+  }
+
+  /** @param {(resultado: Awaited<ReturnType<NFSeService['emitir']>>, job: Bull.Job) => Promise<void>} handler */
+  onCompleted(handler) {
+    this.queue.on('completed', async (job, resultado) => {
+      await handler(resultado, job);
+    });
+  }
+
+  onFailed(handler) {
+    this.queue.on('failed', async (job, error) => {
+      await handler(error, job);
+    });
+  }
+
+  async close() {
+    await this.queue.close();
+  }
+}

package/src/queue/NFeQueue.js

@@ -1,76 +1,76 @@
-import Bull from 'bull';
-import { NFeService } from '../nfe/services/NFeService.js';
-
-/**
- * Fila Bull/Redis para processamento assíncrono de NF-e.
- * Integra com Sequelize no worker: persista o retorno após autorização.
- *
- * @example
- * const queue = new NFeQueue({ redis: { host: '127.0.0.1', port: 6379 } });
- * await queue.adicionarEmissao({ documento, certificado });
- * queue.processar(async (resultado) => { await NotaFiscal.create(...); });
- */
-export class NFeQueue {
-  /**
-   * @param {{
-   *   redis?: { host?: string, port?: number, password?: string },
-   *   queueName?: string,
-   *   nfeOptions?: ConstructorParameters<typeof NFeService>[0],
-   * }} [options]
-   */
-  constructor(options = {}) {
-    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
-    const queueName = options.queueName ?? 'ghinfe:nfe:emissao';
-
-    this.queue = new Bull(queueName, { redis });
-    this.nfeService = new NFeService(options.nfeOptions ?? { mock: true });
-    this.#registerProcessor();
-  }
-
-  #registerProcessor() {
-    this.queue.process(async (job) => {
-      const { documento, certificado, idLote } = job.data;
-      const resultado = await this.nfeService.emitir(documento, certificado, idLote);
-      return resultado;
-    });
-  }
-
-  /**
-   * @param {{
-   *   documento: import('../nfe/types/NFeDocument.js').NFeDocument,
-   *   certificado: { pfx: Buffer|string, senha: string },
-   *   idLote?: string,
-   * }} payload
-   */
-  async adicionarEmissao(payload) {
-    return this.queue.add(payload, {
-      attempts: 3,
-      backoff: { type: 'exponential', delay: 5000 },
-      removeOnComplete: 100,
-      removeOnFail: 500,
-    });
-  }
-
-  /**
-   * Callback executado após emissão bem-sucedida (ex: salvar no Sequelize).
-   * @param {(resultado: Awaited<ReturnType<NFeService['emitir']>>, job: Bull.Job) => Promise<void>} handler
-   */
-  onCompleted(handler) {
-    this.queue.on('completed', async (job, resultado) => {
-      await handler(resultado, job);
-    });
-  }
-
-  /**
-   * @param {(error: Error, job: Bull.Job) => Promise<void>} handler
-   */
-  onFailed(handler) {
-    this.queue.on('failed', async (job, error) => {
-      await handler(error, job);
-    });
-  }
-
-  async close() {
-    await this.queue.close();
-  }
-}
+import Bull from 'bull';
+import { NFeService } from '../nfe/services/NFeService.js';
+
+/**
+ * Fila Bull/Redis para processamento assíncrono de NF-e.
+ * Integra com Sequelize no worker: persista o retorno após autorização.
+ *
+ * @example
+ * const queue = new NFeQueue({ redis: { host: '127.0.0.1', port: 6379 } });
+ * await queue.adicionarEmissao({ documento, certificado });
+ * queue.processar(async (resultado) => { await NotaFiscal.create(...); });
+ */
+export class NFeQueue {
+  /**
+   * @param {{
+   *   redis?: { host?: string, port?: number, password?: string },
+   *   queueName?: string,
+   *   nfeOptions?: ConstructorParameters<typeof NFeService>[0],
+   * }} [options]
+   */
+  constructor(options = {}) {
+    const redis = options.redis ?? { host: '127.0.0.1', port: 6379 };
+    const queueName = options.queueName ?? 'ghinfe:nfe:emissao';
+
+    this.queue = new Bull(queueName, { redis });
+    this.nfeService = new NFeService(options.nfeOptions ?? { mock: true });
+    this.#registerProcessor();
+  }
+
+  #registerProcessor() {
+    this.queue.process(async (job) => {
+      const { documento, certificado, idLote } = job.data;
+      const resultado = await this.nfeService.emitir(documento, certificado, idLote);
+      return resultado;
+    });
+  }
+
+  /**
+   * @param {{
+   *   documento: import('../nfe/types/NFeDocument.js').NFeDocument,
+   *   certificado: { pfx: Buffer|string, senha: string },
+   *   idLote?: string,
+   * }} payload
+   */
+  async adicionarEmissao(payload) {
+    return this.queue.add(payload, {
+      attempts: 3,
+      backoff: { type: 'exponential', delay: 5000 },
+      removeOnComplete: 100,
+      removeOnFail: 500,
+    });
+  }
+
+  /**
+   * Callback executado após emissão bem-sucedida (ex: salvar no Sequelize).
+   * @param {(resultado: Awaited<ReturnType<NFeService['emitir']>>, job: Bull.Job) => Promise<void>} handler
+   */
+  onCompleted(handler) {
+    this.queue.on('completed', async (job, resultado) => {
+      await handler(resultado, job);
+    });
+  }
+
+  /**
+   * @param {(error: Error, job: Bull.Job) => Promise<void>} handler
+   */
+  onFailed(handler) {
+    this.queue.on('failed', async (job, error) => {
+      await handler(error, job);
+    });
+  }
+
+  async close() {
+    await this.queue.close();
+  }
+}