facturas 0.9.0 → 0.11.0

package/bin/facturas.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "../dist/cli.mjs";
+
+await main(process.argv.slice(2));

package/dist/{chunk-RCM4NAAG.mjs → chunk-5KCTRQJX.mjs}

@@ -1,15 +1,12 @@
 import {
-  ARCA_CURRENCY_IDS,
-  ARCA_VAT_RATES,
-  ARCA_VOUCHER_TYPES
-} from "./chunk-76WU5BVI.mjs";
+  ARCA_VAT_RATES
+} from "./chunk-GX5ERXT6.mjs";
 import {
   classifyArcaAuthenticationError,
   classifyArcaAuthenticationIssues,
-  createArcaAuthenticationErrorFromEvidence,
   createArcaAuthenticationEvidence,
   executeWithAuthenticationRecovery
-} from "./chunk-4QVFXT35.mjs";
+} from "./chunk-UDX6HLAU.mjs";
 import {
   ArcaInputError,
   ArcaInvalidSoapResponseError,
@@ -297,20 +294,6 @@ function createWsfeService(options) {
     });
     return getWsfeResultEntries(result, resultKey).map(mapWsfeCatalogEntry);
   }
-  function authorizeVoucher({
-    representedTaxId,
-    data,
-    voucherNumber,
-    forceRefresh
-  }) {
-    const normalizedInput = normalizeWsfeVoucherInput(data);
-    return authorizeNormalizedVoucher({
-      representedTaxId,
-      data: normalizedInput,
-      voucherNumber,
-      forceRefresh
-    });
-  }
   function issue({
     representedTaxId,
     data,
@@ -325,66 +308,6 @@ function createWsfeService(options) {
       forceRefresh
     }).then(({ outcome }) => outcome);
   }
-  function authorizeNormalizedVoucher({
-    representedTaxId,
-    data: normalizedInput,
-    voucherNumber,
-    forceRefresh,
-    allowAuthenticationRecovery
-  }) {
-    return executeWithAuthenticationRecovery({
-      service: "wsfe",
-      operation: "FECAESolicitar",
-      forceRefresh,
-      allowRetry: allowAuthenticationRecovery,
-      execute: (attemptForceRefresh) => authorizeNormalizedVoucherOnce({
-        representedTaxId,
-        data: normalizedInput,
-        voucherNumber,
-        forceRefresh: attemptForceRefresh
-      })
-    });
-  }
-  async function authorizeNormalizedVoucherOnce({
-    representedTaxId,
-    data: normalizedInput,
-    voucherNumber,
-    forceRefresh
-  }) {
-    const execution = await executeWsfeAuthorization({
-      representedTaxId,
-      data: normalizedInput,
-      voucherNumber,
-      forceRefresh
-    });
-    if (execution.error) {
-      throw execution.error;
-    }
-    if (execution.outcome.kind !== "authorized") {
-      throw createWsfeOutcomeError(execution.outcome);
-    }
-    const { cae, caeExpiry, raw } = execution.outcome;
-    if (!(caeExpiry && raw)) {
-      throw new ArcaServiceError("WSFE did not return CAE authorization data", {
-        service: "wsfe",
-        operation: "FECAESolicitar",
-        result: execution.outcome.result,
-        resultLevel: execution.outcome.resultLevel,
-        results: execution.outcome.results,
-        cae,
-        issues: [
-          ...execution.outcome.errors,
-          ...execution.outcome.observations
-        ]
-      });
-    }
-    return {
-      cae,
-      caeExpiry,
-      voucherNumber,
-      raw
-    };
-  }
   async function executeWsfeAuthorization({
     representedTaxId,
     data: normalizedInput,
@@ -491,35 +414,30 @@ function createWsfeService(options) {
   }
   return {
     issue,
-    authorizeVoucherOutcome: issue,
-    authorizeVoucher,
-    async createNextVoucher({ representedTaxId, data, forceRefresh }) {
-      const normalizedInput = normalizeWsfeVoucherInput(data);
-      const voucherNumber = await getNextVoucherNumber({
-        representedTaxId,
-        salesPoint: normalizedInput.salesPoint,
-        voucherType: normalizedInput.voucherType,
-        forceRefresh
-      });
-      return authorizeNormalizedVoucher({
-        representedTaxId,
-        data: normalizedInput,
-        voucherNumber,
-        allowAuthenticationRecovery: forceRefresh !== true
-      });
-    },
     getNextVoucherNumber,
     getLastVoucher(input) {
       return getNextVoucherNumber(input);
     },
     async getSalesPoints({ representedTaxId, forceRefresh }) {
-      const result = await executeWsfeAuthenticatedOperation(
-        "FEParamGetPtosVenta",
-        {
-          representedTaxId,
-          forceRefresh
+      const operation = "FEParamGetPtosVenta";
+      const result = await executeWithAuthenticationRecovery({
+        service: "wsfe",
+        operation,
+        forceRefresh,
+        async execute(attemptForceRefresh) {
+          const raw = await executeWsfeAuthenticatedRawOperation(
+            operation,
+            { representedTaxId, forceRefresh: attemptForceRefresh },
+            {}
+          );
+          const errors = extractWsfeGlobalIssues(raw, operation);
+          if (errors.length > 0 && errors.every((issue2) => issue2.code === "602")) {
+            return {};
+          }
+          throwForWsfeOperationErrors(operation, raw);
+          return raw;
         }
-      );
+      });
       const rawPoints = result.ResultGet?.PtoVenta;
       if (!rawPoints) {
         return [];
@@ -925,7 +843,25 @@ function normalizeAndValidateWsfeAmounts(input) {
   };
 }
 function requiresWsfeVatBaseReconciliation(voucherType) {
-  return ![2, 3, 7, 8, 11, 12, 13, 15, 52, 53].includes(voucherType);
+  return ![
+    2,
+    3,
+    7,
+    8,
+    11,
+    12,
+    13,
+    15,
+    52,
+    53,
+    202,
+    203,
+    207,
+    208,
+    211,
+    212,
+    213
+  ].includes(voucherType);
 }
 function assertWsfeAmountMatch(actual, expectedAmount, field, expectedDescription, absoluteCentAllowance = 1) {
   if (!isWithinArcaTolerance(actual, expectedAmount, absoluteCentAllowance)) {
@@ -1150,10 +1086,42 @@ function mapWsfeVoucherInfo(raw) {
         type,
         salesPoint,
         number,
+        ...normalizeWsfeString(item.Cuit) ? { taxId: normalizeWsfeString(item.Cuit) } : {},
         ...normalizeWsfeString(item.CbteFch) ? { voucherDate: normalizeWsfeString(item.CbteFch) } : {}
       };
     })
   );
+  const period = toWsfeRecord(raw.PeriodoAsoc);
+  if (period?.FchDesde && period.FchHasta) {
+    voucher.associatedPeriod = {
+      startDate: String(period.FchDesde),
+      endDate: String(period.FchHasta)
+    };
+  }
+  if (raw.CanMisMonExt === "S" || raw.CanMisMonExt === "N") {
+    voucher.sameCurrencyForeignCancellation = raw.CanMisMonExt;
+  }
+  voucher.optionalFields = mapWsfeLookupDetails(
+    raw.Opcionales,
+    "Opcional",
+    (item) => item.Id === void 0 || item.Valor === void 0 ? void 0 : { id: String(item.Id), value: String(item.Valor) }
+  );
+  voucher.buyers = mapWsfeLookupDetails(
+    raw.Compradores,
+    "Comprador",
+    (item) => {
+      const documentType = normalizeWsfeNumber(item.DocTipo), documentNumber = normalizeWsfeNumber(item.DocNro), percentage = normalizeWsfeNumber(item.Porcentaje);
+      return documentType === void 0 || documentNumber === void 0 || percentage === void 0 ? void 0 : { documentType, documentNumber, percentage };
+    }
+  );
+  voucher.activities = mapWsfeLookupDetails(
+    raw.Actividades,
+    "Actividad",
+    (item) => {
+      const id = normalizeWsfeNumber(item.Id);
+      return id === void 0 ? void 0 : { id };
+    }
+  );
   return voucher;
 }
 function mapWsfeLookupDetails(container, key, map) {
@@ -1377,27 +1345,6 @@ function getArcaIndeterminateReason(error) {
   }
   return "unexpected_error";
 }
-function createWsfeOutcomeError(outcome) {
-  if (outcome.kind === "indeterminate" && outcome.authentication) {
-    return createArcaAuthenticationErrorFromEvidence(outcome.authentication, {
-      service: "wsfe",
-      operation: outcome.operation
-    });
-  }
-  const issues = [...outcome.errors, ...outcome.observations];
-  const firstIssue = issues[0];
-  const message = firstIssue ? formatWsfeIssue(firstIssue) : outcome.kind === "rejected" ? "WSFE rejected the voucher authorization" : outcome.result === "A" ? "WSFE did not return CAE authorization data" : "WSFE did not return conclusive voucher authorization data";
-  return new ArcaServiceError(message, {
-    service: "wsfe",
-    operation: outcome.operation,
-    ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
-    ...outcome.result === void 0 ? {} : { result: outcome.result },
-    ...outcome.resultLevel === void 0 ? {} : { resultLevel: outcome.resultLevel },
-    results: outcome.results,
-    ...outcome.kind === "indeterminate" && outcome.cae ? { cae: outcome.cae } : {},
-    issues
-  });
-}
 function createWsfeServiceError(operation, issues) {
   const authenticationError = classifyArcaAuthenticationIssues(issues, {
     service: "wsfe",
@@ -1514,9 +1461,9 @@ function calculateWsfeAmounts(input) {
   if (!Array.isArray(input.items) || input.items.length === 0) {
     invalidItem("items", "a non-empty array of items");
   }
-  const isVat = input.issuer === "responsable_inscripto";
-  if (!(isVat || ["monotributo", "exento", "no_alcanzado"].includes(input.issuer))) {
-    invalidItem("issuer", "a supported issuer condition");
+  const isVat = input.voucherClass === "A" || input.voucherClass === "B";
+  if (!(isVat || input.voucherClass === "C")) {
+    invalidItem("voucherClass", "A, B or C");
   }
   const totals = collectItems(input.items, isVat);
   let net = totals.net;
@@ -1605,7 +1552,7 @@ function collectItems(items, isVat) {
 }
 function classCAmount(item, path) {
   if ("vat" in item || "net" in item || "gross" in item) {
-    invalidItem("items", "amount items for a non-RI issuer");
+    invalidItem("items", "amount items for a class C voucher");
   }
   return assertArcaMinorUnits(item.amount, `${path}.amount`);
 }
@@ -1613,7 +1560,7 @@ function vatItemAmount(item, path) {
   if ("amount" in item || "net" in item === "gross" in item) {
     invalidItem(
       "items",
-      "exactly one of net or gross, and vat, for an RI issuer"
+      "exactly one of net or gross, and vat, for a class A or B voucher"
     );
   }
   const field = "net" in item ? "net" : "gross";
@@ -1635,164 +1582,16 @@ function invalidItem(field, expected) {
   });
 }
 
-// src/services/wsfe-builders.ts
-function buildFacturaB(input) {
-  const taxableMinorUnits = assertArcaMinorUnits(
-    input.taxableAmount,
-    "taxableAmount"
-  );
-  if (taxableMinorUnits === 0n) {
-    throw new ArcaInputError(
-      "taxableAmount must be greater than zero for Factura B.",
-      {
-        code: "ARCA_INPUT_INVALID_AMOUNT",
-        field: "taxableAmount",
-        expected: "a positive safe integer in currency minor units"
-      }
-    );
-  }
-  const vatMinorUnits = calculateVatMinorUnits(
-    taxableMinorUnits,
-    input.vatRate,
-    "vatRate"
-  );
-  if (input.vatRate !== 0 && vatMinorUnits === 0n) {
-    throw new ArcaInputError(
-      "taxableAmount is too small to produce VAT at the selected positive vatRate.",
-      {
-        code: "ARCA_INPUT_INVALID_AMOUNT",
-        field: "taxableAmount",
-        expected: "an amount that rounds to at least one currency minor unit of VAT for a positive vatRate"
-      }
-    );
-  }
-  const { data } = calculateWsfeAmounts({
-    issuer: "responsable_inscripto",
-    items: [{ net: input.taxableAmount, vat: input.vatRate }]
-  });
-  for (const rate of data.vatRates ?? []) {
-    Object.freeze(rate);
-  }
-  Object.freeze(data.vatRates);
-  return Object.freeze({
-    ...buildCommonExactInput(input),
-    voucherType: ARCA_VOUCHER_TYPES.FACTURA_B,
-    ...data
-  });
-}
-function buildFacturaC(input) {
-  assertArcaMinorUnits(input.amount, "amount");
-  const { data } = calculateWsfeAmounts({
-    issuer: "monotributo",
-    items: [{ amount: input.amount }]
-  });
-  return Object.freeze({
-    ...buildCommonExactInput(input),
-    voucherType: ARCA_VOUCHER_TYPES.FACTURA_C,
-    ...data
-  });
-}
-function buildCommonExactInput(input) {
-  return {
-    salesPoint: input.salesPoint,
-    concept: input.concept,
-    documentType: input.documentType,
-    documentNumber: input.documentNumber,
-    receiverVatConditionId: input.receiverVatConditionId,
-    voucherDate: input.voucherDate,
-    ...normalizeBuilderCurrency(input),
-    ...input.serviceStartDate === void 0 ? {} : { serviceStartDate: input.serviceStartDate },
-    ...input.serviceEndDate === void 0 ? {} : { serviceEndDate: input.serviceEndDate },
-    ...input.paymentDueDate === void 0 ? {} : { paymentDueDate: input.paymentDueDate }
-  };
-}
-function normalizeBuilderCurrency(input) {
-  const unsafeInput = input;
-  const currency = unsafeInput.currency ?? "ARS";
-  if (unsafeInput.sameCurrencyForeignCancellation !== void 0 && typeof unsafeInput.sameCurrencyForeignCancellation !== "boolean") {
-    throw new ArcaInputError(
-      "sameCurrencyForeignCancellation must be a boolean when provided.",
-      {
-        code: "ARCA_INPUT_INVALID_VALUE",
-        field: "sameCurrencyForeignCancellation",
-        expected: "true, false, or omitted"
-      }
-    );
-  }
-  if (currency === "ARS") {
-    if (unsafeInput.exchangeRate !== void 0) {
-      throw new ArcaInputError(
-        "exchangeRate must be omitted when currency is ARS.",
-        {
-          code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
-          field: "exchangeRate",
-          expected: "omitted when currency is ARS"
-        }
-      );
-    }
-    if (unsafeInput.sameCurrencyForeignCancellation !== void 0) {
-      throw new ArcaInputError(
-        "sameCurrencyForeignCancellation applies only when currency is USD.",
-        {
-          code: "ARCA_INPUT_INVALID_VALUE",
-          field: "sameCurrencyForeignCancellation",
-          expected: "omitted when currency is ARS"
-        }
-      );
-    }
-    return {
-      currencyId: ARCA_CURRENCY_IDS.ARS,
-      exchangeRate: "1"
-    };
-  }
-  if (currency !== "USD") {
-    throw new ArcaInputError("currency is not supported by this builder.", {
-      code: "ARCA_INPUT_INVALID_VALUE",
-      field: "currency",
-      expected: "ARS or USD"
-    });
-  }
-  if (unsafeInput.sameCurrencyForeignCancellation === true) {
-    if (unsafeInput.exchangeRate !== void 0) {
-      throw new ArcaInputError(
-        "exchangeRate must be omitted for same-currency foreign cancellation.",
-        {
-          code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
-          field: "exchangeRate",
-          expected: "omitted when sameCurrencyForeignCancellation is true"
-        }
-      );
-    }
-    return {
-      currencyId: ARCA_CURRENCY_IDS.USD,
-      sameCurrencyForeignCancellation: "S"
-    };
-  }
-  if (typeof unsafeInput.exchangeRate !== "string") {
-    throw new ArcaInputError("exchangeRate is required for USD invoices.", {
-      code: "ARCA_INPUT_MISSING_FIELD",
-      field: "exchangeRate",
-      expected: "a decimal string unless sameCurrencyForeignCancellation is true"
-    });
-  }
-  return {
-    currencyId: ARCA_CURRENCY_IDS.USD,
-    exchangeRate: serializeArcaExchangeRate(
-      unsafeInput.exchangeRate,
-      "exchangeRate"
-    ),
-    ...unsafeInput.sameCurrencyForeignCancellation === false ? { sameCurrencyForeignCancellation: "N" } : {}
-  };
-}
-
 export {
   normalizeArcaAmountToMinorUnits,
   serializeArcaExchangeRate,
+  assertArcaMinorUnits,
+  arcaMinorUnitsToNumber,
+  calculateVatMinorUnits,
+  isWithinArcaTolerance,
   createWsfeService,
   normalizeWsfeVoucherInput,
   normalizeWsfeDateInput,
-  calculateWsfeAmounts,
-  buildFacturaB,
-  buildFacturaC
+  calculateWsfeAmounts
 };
-//# sourceMappingURL=chunk-RCM4NAAG.mjs.map
+//# sourceMappingURL=chunk-5KCTRQJX.mjs.map