facturas 0.4.0

package/dist/wsfe.js

@@ -0,0 +1,605 @@
+// src/errors.ts
+var ArcaError = class extends Error {
+  code;
+  name = "ArcaError";
+  constructor(message, code = "ARCA_ERROR", options) {
+    super(message, options);
+    this.code = code;
+  }
+};
+var ArcaInputError = class extends ArcaError {
+  name = "ArcaInputError";
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_INPUT_ERROR", options);
+    this.detail = options?.detail;
+  }
+};
+var ArcaServiceError = class extends ArcaError {
+  name = "ArcaServiceError";
+  serviceCode;
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_SERVICE_ERROR", options);
+    this.serviceCode = options?.serviceCode;
+    this.detail = options?.detail;
+  }
+};
+
+// src/services/wsfe.ts
+function createWsfeService(options) {
+  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+    const auth = await options.auth.login("wsfe", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceAuthRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body: {
+        Auth: createWsfeAuth(
+          input.representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        ),
+        ...body
+      }
+    });
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function executeWsfeOperation(operation, body = {}) {
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body
+    });
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function getNextVoucherNumber({
+    representedTaxId,
+    salesPoint,
+    voucherType,
+    forceAuthRefresh
+  }) {
+    const result = await executeWsfeAuthenticatedOperation(
+      "FECompUltimoAutorizado",
+      {
+        representedTaxId,
+        forceAuthRefresh
+      },
+      {
+        PtoVta: salesPoint,
+        CbteTipo: voucherType
+      }
+    );
+    return Number(result.CbteNro ?? 0) + 1;
+  }
+  async function getWsfeCatalog(operation, resultKey, input) {
+    const result = await executeWsfeAuthenticatedOperation(operation, {
+      representedTaxId: input.representedTaxId,
+      forceAuthRefresh: input.forceAuthRefresh
+    });
+    return getWsfeResultEntries(result, resultKey).map(mapWsfeCatalogEntry);
+  }
+  return {
+    async createNextVoucher({ representedTaxId, data }) {
+      const normalizedInput = normalizeWsfeVoucherInput(data);
+      const voucherNumber = await getNextVoucherNumber({
+        representedTaxId,
+        salesPoint: normalizedInput.salesPoint,
+        voucherType: normalizedInput.voucherType
+      });
+      const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
+      const auth = await options.auth.login("wsfe", { representedTaxId });
+      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
+            }
+          }
+        }
+      });
+      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",
+          { detail: result }
+        );
+      }
+      return {
+        cae,
+        caeExpiry: String(caeExpiry),
+        voucherNumber,
+        raw: result
+      };
+    },
+    getNextVoucherNumber,
+    getLastVoucher(input) {
+      return getNextVoucherNumber(input);
+    },
+    async getSalesPoints({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetPtosVenta",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      const rawPoints = result.ResultGet?.PtoVenta;
+      if (!rawPoints) {
+        return [];
+      }
+      const entries = Array.isArray(rawPoints) ? rawPoints : [rawPoints];
+      return entries.map(mapWsfeSalesPoint);
+    },
+    getVoucherTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposCbte", "CbteTipo", input);
+    },
+    getDocumentTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposDoc", "DocTipo", input);
+    },
+    getConceptTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposConcepto", "ConceptoTipo", input);
+    },
+    async getCurrencyTypes({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetTiposMonedas",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "Moneda").map(mapWsfeCurrencyType);
+    },
+    getVatRates(input) {
+      return getWsfeCatalog("FEParamGetTiposIva", "IvaTipo", input);
+    },
+    getTaxTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposTributos", "TributoTipo", input);
+    },
+    getOptionalTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposOpcional", "OpcionalTipo", input);
+    },
+    async getActivities({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetActividades",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "ActividadesTipo").map(
+        mapWsfeActivityType
+      );
+    },
+    async getReceiverVatConditions({
+      representedTaxId,
+      voucherClass,
+      forceAuthRefresh
+    }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCondicionIvaReceptor",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        },
+        {
+          ...voucherClass === void 0 ? {} : { ClaseCmp: voucherClass }
+        }
+      );
+      return getWsfeResultEntries(result, "CondicionIvaReceptor").map(
+        mapWsfeReceiverVatCondition
+      );
+    },
+    async getServerStatus() {
+      const result = await executeWsfeOperation("FEDummy");
+      return mapWsfeServerStatus(result);
+    },
+    async getQuotation({ currencyId, representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCotizacion",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        },
+        {
+          MonId: currencyId
+        }
+      );
+      const raw = result.ResultGet ?? {};
+      return mapWsfeQuotation(raw);
+    },
+    async getVoucherInfo({
+      representedTaxId,
+      number,
+      salesPoint,
+      voucherType
+    }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FECompConsultar",
+        {
+          representedTaxId
+        },
+        {
+          FeCompConsReq: {
+            CbteNro: number,
+            PtoVta: salesPoint,
+            CbteTipo: voucherType
+          }
+        }
+      );
+      const raw = result.ResultGet ?? null;
+      if (!raw) {
+        return null;
+      }
+      return mapWsfeVoucherInfo(raw);
+    }
+  };
+}
+function mapWsfeVoucherInput(input, voucherNumber) {
+  const data = {
+    Concepto: input.concept,
+    DocTipo: input.documentType,
+    DocNro: input.documentNumber,
+    CbteDesde: voucherNumber,
+    CbteHasta: voucherNumber,
+    CbteFch: input.voucherDate,
+    ImpTotal: input.totalAmount,
+    ImpTotConc: input.nonTaxableAmount,
+    ImpNeto: input.netAmount,
+    ImpOpEx: input.exemptAmount,
+    ImpTrib: input.taxAmount,
+    ImpIVA: input.vatAmount,
+    MonId: input.currencyId,
+    MonCotiz: input.exchangeRate,
+    PtoVta: input.salesPoint,
+    CbteTipo: input.voucherType
+  };
+  if (input.receiverVatConditionId !== void 0) {
+    data.CondicionIVAReceptorId = input.receiverVatConditionId;
+  }
+  if (input.sameCurrencyForeignCancellation !== void 0) {
+    data.CanMisMonExt = input.sameCurrencyForeignCancellation;
+  }
+  if (input.serviceStartDate !== void 0) {
+    data.FchServDesde = input.serviceStartDate;
+  }
+  if (input.serviceEndDate !== void 0) {
+    data.FchServHasta = input.serviceEndDate;
+  }
+  if (input.paymentDueDate !== void 0) {
+    data.FchVtoPago = input.paymentDueDate;
+  }
+  if (input.associatedVouchers) {
+    data.CbtesAsoc = {
+      CbteAsoc: input.associatedVouchers.map((v) => ({
+        Tipo: v.type,
+        PtoVta: v.salesPoint,
+        Nro: v.number,
+        ...v.taxId === void 0 ? {} : { Cuit: v.taxId },
+        ...v.voucherDate === void 0 ? {} : { CbteFch: v.voucherDate }
+      }))
+    };
+  }
+  if (input.associatedPeriod) {
+    data.PeriodoAsoc = {
+      FchDesde: input.associatedPeriod.startDate,
+      FchHasta: input.associatedPeriod.endDate
+    };
+  }
+  if (input.taxes) {
+    data.Tributos = {
+      Tributo: input.taxes.map((t) => ({
+        Id: t.id,
+        ...t.description === void 0 ? {} : { Desc: t.description },
+        BaseImp: t.baseAmount,
+        Alic: t.rate,
+        Importe: t.amount
+      }))
+    };
+  }
+  if (input.vatRates) {
+    data.Iva = {
+      AlicIva: input.vatRates.map((v) => ({
+        Id: v.id,
+        BaseImp: v.baseAmount,
+        Importe: v.amount
+      }))
+    };
+  }
+  if (input.optionalFields) {
+    data.Opcionales = {
+      Opcional: input.optionalFields.map((o) => ({
+        Id: o.id,
+        Valor: o.value
+      }))
+    };
+  }
+  if (input.buyers) {
+    data.Compradores = {
+      Comprador: input.buyers.map((b) => ({
+        DocTipo: b.documentType,
+        DocNro: b.documentNumber,
+        Porcentaje: b.percentage
+      }))
+    };
+  }
+  if (input.activities) {
+    data.Actividades = {
+      Actividad: input.activities.map((a) => ({
+        Id: a.id
+      }))
+    };
+  }
+  return data;
+}
+function normalizeWsfeVoucherInput(input) {
+  const {
+    voucherDate,
+    serviceStartDate,
+    serviceEndDate,
+    paymentDueDate,
+    associatedVouchers,
+    associatedPeriod,
+    ...rest
+  } = input;
+  return {
+    ...rest,
+    voucherDate: normalizeWsfeDateInput(voucherDate, "voucherDate"),
+    ...serviceStartDate === void 0 ? {} : {
+      serviceStartDate: normalizeWsfeDateInput(
+        serviceStartDate,
+        "serviceStartDate"
+      )
+    },
+    ...serviceEndDate === void 0 ? {} : {
+      serviceEndDate: normalizeWsfeDateInput(
+        serviceEndDate,
+        "serviceEndDate"
+      )
+    },
+    ...paymentDueDate === void 0 ? {} : {
+      paymentDueDate: normalizeWsfeDateInput(
+        paymentDueDate,
+        "paymentDueDate"
+      )
+    },
+    ...associatedVouchers === void 0 ? {} : {
+      associatedVouchers: associatedVouchers.map((voucher, index) => {
+        const { voucherDate: associatedVoucherDate, ...associatedRest } = voucher;
+        return {
+          ...associatedRest,
+          ...associatedVoucherDate === void 0 ? {} : {
+            voucherDate: normalizeWsfeDateInput(
+              associatedVoucherDate,
+              `associatedVouchers[${index}].voucherDate`
+            )
+          }
+        };
+      })
+    },
+    ...associatedPeriod === void 0 ? {} : {
+      associatedPeriod: {
+        startDate: normalizeWsfeDateInput(
+          associatedPeriod.startDate,
+          "associatedPeriod.startDate"
+        ),
+        endDate: normalizeWsfeDateInput(
+          associatedPeriod.endDate,
+          "associatedPeriod.endDate"
+        )
+      }
+    }
+  };
+}
+function normalizeWsfeDateInput(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+  const normalizedValue = value.trim();
+  const afipMatch = normalizedValue.match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (afipMatch) {
+    const [, year, month, day] = afipMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return normalizedValue;
+  }
+  const isoMatch = normalizedValue.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (isoMatch) {
+    const [, year, month, day] = isoMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return `${year}${month}${day}`;
+  }
+  throw new ArcaInputError(
+    `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+    {
+      detail: { field: fieldName, value: normalizedValue }
+    }
+  );
+}
+function assertValidCalendarDate(yearInput, monthInput, dayInput, fieldName, value) {
+  const year = Number(yearInput);
+  const month = Number(monthInput);
+  const day = Number(dayInput);
+  const candidate = new Date(Date.UTC(year, month - 1, day));
+  if (candidate.getUTCFullYear() !== year || candidate.getUTCMonth() !== month - 1 || candidate.getUTCDate() !== day) {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: received a non-existent calendar date`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+}
+function mapWsfeSalesPoint(raw) {
+  const record = raw;
+  return {
+    number: Number(record.Nro ?? 0),
+    ...record.EmisionTipo === void 0 ? {} : { emissionType: String(record.EmisionTipo) },
+    ...record.Bloqueado === void 0 ? {} : { blocked: String(record.Bloqueado) },
+    ...record.FchBaja === void 0 ? {} : { deletedSince: String(record.FchBaja) }
+  };
+}
+function mapWsfeCatalogEntry(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? "")
+  };
+}
+function mapWsfeActivityType(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? ""),
+    order: Number(record.Orden ?? 0)
+  };
+}
+function mapWsfeReceiverVatCondition(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? ""),
+    voucherClass: String(record.Cmp_Clase ?? "")
+  };
+}
+function mapWsfeCurrencyType(raw) {
+  const record = raw;
+  return {
+    id: String(record.Id ?? ""),
+    description: String(record.Desc ?? ""),
+    validFrom: String(record.FchDesde ?? ""),
+    validTo: String(record.FchHasta ?? "")
+  };
+}
+function mapWsfeServerStatus(raw) {
+  return {
+    appServer: String(raw.AppServer ?? ""),
+    dbServer: String(raw.DbServer ?? ""),
+    authServer: String(raw.AuthServer ?? "")
+  };
+}
+function mapWsfeQuotation(raw) {
+  return {
+    currencyId: String(raw.MonId ?? ""),
+    rate: Number(raw.MonCotiz ?? 0),
+    date: String(raw.FchCotiz ?? "")
+  };
+}
+function mapWsfeVoucherInfo(raw) {
+  return {
+    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
+  };
+}
+function createWsfeAuth(representedTaxId, token, sign) {
+  return {
+    Token: token,
+    Sign: sign,
+    Cuit: Number.parseInt(String(representedTaxId), 10)
+  };
+}
+function unwrapWsfeOperationResult(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);
+  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
+    });
+  }
+  return result;
+}
+function normalizeWsfeDetailResponse(result) {
+  const detailResponse = result.FeDetResp;
+  const rawDetail = detailResponse?.FECAEDetResponse;
+  if (Array.isArray(rawDetail)) {
+    return rawDetail[0] ?? {};
+  }
+  return rawDetail ?? {};
+}
+function normalizeWsfeErrors(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 message = entry.Msg ?? entry.msg ?? "Unknown WSFE error";
+    return {
+      code: String(code),
+      message: `(${String(code)}) ${String(message)}`
+    };
+  });
+}
+function getWsfeResultEntries(result, key) {
+  const rawEntries = result.ResultGet?.[key];
+  if (!rawEntries) {
+    return [];
+  }
+  return (Array.isArray(rawEntries) ? rawEntries : [rawEntries]).map(
+    (entry) => entry
+  );
+}
+export {
+  createWsfeService
+};
+//# sourceMappingURL=wsfe.js.map