facturas 0.5.2 → 0.6.0

package/dist/wsfe.mjs

@@ -15,20 +15,78 @@ var ArcaInputError = class extends ArcaError {
     this.detail = options?.detail;
   }
 };
+var ArcaTransportError = class extends ArcaError {
+  name = "ArcaTransportError";
+  statusCode;
+  contentType;
+  responseBody;
+  constructor(message, options) {
+    super(message, "ARCA_TRANSPORT_ERROR", options);
+    this.statusCode = options?.statusCode;
+    this.contentType = options?.contentType;
+    this.responseBody = options?.responseBody;
+  }
+};
+var ArcaSoapFaultError = class extends ArcaError {
+  name = "ArcaSoapFaultError";
+  faultCode;
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_SOAP_FAULT", options);
+    this.faultCode = options?.faultCode;
+    this.detail = options?.detail;
+  }
+};
+var ArcaInvalidSoapResponseError = class extends ArcaError {
+  name = "ArcaInvalidSoapResponseError";
+  service;
+  operation;
+  endpointUrl;
+  statusCode;
+  contentType;
+  responseBodyLength;
+  responseBodyPreview;
+  parsedDetail;
+  constructor(message, options) {
+    super(message, "ARCA_INVALID_SOAP_RESPONSE", options);
+    this.service = options?.service;
+    this.operation = options?.operation;
+    this.endpointUrl = options?.endpointUrl;
+    this.statusCode = options?.statusCode;
+    this.contentType = options?.contentType;
+    this.responseBodyLength = options?.responseBodyLength;
+    this.responseBodyPreview = options?.responseBodyPreview;
+    this.parsedDetail = options?.parsedDetail;
+  }
+};
 var ArcaServiceError = class extends ArcaError {
   name = "ArcaServiceError";
   serviceCode;
+  service;
+  operation;
+  result;
+  resultLevel;
+  results;
+  cae;
+  issues;
   detail;
   constructor(message, options) {
     super(message, "ARCA_SERVICE_ERROR", options);
     this.serviceCode = options?.serviceCode;
+    this.service = options?.service;
+    this.operation = options?.operation;
+    this.result = options?.result;
+    this.resultLevel = options?.resultLevel;
+    this.results = options?.results;
+    this.cae = options?.cae;
+    this.issues = options?.issues;
     this.detail = options?.detail;
   }
 };
 
 // src/services/wsfe.ts
 function createWsfeService(options) {
-  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+  async function executeWsfeAuthenticatedRawOperation(operation, input, body = {}, retries) {
     const auth = await options.auth.login("wsfe", {
       representedTaxId: input.representedTaxId,
       forceRefresh: input.forceRefresh
@@ -36,6 +94,7 @@ function createWsfeService(options) {
     const response = await options.soap.execute({
       service: "wsfe",
       operation,
+      ...retries === void 0 ? {} : { retries },
       body: {
         Auth: createWsfeAuth(
           input.representedTaxId ?? options.config.taxId,
@@ -45,7 +104,16 @@ function createWsfeService(options) {
         ...body
       }
     });
-    return unwrapWsfeOperationResult(operation, response.result);
+    return unwrapWsfeOperationEnvelope(operation, response.result);
+  }
+  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+    const result = await executeWsfeAuthenticatedRawOperation(
+      operation,
+      input,
+      body
+    );
+    throwForWsfeOperationErrors(operation, result);
+    return result;
   }
   async function executeWsfeOperation(operation, body = {}) {
     const response = await options.soap.execute({
@@ -53,7 +121,9 @@ function createWsfeService(options) {
       operation,
       body
     });
-    return unwrapWsfeOperationResult(operation, response.result);
+    const result = unwrapWsfeOperationEnvelope(operation, response.result);
+    throwForWsfeOperationErrors(operation, result);
+    return result;
   }
   async function getNextVoucherNumber({
     representedTaxId,
@@ -95,55 +165,148 @@ function createWsfeService(options) {
       forceRefresh
     });
   }
+  function authorizeVoucherOutcome({
+    representedTaxId,
+    data,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const normalizedInput = normalizeWsfeVoucherInput(data);
+    return executeWsfeAuthorization({
+      representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
+      forceRefresh
+    }).then(({ outcome }) => outcome);
+  }
   async function authorizeNormalizedVoucher({
     representedTaxId,
     data: normalizedInput,
     voucherNumber,
     forceRefresh
   }) {
-    const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
-    const auth = await options.auth.login("wsfe", {
+    const execution = await executeWsfeAuthorization({
       representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
       forceRefresh
     });
-    const response = await options.soap.execute({
-      service: "wsfe",
-      operation: "FECAESolicitar",
-      body: {
-        Auth: createWsfeAuth(
-          representedTaxId ?? options.config.taxId,
-          auth.token,
-          auth.sign
-        ),
-        FeCAEReq: {
-          FeCabReq: {
-            CantReg: 1,
-            PtoVta: normalizedInput.salesPoint,
-            CbteTipo: normalizedInput.voucherType
-          },
-          FeDetReq: {
-            FECAEDetRequest: requestData
+    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
+        ],
+        detail: raw
+      });
+    }
+    return {
+      cae,
+      caeExpiry,
+      voucherNumber,
+      raw
+    };
+  }
+  async function executeWsfeAuthorization({
+    representedTaxId,
+    data: normalizedInput,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
+    try {
+      const result = await executeWsfeAuthenticatedRawOperation(
+        "FECAESolicitar",
+        { representedTaxId, forceRefresh },
+        {
+          FeCAEReq: {
+            FeCabReq: {
+              CantReg: 1,
+              PtoVta: normalizedInput.salesPoint,
+              CbteTipo: normalizedInput.voucherType
+            },
+            FeDetReq: {
+              FECAEDetRequest: requestData
+            }
           }
+        },
+        0
+      );
+      return {
+        outcome: classifyWsfeAuthorization(result, voucherNumber)
+      };
+    } catch (error) {
+      return {
+        outcome: createWsfeIndeterminateOutcome(error),
+        error
+      };
+    }
+  }
+  async function lookupVoucher({
+    representedTaxId,
+    number,
+    salesPoint,
+    voucherType,
+    forceRefresh
+  }) {
+    const operation = "FECompConsultar";
+    const result = await executeWsfeAuthenticatedRawOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        FeCompConsReq: {
+          CbteNro: number,
+          PtoVta: salesPoint,
+          CbteTipo: voucherType
         }
       }
-    });
-    const result = unwrapWsfeOperationResult("FECAESolicitar", response.result);
-    const detailResponse = normalizeWsfeDetailResponse(result);
-    const cae = detailResponse.CAE;
-    const caeExpiry = detailResponse.CAEFchVto;
-    if (typeof cae !== "string" || typeof caeExpiry !== "string") {
-      throw new ArcaServiceError("WSFE did not return CAE authorization data", {
+    );
+    const errors = extractWsfeGlobalIssues(result, operation);
+    if (errors.length > 0 && errors.every((issue) => issue.code === "602")) {
+      return {
+        kind: "not_found",
+        service: "wsfe",
+        operation,
+        errors,
+        observations: [],
+        raw: result
+      };
+    }
+    if (errors.length > 0) {
+      throw createWsfeServiceError(operation, result, errors);
+    }
+    const raw = toWsfeRecord(result.ResultGet);
+    if (!raw) {
+      throw new ArcaServiceError("WSFE did not return the consulted voucher", {
+        service: "wsfe",
+        operation,
         detail: result
       });
     }
     return {
-      cae,
-      caeExpiry: String(caeExpiry),
-      voucherNumber,
+      kind: "found",
+      service: "wsfe",
+      operation,
+      voucher: mapWsfeVoucherInfo(raw),
+      observations: [],
       raw: result
     };
   }
   return {
+    authorizeVoucherOutcome,
     authorizeVoucher,
     async createNextVoucher({ representedTaxId, data, forceRefresh }) {
       const normalizedInput = normalizeWsfeVoucherInput(data);
@@ -255,33 +418,11 @@ function createWsfeService(options) {
       const raw = result.ResultGet ?? {};
       return mapWsfeQuotation(raw);
     },
-    async getVoucherInfo({
-      representedTaxId,
-      number,
-      salesPoint,
-      voucherType,
-      forceRefresh
-    }) {
-      const result = await executeWsfeAuthenticatedOperation(
-        "FECompConsultar",
-        {
-          representedTaxId,
-          forceRefresh
-        },
-        {
-          FeCompConsReq: {
-            CbteNro: number,
-            PtoVta: salesPoint,
-            CbteTipo: voucherType
-          }
-        }
-      );
-      const raw = result.ResultGet ?? null;
-      if (!raw) {
-        return null;
-      }
-      return mapWsfeVoucherInfo(raw);
-    }
+    async getVoucherInfo(input) {
+      const lookup = await lookupVoucher(input);
+      return lookup.kind === "found" ? lookup.voucher : null;
+    },
+    lookupVoucher
   };
 }
 function mapWsfeVoucherInput(input, voucherNumber) {
@@ -547,17 +688,45 @@ function mapWsfeQuotation(raw) {
   };
 }
 function mapWsfeVoucherInfo(raw) {
-  return {
+  const voucher = {
     voucherNumber: Number(raw.CbteDesde ?? raw.CbteHasta ?? 0),
-    ...raw.CbteFch === void 0 ? {} : { voucherDate: String(raw.CbteFch) },
-    ...raw.PtoVta === void 0 ? {} : { salesPoint: Number(raw.PtoVta) },
-    ...raw.CbteTipo === void 0 ? {} : { voucherType: Number(raw.CbteTipo) },
-    ...raw.ImpTotal === void 0 ? {} : { totalAmount: Number(raw.ImpTotal) },
-    ...raw.Resultado === void 0 ? {} : { result: String(raw.Resultado) },
-    ...raw.CAE === void 0 ? {} : { cae: String(raw.CAE) },
-    ...raw.CAEFchVto === void 0 ? {} : { caeExpiry: String(raw.CAEFchVto) },
     raw
   };
+  assignWsfeValue(voucher, "voucherDate", normalizeWsfeString(raw.CbteFch));
+  assignWsfeValue(voucher, "salesPoint", normalizeWsfeNumber(raw.PtoVta));
+  assignWsfeValue(voucher, "voucherType", normalizeWsfeNumber(raw.CbteTipo));
+  assignWsfeValue(voucher, "concept", normalizeWsfeNumber(raw.Concepto));
+  assignWsfeValue(voucher, "documentType", normalizeWsfeNumber(raw.DocTipo));
+  assignWsfeValue(voucher, "documentNumber", normalizeWsfeString(raw.DocNro));
+  assignWsfeValue(
+    voucher,
+    "receiverVatConditionId",
+    normalizeWsfeNumber(raw.CondicionIVAReceptorId)
+  );
+  assignWsfeValue(voucher, "totalAmount", normalizeWsfeNumber(raw.ImpTotal));
+  assignWsfeValue(
+    voucher,
+    "nonTaxableAmount",
+    normalizeWsfeNumber(raw.ImpTotConc)
+  );
+  assignWsfeValue(voucher, "netAmount", normalizeWsfeNumber(raw.ImpNeto));
+  assignWsfeValue(voucher, "exemptAmount", normalizeWsfeNumber(raw.ImpOpEx));
+  assignWsfeValue(voucher, "taxAmount", normalizeWsfeNumber(raw.ImpTrib));
+  assignWsfeValue(voucher, "vatAmount", normalizeWsfeNumber(raw.ImpIVA));
+  assignWsfeValue(voucher, "currencyId", normalizeWsfeString(raw.MonId));
+  assignWsfeValue(voucher, "exchangeRate", normalizeWsfeNumber(raw.MonCotiz));
+  assignWsfeValue(voucher, "result", normalizeWsfeString(raw.Resultado));
+  assignWsfeValue(
+    voucher,
+    "cae",
+    normalizeWsfeString(raw.CodAutorizacion ?? raw.CAE)
+  );
+  assignWsfeValue(
+    voucher,
+    "caeExpiry",
+    normalizeWsfeString(raw.FchVto ?? raw.CAEFchVto)
+  );
+  return voucher;
 }
 function createWsfeAuth(representedTaxId, token, sign) {
   return {
@@ -566,47 +735,16 @@ function createWsfeAuth(representedTaxId, token, sign) {
     Cuit: Number.parseInt(String(representedTaxId), 10)
   };
 }
-function unwrapWsfeOperationResult(operation, response) {
+function unwrapWsfeOperationEnvelope(operation, response) {
   const operationResponse = response[`${operation}Response`];
   const result = operationResponse?.[`${operation}Result`] ?? response[`${operation}Result`] ?? response;
-  if (operation === "FECAESolicitar") {
-    const detailResponse = normalizeWsfeDetailResponse(result);
-    const resultCode = detailResponse.Resultado;
-    if (resultCode && resultCode !== "A") {
-      const observationsContainer = detailResponse.Observaciones;
-      const observations = normalizeWsfeErrors(observationsContainer?.Obs);
-      if (observations.length > 0) {
-        const firstObservation = observations[0];
-        if (!firstObservation) {
-          throw new ArcaServiceError(
-            "WSFE returned an empty observation list",
-            {
-              detail: result
-            }
-          );
-        }
-        throw new ArcaServiceError(firstObservation.message, {
-          serviceCode: firstObservation.code,
-          detail: result
-        });
-      }
-    }
-  }
-  const errorsContainer = result.Errors;
-  const errors = normalizeWsfeErrors(errorsContainer?.Err);
+  return result;
+}
+function throwForWsfeOperationErrors(operation, result) {
+  const errors = extractWsfeGlobalIssues(result, operation);
   if (errors.length > 0) {
-    const firstError = errors[0];
-    if (!firstError) {
-      throw new ArcaServiceError("WSFE returned an empty error list", {
-        detail: result
-      });
-    }
-    throw new ArcaServiceError(firstError.message, {
-      serviceCode: firstError.code,
-      detail: result
-    });
+    throw createWsfeServiceError(operation, result, errors);
   }
-  return result;
 }
 function normalizeWsfeDetailResponse(result) {
   const detailResponse = result.FeDetResp;
@@ -616,17 +754,248 @@ function normalizeWsfeDetailResponse(result) {
   }
   return rawDetail ?? {};
 }
-function normalizeWsfeErrors(rawErrors) {
+function classifyWsfeAuthorization(result, voucherNumber) {
+  const operation = "FECAESolicitar";
+  const header = toWsfeRecord(result.FeCabResp) ?? {};
+  const detail = normalizeWsfeDetailResponse(result);
+  const headerResult = normalizeWsfeResult(header.Resultado);
+  const detailResult = normalizeWsfeResult(detail.Resultado);
+  const resultCode = detailResult ?? headerResult;
+  const resultLevel = getWsfeResultLevel(headerResult, detailResult);
+  const cae = normalizeWsfeString(detail.CAE);
+  const caeExpiry = normalizeWsfeString(detail.CAEFchVto);
+  const errors = extractWsfeGlobalIssues(result, operation, "header");
+  const observations = extractWsfeObservations(
+    detail,
+    detailResult === "R" ? "business" : "observation"
+  );
+  const hasInfrastructureError = errors.some(
+    (issue) => issue.category === "infrastructure"
+  );
+  const base = {
+    service: "wsfe",
+    operation,
+    results: createWsfeResults(headerResult, detailResult),
+    errors,
+    observations,
+    raw: result
+  };
+  const context = {
+    base,
+    headerResult,
+    detailResult,
+    resultCode,
+    resultLevel,
+    cae,
+    caeExpiry
+  };
+  if (hasContradictoryWsfeResults(context)) {
+    return createWsfeStructuredIndeterminate(context, "contradictory_response");
+  }
+  if (hasInfrastructureError) {
+    return createWsfeStructuredIndeterminate(context, "incomplete_response");
+  }
+  if (isAuthorizedWsfeContext(context)) {
+    return {
+      ...base,
+      kind: "authorized",
+      result: "A",
+      resultLevel: "detail",
+      cae: context.cae,
+      caeExpiry: context.caeExpiry,
+      voucherNumber
+    };
+  }
+  if (isRejectedWsfeDetailContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "detail"
+    };
+  }
+  if (isRejectedWsfeHeaderContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "header"
+    };
+  }
+  return createWsfeStructuredIndeterminate(
+    context,
+    hasWsfeCaeContradiction(context) ? "contradictory_response" : "incomplete_response"
+  );
+}
+function getWsfeResultLevel(headerResult, detailResult) {
+  if (detailResult) {
+    return "detail";
+  }
+  return headerResult ? "header" : void 0;
+}
+function hasContradictoryWsfeResults(context) {
+  return Boolean(
+    context.headerResult && context.detailResult && context.headerResult !== context.detailResult
+  );
+}
+function isAuthorizedWsfeContext(context) {
+  return Boolean(
+    context.detailResult === "A" && context.headerResult !== "R" && context.base.errors.length === 0 && context.cae && context.caeExpiry
+  );
+}
+function isRejectedWsfeDetailContext(context) {
+  return context.detailResult === "R" && context.headerResult !== "A" && !context.cae;
+}
+function isRejectedWsfeHeaderContext(context) {
+  return context.headerResult === "R" && context.detailResult === void 0 && !context.cae && context.base.errors.length > 0 && context.base.errors.every((issue) => issue.category === "business");
+}
+function hasWsfeCaeContradiction(context) {
+  return (context.resultCode === "A" || context.resultCode === "R") && Boolean(context.cae);
+}
+function createWsfeStructuredIndeterminate(context, reason) {
+  const outcome = {
+    ...context.base,
+    kind: "indeterminate",
+    reason
+  };
+  assignWsfeValue(outcome, "result", context.resultCode);
+  assignWsfeValue(outcome, "resultLevel", context.resultLevel);
+  assignWsfeValue(outcome, "cae", context.cae);
+  assignWsfeValue(outcome, "caeExpiry", context.caeExpiry);
+  return outcome;
+}
+function createWsfeResults(headerResult, detailResult) {
+  const results = {};
+  assignWsfeValue(results, "header", headerResult);
+  assignWsfeValue(results, "detail", detailResult);
+  return results;
+}
+function createWsfeIndeterminateOutcome(error) {
+  return {
+    kind: "indeterminate",
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    results: {},
+    reason: getArcaIndeterminateReason(error),
+    errors: [],
+    observations: []
+  };
+}
+function getArcaIndeterminateReason(error) {
+  if (error instanceof ArcaTransportError) {
+    return "transport_error";
+  }
+  if (error instanceof ArcaSoapFaultError) {
+    return "soap_fault";
+  }
+  if (error instanceof ArcaInvalidSoapResponseError) {
+    return "invalid_response";
+  }
+  return "unexpected_error";
+}
+function createWsfeOutcomeError(outcome) {
+  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,
+    detail: outcome.raw
+  });
+}
+function createWsfeServiceError(operation, result, issues) {
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    firstIssue ? formatWsfeIssue(firstIssue) : "WSFE returned a service error",
+    {
+      service: "wsfe",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues,
+      detail: result
+    }
+  );
+}
+function extractWsfeGlobalIssues(result, operation, resultLevel) {
+  const errorsContainer = toWsfeRecord(result.Errors);
+  return normalizeWsfeIssueEntries(errorsContainer?.Err).map((entry) => ({
+    service: "wsfe",
+    operation,
+    source: "error",
+    category: operation === "FECAESolicitar" && WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES.has(entry.code ?? "") ? "infrastructure" : operation === "FECAESolicitar" ? "business" : "unknown",
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    ...resultLevel === void 0 ? {} : { resultLevel }
+  }));
+}
+function extractWsfeObservations(detail, category) {
+  const observationsContainer = toWsfeRecord(detail.Observaciones);
+  return normalizeWsfeIssueEntries(observationsContainer?.Obs).map((entry) => ({
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    source: "observation",
+    category,
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    resultLevel: "detail"
+  }));
+}
+function normalizeWsfeIssueEntries(rawErrors) {
   const entries = Array.isArray(rawErrors) ? rawErrors : rawErrors ? [rawErrors] : [];
   return entries.map((entry) => entry).map((entry) => {
-    const code = entry.Code ?? entry.code ?? "N/A";
+    const code = entry.Code ?? entry.code;
     const message = entry.Msg ?? entry.msg ?? "Unknown WSFE error";
     return {
-      code: String(code),
-      message: `(${String(code)}) ${String(message)}`
+      ...code === void 0 ? {} : { code: String(code) },
+      message: String(message)
     };
   });
 }
+function formatWsfeIssue(issue) {
+  return issue.code ? `(${issue.code}) ${issue.message}` : issue.message;
+}
+function normalizeWsfeResult(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized || void 0;
+}
+function normalizeWsfeString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  return normalized || void 0;
+}
+function normalizeWsfeNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const normalized = Number(value);
+  return Number.isFinite(normalized) ? normalized : void 0;
+}
+function assignWsfeValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function toWsfeRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+var WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES = /* @__PURE__ */ new Set([
+  "500",
+  "501",
+  "502",
+  "600",
+  "601"
+]);
 function getWsfeResultEntries(result, key) {
   const rawEntries = result.ResultGet?.[key];
   if (!rawEntries) {