evo360-types 1.3.732 → 1.3.736

package/dist/apps/evo-finops/nfse-reissue.d.ts

@@ -0,0 +1,54 @@
+import type { NfseReissueField, ServiceInvoiceState } from "../../types/evo-finops/invoices";
+/** Campos que a correção no lugar aceita (tomador e serviço municipal ⇒ caminho B). */
+export declare const NFSE_REISSUE_FIELDS: ReadonlyArray<NfseReissueField>;
+/**
+ * Por quanto tempo uma substituição `pending` trava novas reemissões da mesma origem.
+ * Passado esse prazo sem `done`, considera-se que a emissão anterior morreu e libera-se.
+ */
+export declare const NFSE_REPLACEMENT_PENDING_LOCK_MS: number;
+/** Recorte mínimo da nota que as regras precisam (aceita `IServiceInvoice` ou linha da lista). */
+export interface INfseReissueCheckInput {
+    state?: ServiceInvoiceState | string | null;
+    provider_invoice_id?: string | null;
+    deleted_at?: unknown;
+    replaced_by?: {
+        status?: "pending" | "done" | string | null;
+        requested_at?: unknown;
+    } | null;
+}
+/** Por que a nota não pode ser corrigida no lugar (`null` = pode). */
+export type NfseFixInPlaceBlockReason = "deleted" | "no_provider_id" | "replaced" | "not_error";
+/** Por que a nota não pode ser reemitida como nova (`null` = pode). */
+export type NfseReissueAsNewBlockReason = "deleted" | "already_replaced" | "replacement_pending" | "not_reissuable";
+/**
+ * Diz por que a NFS-e não pode ser corrigida no lugar ("Corrigir e reemitir"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `replaced` > `no_provider_id` > estado.
+ * - `replaced`: já existe `replaced_by` (qualquer status) — a origem foi (ou está sendo) substituída.
+ * - Só nota em `ERROR` é corrigível; qualquer outro estado (ou ausente) ⇒ `not_error`.
+ */
+export declare function nfseFixInPlaceBlockReason(inv: INfseReissueCheckInput | null | undefined): NfseFixInPlaceBlockReason | null;
+/** `true` quando a NFS-e em erro pode ser corrigida e reemitida no lugar. */
+export declare function isNfseFixableInPlace(inv: INfseReissueCheckInput | null | undefined): boolean;
+/**
+ * Converte uma data vinda do Firestore/JSON em milissegundos.
+ * Aceita `Date`, string ISO, número (ms), objeto com `toDate()` e Timestamp
+ * serializado (`{seconds}` ou `{_seconds}`, com `nanoseconds`/`_nanoseconds` opcionais).
+ * Retorna `null` quando não reconhece ou a data é inválida.
+ */
+export declare function nfseReissueDateToMillis(v: unknown): number | null;
+/**
+ * Diz por que a NFS-e não pode ser reemitida como nova ("Reemitir como nova"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `already_replaced` > `replacement_pending` > estado.
+ * - `already_replaced`: `replaced_by.status = done` (uma substituição por origem;
+ *   se a nova for cancelada, reemite-se a partir da nova).
+ * - `replacement_pending`: `replaced_by.status = pending` pedido há menos de
+ *   `NFSE_REPLACEMENT_PENDING_LOCK_MS`. Data ilegível conta como trava ativa (na dúvida, bloqueia).
+ * - Só `CANCELED` ou `ERROR` são reemitíveis; o resto ⇒ `not_reissuable`.
+ *
+ * @param now relógio injetável (ms ou `Date`); padrão `Date.now()`.
+ */
+export declare function nfseReissueAsNewBlockReason(inv: INfseReissueCheckInput | null | undefined, now?: number | Date): NfseReissueAsNewBlockReason | null;
+/** `true` quando a NFS-e pode ser reemitida como uma nota nova. */
+export declare function isNfseReissuableAsNew(inv: INfseReissueCheckInput | null | undefined, now?: number | Date): boolean;

package/dist/apps/evo-finops/nfse-reissue.js

@@ -0,0 +1,120 @@
+"use strict";
+// Regra única de reemissão de NFS-e (feat-292), usada pelo backend e pelo front-end.
+// Dois caminhos:
+// - A "Corrigir e reemitir": corrige no lugar uma nota em ERROR (PUT + authorize no Asaas).
+// - B "Reemitir como nova": emite uma nota nova a partir de uma CANCELED ou ERROR.
+// Runtime lib: es6 — sem dependências de Node e sem APIs posteriores ao target.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFSE_REPLACEMENT_PENDING_LOCK_MS = exports.NFSE_REISSUE_FIELDS = void 0;
+exports.nfseFixInPlaceBlockReason = nfseFixInPlaceBlockReason;
+exports.isNfseFixableInPlace = isNfseFixableInPlace;
+exports.nfseReissueDateToMillis = nfseReissueDateToMillis;
+exports.nfseReissueAsNewBlockReason = nfseReissueAsNewBlockReason;
+exports.isNfseReissuableAsNew = isNfseReissuableAsNew;
+/** Campos que a correção no lugar aceita (tomador e serviço municipal ⇒ caminho B). */
+exports.NFSE_REISSUE_FIELDS = [
+    "value",
+    "service_description",
+    "observations",
+    "deductions",
+    "taxes",
+];
+/**
+ * Por quanto tempo uma substituição `pending` trava novas reemissões da mesma origem.
+ * Passado esse prazo sem `done`, considera-se que a emissão anterior morreu e libera-se.
+ */
+exports.NFSE_REPLACEMENT_PENDING_LOCK_MS = 21 * 60 * 1000;
+/**
+ * Diz por que a NFS-e não pode ser corrigida no lugar ("Corrigir e reemitir"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `replaced` > `no_provider_id` > estado.
+ * - `replaced`: já existe `replaced_by` (qualquer status) — a origem foi (ou está sendo) substituída.
+ * - Só nota em `ERROR` é corrigível; qualquer outro estado (ou ausente) ⇒ `not_error`.
+ */
+function nfseFixInPlaceBlockReason(inv) {
+    if (!inv)
+        return "not_error";
+    if (inv.deleted_at)
+        return "deleted";
+    if (inv.replaced_by)
+        return "replaced";
+    if (!inv.provider_invoice_id)
+        return "no_provider_id";
+    return inv.state === "ERROR" ? null : "not_error";
+}
+/** `true` quando a NFS-e em erro pode ser corrigida e reemitida no lugar. */
+function isNfseFixableInPlace(inv) {
+    return nfseFixInPlaceBlockReason(inv) === null;
+}
+/**
+ * Converte uma data vinda do Firestore/JSON em milissegundos.
+ * Aceita `Date`, string ISO, número (ms), objeto com `toDate()` e Timestamp
+ * serializado (`{seconds}` ou `{_seconds}`, com `nanoseconds`/`_nanoseconds` opcionais).
+ * Retorna `null` quando não reconhece ou a data é inválida.
+ */
+function nfseReissueDateToMillis(v) {
+    if (v === null || v === undefined)
+        return null;
+    let ms = null;
+    if (v instanceof Date) {
+        ms = v.getTime();
+    }
+    else if (typeof v === "number") {
+        ms = v;
+    }
+    else if (typeof v === "string") {
+        ms = v.trim() ? Date.parse(v) : null;
+    }
+    else if (typeof v === "object") {
+        const o = v;
+        if (typeof o.toDate === "function") {
+            const d = o.toDate.call(v);
+            ms = d instanceof Date ? d.getTime() : null;
+        }
+        else {
+            const s = typeof o.seconds === "number" ? o.seconds : o._seconds;
+            const n = typeof o.nanoseconds === "number" ? o.nanoseconds : o._nanoseconds;
+            if (typeof s === "number") {
+                ms = s * 1000 + (typeof n === "number" ? Math.floor(n / 1e6) : 0);
+            }
+        }
+    }
+    return ms !== null && isFinite(ms) ? ms : null;
+}
+/**
+ * Diz por que a NFS-e não pode ser reemitida como nova ("Reemitir como nova"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `already_replaced` > `replacement_pending` > estado.
+ * - `already_replaced`: `replaced_by.status = done` (uma substituição por origem;
+ *   se a nova for cancelada, reemite-se a partir da nova).
+ * - `replacement_pending`: `replaced_by.status = pending` pedido há menos de
+ *   `NFSE_REPLACEMENT_PENDING_LOCK_MS`. Data ilegível conta como trava ativa (na dúvida, bloqueia).
+ * - Só `CANCELED` ou `ERROR` são reemitíveis; o resto ⇒ `not_reissuable`.
+ *
+ * @param now relógio injetável (ms ou `Date`); padrão `Date.now()`.
+ */
+function nfseReissueAsNewBlockReason(inv, now) {
+    if (!inv)
+        return "not_reissuable";
+    if (inv.deleted_at)
+        return "deleted";
+    const rb = inv.replaced_by;
+    if (rb) {
+        if (rb.status === "done")
+            return "already_replaced";
+        if (rb.status === "pending") {
+            const at = nfseReissueDateToMillis(rb.requested_at);
+            const nowMs = now === undefined ? Date.now() : now instanceof Date ? now.getTime() : now;
+            if (at === null || nowMs - at < exports.NFSE_REPLACEMENT_PENDING_LOCK_MS) {
+                return "replacement_pending";
+            }
+        }
+    }
+    return inv.state === "CANCELED" || inv.state === "ERROR"
+        ? null
+        : "not_reissuable";
+}
+/** `true` quando a NFS-e pode ser reemitida como uma nota nova. */
+function isNfseReissuableAsNew(inv, now) {
+    return nfseReissueAsNewBlockReason(inv, now) === null;
+}

package/dist/apps/evo-finops/nfse-reissue.ts

@@ -0,0 +1,156 @@
+// Regra única de reemissão de NFS-e (feat-292), usada pelo backend e pelo front-end.
+// Dois caminhos:
+// - A "Corrigir e reemitir": corrige no lugar uma nota em ERROR (PUT + authorize no Asaas).
+// - B "Reemitir como nova": emite uma nota nova a partir de uma CANCELED ou ERROR.
+// Runtime lib: es6 — sem dependências de Node e sem APIs posteriores ao target.
+
+import type {
+  NfseReissueField,
+  ServiceInvoiceState,
+} from "../../types/evo-finops/invoices";
+
+/** Campos que a correção no lugar aceita (tomador e serviço municipal ⇒ caminho B). */
+export const NFSE_REISSUE_FIELDS: ReadonlyArray<NfseReissueField> = [
+  "value",
+  "service_description",
+  "observations",
+  "deductions",
+  "taxes",
+];
+
+/**
+ * Por quanto tempo uma substituição `pending` trava novas reemissões da mesma origem.
+ * Passado esse prazo sem `done`, considera-se que a emissão anterior morreu e libera-se.
+ */
+export const NFSE_REPLACEMENT_PENDING_LOCK_MS = 21 * 60 * 1000;
+
+/** Recorte mínimo da nota que as regras precisam (aceita `IServiceInvoice` ou linha da lista). */
+export interface INfseReissueCheckInput {
+  state?: ServiceInvoiceState | string | null;
+  provider_invoice_id?: string | null;
+  deleted_at?: unknown;
+  replaced_by?: {
+    status?: "pending" | "done" | string | null;
+    requested_at?: unknown;
+  } | null;
+}
+
+/** Por que a nota não pode ser corrigida no lugar (`null` = pode). */
+export type NfseFixInPlaceBlockReason =
+  | "deleted"
+  | "no_provider_id"
+  | "replaced"
+  | "not_error";
+
+/** Por que a nota não pode ser reemitida como nova (`null` = pode). */
+export type NfseReissueAsNewBlockReason =
+  | "deleted"
+  | "already_replaced"
+  | "replacement_pending"
+  | "not_reissuable";
+
+/**
+ * Diz por que a NFS-e não pode ser corrigida no lugar ("Corrigir e reemitir"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `replaced` > `no_provider_id` > estado.
+ * - `replaced`: já existe `replaced_by` (qualquer status) — a origem foi (ou está sendo) substituída.
+ * - Só nota em `ERROR` é corrigível; qualquer outro estado (ou ausente) ⇒ `not_error`.
+ */
+export function nfseFixInPlaceBlockReason(
+  inv: INfseReissueCheckInput | null | undefined,
+): NfseFixInPlaceBlockReason | null {
+  if (!inv) return "not_error";
+  if (inv.deleted_at) return "deleted";
+  if (inv.replaced_by) return "replaced";
+  if (!inv.provider_invoice_id) return "no_provider_id";
+  return inv.state === "ERROR" ? null : "not_error";
+}
+
+/** `true` quando a NFS-e em erro pode ser corrigida e reemitida no lugar. */
+export function isNfseFixableInPlace(
+  inv: INfseReissueCheckInput | null | undefined,
+): boolean {
+  return nfseFixInPlaceBlockReason(inv) === null;
+}
+
+/**
+ * Converte uma data vinda do Firestore/JSON em milissegundos.
+ * Aceita `Date`, string ISO, número (ms), objeto com `toDate()` e Timestamp
+ * serializado (`{seconds}` ou `{_seconds}`, com `nanoseconds`/`_nanoseconds` opcionais).
+ * Retorna `null` quando não reconhece ou a data é inválida.
+ */
+export function nfseReissueDateToMillis(v: unknown): number | null {
+  if (v === null || v === undefined) return null;
+  let ms: number | null = null;
+  if (v instanceof Date) {
+    ms = v.getTime();
+  } else if (typeof v === "number") {
+    ms = v;
+  } else if (typeof v === "string") {
+    ms = v.trim() ? Date.parse(v) : null;
+  } else if (typeof v === "object") {
+    const o = v as {
+      toDate?: unknown;
+      seconds?: unknown;
+      _seconds?: unknown;
+      nanoseconds?: unknown;
+      _nanoseconds?: unknown;
+    };
+    if (typeof o.toDate === "function") {
+      const d = (o.toDate as () => unknown).call(v);
+      ms = d instanceof Date ? d.getTime() : null;
+    } else {
+      const s = typeof o.seconds === "number" ? o.seconds : o._seconds;
+      const n = typeof o.nanoseconds === "number" ? o.nanoseconds : o._nanoseconds;
+      if (typeof s === "number") {
+        ms = s * 1000 + (typeof n === "number" ? Math.floor(n / 1e6) : 0);
+      }
+    }
+  }
+  return ms !== null && isFinite(ms) ? ms : null;
+}
+
+/**
+ * Diz por que a NFS-e não pode ser reemitida como nova ("Reemitir como nova"), ou `null` se pode.
+ *
+ * Precedência: `deleted` > `already_replaced` > `replacement_pending` > estado.
+ * - `already_replaced`: `replaced_by.status = done` (uma substituição por origem;
+ *   se a nova for cancelada, reemite-se a partir da nova).
+ * - `replacement_pending`: `replaced_by.status = pending` pedido há menos de
+ *   `NFSE_REPLACEMENT_PENDING_LOCK_MS`. Data ilegível conta como trava ativa (na dúvida, bloqueia).
+ * - Só `CANCELED` ou `ERROR` são reemitíveis; o resto ⇒ `not_reissuable`.
+ *
+ * @param now relógio injetável (ms ou `Date`); padrão `Date.now()`.
+ */
+export function nfseReissueAsNewBlockReason(
+  inv: INfseReissueCheckInput | null | undefined,
+  now?: number | Date,
+): NfseReissueAsNewBlockReason | null {
+  if (!inv) return "not_reissuable";
+  if (inv.deleted_at) return "deleted";
+
+  const rb = inv.replaced_by;
+  if (rb) {
+    if (rb.status === "done") return "already_replaced";
+    if (rb.status === "pending") {
+      const at = nfseReissueDateToMillis(rb.requested_at);
+      const nowMs =
+        now === undefined ? Date.now() : now instanceof Date ? now.getTime() : now;
+      if (at === null || nowMs - at < NFSE_REPLACEMENT_PENDING_LOCK_MS) {
+        return "replacement_pending";
+      }
+    }
+  }
+
+  return inv.state === "CANCELED" || inv.state === "ERROR"
+    ? null
+    : "not_reissuable";
+}
+
+/** `true` quando a NFS-e pode ser reemitida como uma nota nova. */
+export function isNfseReissuableAsNew(
+  inv: INfseReissueCheckInput | null | undefined,
+  now?: number | Date,
+): boolean {
+  return nfseReissueAsNewBlockReason(inv, now) === null;
+}