@grod30/hacienda-js/dist/index.js

Biblioteca TypeScript para facturación electrónica de Costa Rica (Hacienda)

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  HaciendaAPI: () => HaciendaAPI,
  signXml: () => signXml,
  validateXml: () => validateXml
});
module.exports = __toCommonJS(index_exports);

// src/signature/index.ts
var import_xml_crypto = require("xml-crypto");
var import_fs = require("fs");
async function signXml(xml, options) {
  if (!xml || typeof xml !== "string") {
    throw new Error("Invalid XML");
  }
  if (!options || typeof options !== "object" || Array.isArray(options)) {
    throw new Error("Invalid options");
  }
  const { certPath, certType } = options;
  if (!certType) {
    throw new Error("Certificate type is required");
  }
  if (!certPath) {
    throw new Error("Certificate path is required");
  }
  if (certType !== "p12" && certType !== "pem") {
    throw new Error("Invalid certificate type");
  }
  try {
    const cert = (0, import_fs.readFileSync)(certPath);
    const sig = new import_xml_crypto.SignedXml();
    sig.keyInfoProvider = {
      getKeyInfo: () => `<X509Data><X509Certificate>${cert.toString("base64")}</X509Certificate></X509Data>`,
      getKey: () => cert
    };
    sig.addReference("", [
      "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
    ]);
    sig.signingKey = cert;
    sig.computeSignature(xml);
    return sig.getSignedXml();
  } catch (error) {
    if (error instanceof Error) {
      if (error.message.includes("ENOENT")) {
        throw new Error("File not found");
      }
      throw error;
    }
    throw new Error("Signing failed");
  }
}

// src/api/index.ts
var import_axios = __toESM(require("axios"));
var HaciendaAPI = class {
  constructor(config) {
    this.config = config;
  }
  async getToken(username, password) {
    const response = await import_axios.default.post(`${this.config.apiUrl}/token`, {
      grant_type: "password",
      client_id: this.config.clientId,
      username,
      password
    });
    this.token = response.data.access_token;
    return this.token;
  }
  validateToken(token) {
    const useToken = token || this.token;
    if (!useToken) {
      throw new Error("Token no proporcionado");
    }
    return useToken;
  }
  async makeRequest(method, url, data, token) {
    const useToken = this.validateToken(token);
    try {
      const config = {
        headers: {
          "Authorization": `Bearer ${useToken}`,
          "Content-Type": "application/json"
        }
      };
      const response = method === "post" ? await import_axios.default.post(url, data, config) : await import_axios.default.get(url, config);
      return response.data;
    } catch (error) {
      if (error instanceof Error) {
        throw error;
      }
      throw new Error("Error desconocido");
    }
  }
  async sendDocument(documentXml, token) {
    const response = await this.makeRequest(
      "post",
      `${this.config.apiUrl}/recepcion`,
      { xml: documentXml },
      token
    );
    return {
      clave: response.clave,
      fecha: response.fecha,
      estado: response.estado,
      mensaje: response.mensaje
    };
  }
  async checkStatus(clave, token) {
    const response = await this.makeRequest(
      "get",
      `${this.config.apiUrl}/recepcion/${clave}`,
      void 0,
      token
    );
    return {
      clave: response.clave,
      fecha: response.fecha,
      estado: response.estado,
      mensaje: response.mensaje
    };
  }
};

// src/xml/index.ts
var validateXml = (xml) => {
  return xml.includes("FacturaElectronica");
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  HaciendaAPI,
  signXml,
  validateXml
});