nets-service-sdk 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,2 +1,1406 @@
-function e(){return e=Object.assign?Object.assign.bind():function(e){for(var r=1;r<arguments.length;r++){var n=arguments[r];for(var s in n)({}).hasOwnProperty.call(n,s)&&(e[s]=n[s])}return e},e.apply(null,arguments)}var r=require("./src/utils.helper"),n=require("./src/winston"),s=require("./src/manageConfig"),u=require("./src/queue"),a=require("./src/sendMessage"),t=require("./src/payment/communication"),i=require("./src/payment/hexRequest"),c=require("./src/payment/httpRequest"),o=require("./src/payment/parser"),p=require("./src/payment/responseHandler");module.exports=e({},r,{logger:n,manageConfig:s,queue:u,sendMessage:a,communication:t,hexRequest:i,httpRequest:c,parser:o,responseHandler:p});
-//# sourceMappingURL=index.js.map
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/utils.helper.js
+var require_utils_helper = __commonJS({
+  "src/utils.helper.js"(exports2, module2) {
+    var { SerialPort } = require("serialport");
+    var crypto = require("crypto");
+    var _ = require("lodash");
+    module2.exports.padWithLeadingZeros = (num, totalLength) => {
+      return String(num).padStart(totalLength, "0");
+    };
+    module2.exports.xorCalculation = (value) => {
+      const splitted_arr = value.match(/[\w]{2}/g);
+      let response = "";
+      _.map(splitted_arr, (value2, i) => {
+        if (i == 0) {
+          response = value2;
+        } else {
+          response = xor(response, value2);
+        }
+      });
+      return response;
+    };
+    String.prototype.toHexString = function() {
+      var res = [];
+      for (var i = 0, j = this.length; i < j; ++i) {
+        var chr = this.charCodeAt(i).toString(16);
+        chr = (chr.length == 1 ? "0" : "") + chr;
+        res.push(chr);
+      }
+      return res.join("").toUpperCase();
+    };
+    function xor(hex1, hex2) {
+      const buf1 = Buffer.from(hex1, "hex");
+      const buf2 = Buffer.from(hex2, "hex");
+      const bufResult = buf1.map((b, i) => b ^ buf2[i]);
+      return bufResult.toString("hex");
+    }
+    String.prototype.toAsciiString = function() {
+      return this.match(/.{1,2}/g).map(function(v) {
+        return String.fromCharCode(parseInt(v, 16));
+      }).join("");
+    };
+    String.prototype.splitAtIndex = function(index) {
+      return [this.substring(0, index), this.substring(index)];
+    };
+    String.prototype.cleanUp = function() {
+      return this.replace(
+        /[^A-Za-z 0-9 \.,\?""!@#\$%\^&\*\(\)-_=\+;:<>\/\\\|\}\{\[\]`~]*/g,
+        ""
+      ).trim();
+    };
+    SerialPort.prototype._disconnected = function(err) {
+      this.paused = true;
+      this.emit("disconnect", err);
+      if (this.closing) {
+        return;
+      }
+      if (this.fd === null) {
+        return;
+      }
+      this.closing = true;
+      if (process.platform !== "win32") {
+        this.readable = false;
+        if (this.serialPoller) {
+          this.serialPoller.close();
+        }
+      }
+      SerialPortBinding.close(
+        this.fd,
+        function(err2) {
+          this.closing = false;
+          if (err2) {
+            debug("Disconnect close completed with error: ", err2);
+          }
+          this.fd = null;
+          this.emit("close");
+        }.bind(this)
+      );
+    };
+    module2.exports.generateServiceKey = (payload) => {
+      const key = `${process.env.user}:${process.env.password}`;
+      const algorithm = "aes256";
+      var cipher = crypto.createCipher(algorithm, key);
+      return cipher.update(JSON.stringify(payload), "utf8", "hex") + cipher.final("hex");
+    };
+  }
+});
+
+// src/winston.js
+var require_winston = __commonJS({
+  "src/winston.js"(exports2, module2) {
+    var { createLogger, format, transports } = require("winston");
+    var { combine, timestamp, label, printf } = format;
+    var path = require("path");
+    var getLabel = (callingModule) => {
+      if (!callingModule || !callingModule.filename) {
+        return "unknown";
+      }
+      const parts = callingModule.filename.split(path.sep);
+      return path.join(parts[parts.length - 1], parts.pop());
+    };
+    var myFormat = printf(
+      ({ level, message, label: label2, timestamp: timestamp2 }) => `${timestamp2} [${label2}] ${level}: ${message}`
+    );
+    var logger = (module3) => createLogger({
+      format: combine(label({ label: getLabel(module3) }), timestamp(), myFormat),
+      transports: [
+        new transports.Console(),
+        new transports.File({
+          filename: "log/platform-access.log",
+          level: "info",
+          timestamp: true
+        }),
+        new transports.File({
+          filename: "log/platform-error.log",
+          level: "error",
+          timestamp: true
+        })
+      ]
+    });
+    module2.exports = logger;
+  }
+});
+
+// src/manageConfig.js
+var require_manageConfig = __commonJS({
+  "src/manageConfig.js"(exports2, module2) {
+    var fs = require("fs");
+    var _ = require("lodash");
+    module2.exports.updateConfig = (data) => {
+      try {
+        const config = fs.readFileSync("./config.json");
+        const configJson = JSON.parse(config);
+        _.assignIn(configJson, data);
+        fs.writeFileSync("config.json", JSON.stringify(configJson, null, "	"));
+      } catch (e) {
+        throw e;
+      }
+    };
+    module2.exports.getConfigByKey = (key) => {
+      try {
+        const config = fs.readFileSync("./config.json");
+        const configJson = JSON.parse(config);
+        return configJson[key];
+      } catch (e) {
+        throw e;
+      }
+    };
+    module2.exports.getConfig = () => {
+      try {
+        const config = fs.readFileSync("./config.json");
+        return JSON.parse(config);
+      } catch (e) {
+        throw e;
+      }
+    };
+  }
+});
+
+// src/queue.js
+var require_queue = __commonJS({
+  "src/queue.js"(exports2, module2) {
+    "use strict";
+    var Node = class {
+      constructor(data) {
+        this.data = data;
+      }
+    };
+    var Queue = class {
+      constructor() {
+        this.elements = [];
+      }
+      enqueue(node) {
+        this.elements.push(node);
+      }
+      dequeue() {
+        if (this.elements.length > 0) {
+          return this.elements.shift();
+        } else {
+          return "Underflow situation";
+        }
+      }
+      isEmpty() {
+        return this.elements.length == 0;
+      }
+      front() {
+        if (this.elements.length > 0) {
+          return this.elements[0];
+        } else {
+          return "The Queue is empty!";
+        }
+      }
+      size() {
+        return this.elements.length;
+      }
+      print() {
+        return this.elements;
+      }
+    };
+    module2.exports = {
+      Node,
+      Queue
+    };
+  }
+});
+
+// src/sendMessage.js
+var require_sendMessage = __commonJS({
+  "src/sendMessage.js"(exports2, module2) {
+    var logger = require_winston()(module2);
+    module2.exports.sendMessage = (room = "clientRoom", tag, msg) => {
+      logger.log({
+        level: "info",
+        message: JSON.stringify(msg)
+      });
+      global.io.emit(tag, msg);
+    };
+  }
+});
+
+// src/payment/hexRequest.js
+var require_hexRequest = __commonJS({
+  "src/payment/hexRequest.js"(exports2, module2) {
+    var { padWithLeadingZeros, xorCalculation } = require_utils_helper();
+    var dollarsToCents = require("dollars-to-cents");
+    var _ = require("lodash");
+    var moment = require("moment");
+    module2.exports.generateStatusReq = () => {
+      const date = moment().format("DDMMYYHHmmss");
+      const paddedValue = padWithLeadingZeros(date, "12");
+      const hexValue = paddedValue.toHexString();
+      const calculated = `0018${hexValue}35353031301C03`;
+      const calculatedXor = xorCalculation(calculated);
+      const hexString = `02${calculated}` + calculatedXor;
+      const buffer = Buffer.from(hexString, "hex");
+      return { buffer, ecn: date };
+    };
+    module2.exports.generateLogonRequest = () => {
+      const date = moment().format("DDMMYYHHmmss");
+      const paddedValue = padWithLeadingZeros(date, "12");
+      const hexValue = paddedValue.toHexString();
+      const calculated = `0018${hexValue}38303031301C03`;
+      const calculatedXor = xorCalculation(calculated);
+      const hexString = `02${calculated}` + calculatedXor;
+      console.log(hexString);
+      const buffer = Buffer.from(hexString, "hex");
+      return { buffer, ecn: date };
+    };
+    module2.exports.generatePaymentRequest = (body) => {
+      const ecnPadded = padWithLeadingZeros(body.ecn, "12");
+      console.log("ecnPadded", ecnPadded);
+      const cents = dollarsToCents(body.amount);
+      console.log("cents", cents);
+      const amountPadded = padWithLeadingZeros(cents, "12").toHexString();
+      console.log("amountPadded", amountPadded);
+      const orderReference = padWithLeadingZeros(body.reference, "13").toHexString();
+      console.log("orderReference", orderReference);
+      let calculated;
+      if (body.isCreditTxn) {
+        const calculatedEcn = `${ecnPadded}I0010`.toHexString();
+        calculated = `0053${calculatedEcn}1C34300012${amountPadded}1C48440013${orderReference}1C03`;
+      } else {
+        const calculatedEcn = `${ecnPadded}30010`.toHexString();
+        calculated = `0077${calculatedEcn}1C5432000230311C34300012${amountPadded}1C343200123030303030303030303030301C48440013${orderReference}1C03`;
+      }
+      console.log("calculated", calculated);
+      const calculatedXor = xorCalculation(calculated);
+      console.log("calculatedXor", calculatedXor);
+      const hexString = `02${calculated}` + calculatedXor;
+      console.log("hexString", hexString);
+      const buffer = Buffer.from(hexString, "hex");
+      console.log("hexString", hexString);
+      console.log("buffer", buffer);
+      return { buffer, ecn: body.ecn, hexString };
+    };
+  }
+});
+
+// src/payment/httpRequest.js
+var require_httpRequest = __commonJS({
+  "src/payment/httpRequest.js"(exports2, module2) {
+    var fw = require_manageConfig();
+    var request = require("request");
+    var logger = require_winston()(module2);
+    var { generateServiceKey } = require_utils_helper();
+    module2.exports.requestCompletion = (entryId, fullfillmentDetails, paymentStatus, paymentType) => new Promise(async (resolve, reject) => {
+      try {
+        const URL = `${process.env.URL}api/v1/hooks`;
+        const payload = {
+          ...fullfillmentDetails,
+          paymentType,
+          paymentStatus,
+          entryId
+        };
+        return request(
+          {
+            method: "POST",
+            uri: URL,
+            body: payload,
+            json: true,
+            headers: { "x-service-key": generateServiceKey(payload) }
+          },
+          async (err, res, body) => {
+            if (err) {
+              return reject(err);
+            }
+            if (res) {
+              return resolve(body);
+            }
+          }
+        );
+      } catch (e) {
+        console.log(`getToken Service Error: ${JSON.stringify(e)}`);
+        return reject(e);
+      }
+    });
+    module2.exports.initialiseRequest = (entryId, fullfillmentDetails, paymentType) => new Promise(async (resolve, reject) => {
+      try {
+        const config = fw.getConfig();
+        const URL = `${config.cloud_url}api/v1/hooks`;
+        const payload = {
+          ...fullfillmentDetails,
+          paymentType,
+          entryId,
+          update: "INIT"
+        };
+        logger.log({
+          level: "info",
+          message: `update Request: ${JSON.stringify(payload)}`
+        });
+        return request(
+          {
+            method: "POST",
+            uri: URL,
+            body: payload,
+            json: true,
+            headers: { "x-service-key": generateServiceKey(payload) }
+          },
+          async (err, res, body) => {
+            if (err) {
+              console.log(err);
+              return reject(err);
+            }
+            if (res) {
+              return resolve(body);
+            }
+          }
+        );
+      } catch (e) {
+        console.log(`getToken Service Error: ${JSON.stringify(e)}`);
+        return reject(e);
+      }
+    });
+  }
+});
+
+// src/payment/parser.js
+var require_parser = __commonJS({
+  "src/payment/parser.js"(exports2, module2) {
+    module2.exports.statusParser = (hexCode, ecn) => {
+      const splitted = hexCode.split("1c");
+      for (let i = 0; i < splitted.length; i++) {
+        if (splitted[i].toAsciiString().indexOf(ecn) > -1) {
+          return true;
+        }
+      }
+      return false;
+    };
+    module2.exports.logonParser = (hexCode, ecn) => {
+      try {
+        const splitted = hexCode.split("1c");
+        let status = false;
+        const json = {};
+        for (let i = 0; i < splitted.length; i++) {
+          const ascii = splitted[i].toAsciiString();
+          if (ascii.indexOf(ecn) > -1) {
+            status = true;
+            json["ECN"] = ascii.cleanUp();
+          } else {
+            const subStringArray = ascii.splitAtIndex(2);
+            if (subStringArray.length > 1) {
+              if (subStringArray[0] == "02" && subStringArray[0].indexOf("APPROVED") > -1) {
+                status = true;
+              }
+              const identifier = subStringArray[0].cleanUp();
+              const value = subStringArray[1].cleanUp();
+              if (identifier && value) {
+                json[identifier] = value;
+              }
+            }
+          }
+        }
+        return { status, json };
+      } catch (e) {
+        throw e;
+      }
+    };
+    module2.exports.netsPaymentParser = (hexCode, ecn) => {
+      try {
+        const splitted = hexCode.split("1c");
+        let status = false;
+        const json = {};
+        for (let i = 0; i < splitted.length; i++) {
+          const ascii = splitted[i].toAsciiString();
+          if (ascii.indexOf(ecn) > -1) {
+            json["ECN"] = ascii.cleanUp();
+          } else {
+            const subStringArray = ascii.splitAtIndex(2);
+            if (subStringArray.length > 1) {
+              const identifier = subStringArray[0].cleanUp();
+              const value = subStringArray[1].cleanUp();
+              if (identifier && value) {
+                json[identifier] = value;
+              }
+            }
+          }
+        }
+        return json;
+      } catch (e) {
+        throw e;
+      }
+    };
+    module2.exports.creditPaymentParser = (hexCode, ecn) => {
+      try {
+        const splitted = hexCode.split("1c");
+        let status = false;
+        const json = {};
+        for (let i = 0; i < splitted.length; i++) {
+          const ascii = splitted[i].toAsciiString();
+          if (ascii.indexOf(ecn) > -1) {
+            json["ECN"] = ascii.cleanUp();
+          } else {
+            const subStringArray = ascii.splitAtIndex(2);
+            if (subStringArray.length > 1) {
+              const identifier = subStringArray[0].cleanUp();
+              const value = subStringArray[1].cleanUp();
+              if (identifier && value) {
+                json[identifier] = value;
+              }
+            }
+          }
+        }
+        return json;
+      } catch (e) {
+        throw e;
+      }
+    };
+    module2.exports.jsonProcessor = (obj) => {
+      const data = { ...obj };
+      const keys = Object.keys(data);
+      const translatedJson = {};
+      keys.forEach((key) => {
+        if (key == "01") {
+          translatedJson["approvalCode"] = obj[key];
+        }
+        if (key == "02") {
+          const statusResponse = statusCheck(obj[key]);
+          if (statusResponse) {
+            translatedJson.status = statusResponse.status;
+            translatedJson.description = statusResponse.detail;
+            if (statusResponse.balance) {
+              translatedJson["balance"] = statusResponse.balance;
+            }
+          }
+          const ecnnError = CheckECNERROR(obj["ECN"]);
+          if (ecnnError) {
+            translatedJson.status = ecnnError.status;
+            translatedJson.description = ecnnError.detail;
+          }
+          translatedJson["responsetext"] = obj[key];
+        }
+        if (key == "03") {
+          translatedJson["date"] = obj[key].match(/.{1,2}/g) ?? [];
+        }
+        if (key == "04") {
+          translatedJson["time"] = obj[key].match(/.{1,2}/g) ?? [];
+        }
+        if (key == "16") {
+          translatedJson["terminalId"] = obj[key];
+        }
+        if (key == "30") {
+          translatedJson["cardNumber"] = obj[key];
+        }
+        if (key == "31") {
+          translatedJson["expiryDate"] = obj[key];
+        }
+        if (key == "40") {
+          translatedJson["transactionAmount"] = obj[key];
+        }
+        if (key == "41") {
+          translatedJson["serviceFee"] = obj[key];
+        }
+        if (key == "50") {
+          translatedJson["batchNumber"] = obj[key];
+        }
+        if (key == "65") {
+          translatedJson["stan"] = obj[key];
+        }
+        if (key == "A1") {
+          translatedJson["transactionId"] = obj[key];
+        }
+        if (key == "D0") {
+          translatedJson["merchantNameAndAddress"] = obj[key];
+        }
+        if (key == "D1") {
+          translatedJson["merchantId"] = obj[key];
+        }
+        if (key == "D3") {
+          translatedJson["retrievalReferenceNumber"] = obj[key];
+        }
+        if (key == "D6") {
+          translatedJson["cardHolderName"] = obj[key];
+        }
+        if (key == "D7") {
+          translatedJson["processingGateway"] = obj[key];
+        }
+        if (key == "D8") {
+          translatedJson["cardDescription"] = obj[key];
+        }
+        if (key == "CN") {
+          translatedJson["cardEntryMode"] = obj[key];
+        }
+        if (key == "L1") {
+          translatedJson["loyaltyProgramName"] = obj[key];
+        }
+        if (key == "L2") {
+          translatedJson["loyaltyType"] = obj[key];
+        }
+        if (key == "L3") {
+          translatedJson["redemptionValue"] = obj[key];
+        }
+        if (key == "L4") {
+          translatedJson["currentLoyaltyBalance"] = obj[key];
+        }
+        if (key == "L5") {
+          translatedJson["posMessages"] = obj[key];
+        }
+        if (key == "L7") {
+          translatedJson["cardName"] = obj[key];
+        }
+        if (key == "L8") {
+          translatedJson["loyaltyProgramExpDate"] = obj[key];
+        }
+        if (key == "L9") {
+          translatedJson["loyaltyMarketingMessage"] = obj[key];
+        }
+        if (key == "HC") {
+          translatedJson["hostResponseCode"] = obj[key];
+        }
+        if (key == "HD") {
+          translatedJson["enhancedECRReferenceNumber"] = obj[key];
+        }
+        if (key == "9A") {
+          translatedJson["aid-EMV"] = obj[key];
+        }
+        if (key == "9B") {
+          translatedJson["applicationProfile-EMV"] = obj[key];
+        }
+        if (key == "9C") {
+          translatedJson["cid-EMV"] = obj[key];
+        }
+        if (key == "9D") {
+          translatedJson["transactionCertificate-EMV"] = obj[key];
+        }
+        if (key == "9E") {
+          translatedJson["tsi-EMV"] = obj[key];
+        }
+        if (key == "9F") {
+          translatedJson["tvr-EMV"] = obj[key];
+        }
+        if (key == "9H") {
+          translatedJson["invoiceNumber"] = obj[key];
+        }
+        if (key == "9I") {
+          translatedJson["posId"] = obj[key];
+        }
+        if (key == "9M") {
+          translatedJson["cardType"] = obj[key];
+        }
+        if (key == "9Q") {
+          translatedJson["schemeCategory"] = obj[key];
+        }
+        if (key == "O1") {
+          translatedJson["offlineTxnType"] = obj[key];
+        }
+        if (key == "RP") {
+          translatedJson["receiptTextFormat"] = obj[key];
+        }
+      });
+      return { translated: translatedJson, raw: obj };
+    };
+    function statusCheck(data) {
+      if (data.indexOf("APPROVED") > -1) {
+        const response = { status: "APPROVED", detail: "Payment Succeed" };
+        if (data.indexOf("BAL:") > -1) {
+          const balance = data.split("BAL:");
+          response.balance = balance[1].trim();
+        }
+        return response;
+      }
+      if (data.indexOf("INVALID CARD") > -1) {
+        return { status: "INVALID_CARD", detail: "Invalid Card" };
+      }
+      if (data.indexOf("F3905-Parameter") > -1) {
+        return { status: "INVALID_CARD", detail: "Invalid Card" };
+      }
+      if (data.indexOf("DECLINED") > -1) {
+        return { status: "DECLINED", detail: "Transaction Declined" };
+      }
+      if (data.indexOf("CARD NOT SUPPORTED") > -1) {
+        return { status: "CARD_NOT_SUPPORTED", detail: "Card not supported" };
+      }
+      return null;
+    }
+    function CheckECNERROR(data) {
+      if (data.indexOf("US") > -1) {
+        return { status: "USER_CANCELLED", detail: "User Cancelled" };
+      }
+      if (data.indexOf("GX") > -1) {
+        return { status: "OUT_OF_PAPER", detail: "Out of Paper" };
+      }
+      if (data.indexOf("TO") > -1) {
+        return { status: "TIME_OUT", detail: "Time Out" };
+      }
+      return null;
+    }
+  }
+});
+
+// src/db/autoPurge.js
+var require_autoPurge = __commonJS({
+  "src/db/autoPurge.js"(exports2, module2) {
+    var cron = require("node-cron");
+    var logger = require_winston()(module2);
+    var { cleanupOldTransactions } = require_transactionStore();
+    var scheduledTask = null;
+    function startAutoPurge(daysToKeep = 7, cronSchedule = "0 2 * * 0") {
+      if (scheduledTask) {
+        logger.log({
+          level: "warn",
+          message: "Auto-purge already running. Stopping existing task first."
+        });
+        stopAutoPurge();
+      }
+      scheduledTask = cron.schedule(cronSchedule, () => {
+        logger.log({
+          level: "info",
+          message: `Running scheduled transaction cleanup (keeping last ${daysToKeep} days)`
+        });
+        try {
+          const deletedCount = cleanupOldTransactions(daysToKeep);
+          logger.log({
+            level: "info",
+            message: `Auto-purge completed: Deleted ${deletedCount} old transactions`
+          });
+        } catch (error) {
+          logger.log({
+            level: "error",
+            message: `Auto-purge failed: ${error.message}`
+          });
+        }
+      });
+      logger.log({
+        level: "info",
+        message: `Auto-purge scheduled: ${cronSchedule} (keeping last ${daysToKeep} days)`
+      });
+      return scheduledTask;
+    }
+    function stopAutoPurge() {
+      if (scheduledTask) {
+        scheduledTask.stop();
+        scheduledTask = null;
+        logger.log({
+          level: "info",
+          message: "Auto-purge stopped"
+        });
+      }
+    }
+    function isAutoPurgeRunning() {
+      return scheduledTask !== null;
+    }
+    module2.exports = {
+      startAutoPurge,
+      stopAutoPurge,
+      isAutoPurgeRunning
+    };
+  }
+});
+
+// src/db/transactionStore.js
+var require_transactionStore = __commonJS({
+  "src/db/transactionStore.js"(exports2, module2) {
+    var Database = require("better-sqlite3");
+    var path = require("path");
+    var fs = require("fs");
+    var logger = require_winston()(module2);
+    var db = null;
+    function initDatabase(dbPath, autoPurgeConfig = {}) {
+      try {
+        const defaultPath = path.join(__dirname, "../../transactions.db");
+        const finalPath = dbPath || defaultPath;
+        const dir = path.dirname(finalPath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        db = new Database(finalPath);
+        db.pragma("journal_mode = WAL");
+        const createTableSQL = `
+      CREATE TABLE IF NOT EXISTS transactions (
+        ecn TEXT PRIMARY KEY,
+        request_type TEXT NOT NULL,
+        request_payload TEXT,
+        request_hex TEXT,
+        request_timestamp INTEGER NOT NULL,
+        response_hex TEXT,
+        response_data TEXT,
+        response_timestamp INTEGER,
+        status TEXT DEFAULT 'PENDING',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `;
+        db.exec(createTableSQL);
+        db.exec("CREATE INDEX IF NOT EXISTS idx_request_timestamp ON transactions(request_timestamp DESC)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_status ON transactions(status)");
+        logger.log({
+          level: "info",
+          message: `Transaction database initialized at ${finalPath}`
+        });
+        const { enabled = true, daysToKeep = 7, schedule = "0 2 * * 0" } = autoPurgeConfig;
+        if (enabled) {
+          const autoPurge = require_autoPurge();
+          autoPurge.startAutoPurge(daysToKeep, schedule);
+        }
+        return db;
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to initialize database: ${error.message}`
+        });
+        throw error;
+      }
+    }
+    function getDatabase() {
+      if (!db) {
+        initDatabase();
+      }
+      return db;
+    }
+    function createTransaction(data) {
+      try {
+        const database = getDatabase();
+        const now = Date.now();
+        const stmt = database.prepare(`
+      INSERT INTO transactions (
+        ecn, request_type, request_payload, request_hex, 
+        request_timestamp, status, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const result = stmt.run(
+          data.ecn,
+          data.requestType,
+          JSON.stringify(data.requestPayload || {}),
+          data.requestHex,
+          now,
+          "PENDING",
+          now,
+          now
+        );
+        logger.log({
+          level: "info",
+          message: `Transaction created: ECN=${data.ecn}, Type=${data.requestType}`
+        });
+        return result;
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to create transaction: ${error.message}`
+        });
+        throw error;
+      }
+    }
+    function updateTransactionResponse(ecn, data) {
+      try {
+        const database = getDatabase();
+        const now = Date.now();
+        const stmt = database.prepare(`
+      UPDATE transactions 
+      SET response_hex = ?, 
+          response_data = ?, 
+          response_timestamp = ?,
+          status = ?,
+          updated_at = ?
+      WHERE ecn = ?
+    `);
+        const result = stmt.run(
+          data.responseHex,
+          JSON.stringify(data.responseData || {}),
+          now,
+          data.status || "COMPLETED",
+          now,
+          ecn
+        );
+        logger.log({
+          level: "info",
+          message: `Transaction updated: ECN=${ecn}, Status=${data.status || "COMPLETED"}`
+        });
+        return result;
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to update transaction: ${error.message}`
+        });
+        throw error;
+      }
+    }
+    function getTransactionByEcn(ecn) {
+      try {
+        const database = getDatabase();
+        const stmt = database.prepare("SELECT * FROM transactions WHERE ecn = ?");
+        const row = stmt.get(ecn);
+        if (row) {
+          row.request_payload = JSON.parse(row.request_payload || "{}");
+          row.response_data = JSON.parse(row.response_data || "{}");
+        }
+        return row;
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to get transaction: ${error.message}`
+        });
+        return null;
+      }
+    }
+    function getRecentTransactions(limit = 100) {
+      try {
+        const database = getDatabase();
+        const stmt = database.prepare(`
+      SELECT * FROM transactions 
+      ORDER BY request_timestamp DESC 
+      LIMIT ?
+    `);
+        const rows = stmt.all(limit);
+        return rows.map((row) => ({
+          ...row,
+          request_payload: JSON.parse(row.request_payload || "{}"),
+          response_data: JSON.parse(row.response_data || "{}")
+        }));
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to get recent transactions: ${error.message}`
+        });
+        return [];
+      }
+    }
+    function getTransactionsByStatus(status, limit = 100) {
+      try {
+        const database = getDatabase();
+        const stmt = database.prepare(`
+      SELECT * FROM transactions 
+      WHERE status = ?
+      ORDER BY request_timestamp DESC 
+      LIMIT ?
+    `);
+        const rows = stmt.all(status, limit);
+        return rows.map((row) => ({
+          ...row,
+          request_payload: JSON.parse(row.request_payload || "{}"),
+          response_data: JSON.parse(row.response_data || "{}")
+        }));
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to get transactions by status: ${error.message}`
+        });
+        return [];
+      }
+    }
+    function cleanupOldTransactions(daysToKeep = 90) {
+      try {
+        const database = getDatabase();
+        const cutoffTime = Date.now() - daysToKeep * 24 * 60 * 60 * 1e3;
+        const stmt = database.prepare("DELETE FROM transactions WHERE request_timestamp < ?");
+        const result = stmt.run(cutoffTime);
+        logger.log({
+          level: "info",
+          message: `Cleaned up ${result.changes} old transactions (older than ${daysToKeep} days)`
+        });
+        return result.changes;
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to cleanup old transactions: ${error.message}`
+        });
+        return 0;
+      }
+    }
+    function closeDatabase() {
+      if (db) {
+        db.close();
+        db = null;
+        logger.log({
+          level: "info",
+          message: "Database connection closed"
+        });
+      }
+    }
+    module2.exports = {
+      initDatabase,
+      getDatabase,
+      createTransaction,
+      updateTransactionResponse,
+      getTransactionByEcn,
+      getRecentTransactions,
+      getTransactionsByStatus,
+      cleanupOldTransactions,
+      closeDatabase,
+      // Auto-purge control functions
+      startAutoPurge: require_autoPurge().startAutoPurge,
+      stopAutoPurge: require_autoPurge().stopAutoPurge,
+      isAutoPurgeRunning: require_autoPurge().isAutoPurgeRunning
+    };
+  }
+});
+
+// src/payment/responseHandler.js
+var require_responseHandler = __commonJS({
+  "src/payment/responseHandler.js"(exports2, module2) {
+    var fs = require("fs");
+    var { Queue, Node } = require_queue();
+    var { sendMessage: sendMessage2 } = require_sendMessage();
+    var logger = require_winston()(module2);
+    var { requestCompletion } = require_httpRequest();
+    var {
+      statusParser,
+      logonParser,
+      netsPaymentParser,
+      creditPaymentParser,
+      jsonProcessor
+    } = require_parser();
+    var fw = require_manageConfig();
+    var { xorCalculation } = require_utils_helper();
+    var { updateTransactionResponse } = require_transactionStore();
+    var queue2 = new Queue();
+    module2.exports.terminalStatus = (ecn) => {
+      const length = queue2.size();
+      let fullHex = "";
+      for (let i = 0; i < length; i++) {
+        const node = queue2.dequeue();
+        fullHex += node.data.hex;
+      }
+      const status = statusParser(fullHex, ecn);
+      console.log(fullHex);
+      logger.log({
+        level: "info",
+        message: status
+      });
+      try {
+        updateTransactionResponse(ecn, {
+          responseHex: fullHex,
+          responseData: { status },
+          status: status ? "COMPLETED" : "FAILED"
+        });
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to update transaction: ${error.message}`
+        });
+      }
+      if (status) {
+        fw.updateConfig({ terminal_status: true });
+        sendMessage2("clientRoom", "STATUS_MESSAGE", {
+          success: true,
+          request: "status_scheck",
+          action: "COMPLETED"
+        });
+      } else {
+        fw.updateConfig({ terminal_status: false });
+        sendMessage2("clientRoom", "STATUS_MESSAGE", {
+          success: false,
+          request: "status_scheck",
+          action: "FAILED_TO_GET_THE_STATUS"
+        });
+      }
+    };
+    module2.exports.terminalLogon = (ecn) => {
+      const length = queue2.size();
+      let fullHex = "";
+      for (let i = 0; i < length; i++) {
+        const node = queue2.dequeue();
+        fullHex += node.data.hex;
+      }
+      console.log(fullHex);
+      const response = logonParser(fullHex, ecn);
+      try {
+        updateTransactionResponse(ecn, {
+          responseHex: fullHex,
+          responseData: response,
+          status: response.status ? "COMPLETED" : "FAILED"
+        });
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to update transaction: ${error.message}`
+        });
+      }
+      if (response.status) {
+        fw.updateConfig({ last_logon: /* @__PURE__ */ new Date() });
+        sendMessage2("clientRoom", "LOGON_MESSAGE", {
+          success: true,
+          request: "logon",
+          action: "COMPLETED"
+        });
+      } else {
+        sendMessage2("clientRoom", "LOGON_MESSAGE", {
+          success: false,
+          request: "logon",
+          action: "FAILED_TO_LOGON"
+        });
+      }
+    };
+    module2.exports.fetchFullDetails = () => {
+      const length = queue2.size();
+      let fullHex = "";
+      for (let i = 0; i < length; i++) {
+        const node = queue2.dequeue();
+        fullHex += node.data.hex;
+      }
+      return fullHex;
+    };
+    module2.exports.terminalPayment = (hexValue, ecn) => {
+      const parsedValue = netsPaymentParser(hexValue, ecn);
+      const response = jsonProcessor(parsedValue);
+      try {
+        updateTransactionResponse(ecn, {
+          responseHex: hexValue,
+          responseData: response,
+          status: response.translated?.status || "UNKNOWN"
+        });
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to update transaction: ${error.message}`
+        });
+      }
+      if (response.translated) {
+        if (response.translated.status == "APPROVED") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "COMPLETED"
+          });
+        }
+        if (response.translated.status == "TIME_OUT") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "RETRY"
+          });
+        }
+        if (response.translated.status == "USER_CANCELLED" || response.translated.status == "OUT_OF_PAPER" || response.translated.status == "INVALID_CARD" || response.translated.status == "DECLINED" || response.translated.status == "CARD_NOT_SUPPORTED") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "CANCELLED"
+          });
+        }
+      }
+    };
+    module2.exports.terminalCreditPayment = (hexValue, ecn) => {
+      const parsedValue = creditPaymentParser(hexValue, ecn);
+      const response = jsonProcessor(parsedValue);
+      try {
+        updateTransactionResponse(ecn, {
+          responseHex: hexValue,
+          responseData: response,
+          status: response.translated?.status || "UNKNOWN"
+        });
+      } catch (error) {
+        logger.log({
+          level: "error",
+          message: `Failed to update transaction: ${error.message}`
+        });
+      }
+      if (response.translated) {
+        if (response.translated.status == "APPROVED") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "COMPLETED"
+          });
+        }
+        if (response.translated.status == "TIME_OUT") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "RETRY"
+          });
+        }
+        if (response.translated.status == "USER_CANCELLED" || response.translated.status == "OUT_OF_PAPER" || response.translated.status == "INVALID_CARD" || response.translated.status == "DECLINED" || response.translated.status == "CARD_NOT_SUPPORTED") {
+          sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+            success: true,
+            response,
+            action: "CANCELLED"
+          });
+        }
+      }
+    };
+    module2.exports.verifyParser = (hex, ecn, type) => {
+      if (type == "LOGON") {
+        return logonParser(hex, ecn);
+      }
+      if (type == "PAYMENT") {
+        const response = netsPaymentParser(hex, ecn);
+        return jsonProcessor(response);
+      }
+      if (type == "CREDIT_PAYMENT") {
+        const response = creditPaymentParser(hex, ecn);
+        return jsonProcessor(response);
+      }
+    };
+    module2.exports.requestParser = (data, request, ecn) => {
+      try {
+        const hexValue = data.toString("hex");
+        queue2.enqueue(new Node({ hex: hexValue, alpha: hexValue.toAsciiString() }));
+      } catch (e) {
+      }
+    };
+    module2.exports.checkLrc = (hexValue) => {
+      const value = hexValue.substring(2, hexValue.length - 2);
+      const xor = xorCalculation(value);
+      const lrcCheck = hexValue.substring(hexValue.length - 2, hexValue.length);
+      console.log(`LRC Check: ${xor} === ${lrcCheck}`);
+      return xor == lrcCheck;
+    };
+  }
+});
+
+// src/payment/communication.js
+var require_communication = __commonJS({
+  "src/payment/communication.js"(exports2, module2) {
+    var { SerialPort, ReadlineParser } = require("serialport");
+    var {
+      generateStatusReq,
+      generateLogonRequest,
+      generatePaymentRequest
+    } = require_hexRequest();
+    var logger = require_winston()(module2);
+    var {
+      requestParser,
+      terminalPayment,
+      terminalCreditPayment,
+      terminalLogon,
+      terminalStatus,
+      fetchFullDetails,
+      checkLrc,
+      verifyParser
+    } = require_responseHandler();
+    var { sendMessage: sendMessage2 } = require_sendMessage();
+    var fw = require_manageConfig();
+    var { createTransaction } = require_transactionStore();
+    var { initialiseRequest } = require_httpRequest();
+    var requestType;
+    var calculated;
+    var isTimeOutset = false;
+    var MAX_COUNT = 3;
+    var WRONG_LRC_MAX_COUNT = 3;
+    var count;
+    var lrcCount;
+    var ackOrNack;
+    var requestPayload;
+    var ACK = Buffer.alloc(1, 6, "hex");
+    var NACK = Buffer.alloc(1, 21, "hex");
+    var config = fw.getConfig();
+    var triggerTimer = () => {
+      if (requestType == "STATUS_CHECK") {
+        setTimeout(() => {
+          isTimeOutset = false;
+          terminalStatus(calculated.ecn);
+        }, 3e3);
+      }
+      if (requestType == "LOGON") {
+        setTimeout(() => {
+          isTimeOutset = false;
+          terminalLogon(calculated.ecn);
+        }, 5e3);
+      }
+      if (requestType == "PAYMENT") {
+        setTimeout(() => {
+          isTimeOutset = false;
+          lrcCount--;
+          if (lrcCount >= 0) {
+            const hexValue = fetchFullDetails();
+            const lrcResponse = checkLrc(hexValue);
+            if (!lrcResponse) {
+              logger.log({
+                level: "info",
+                message: `Terminal send response data with wrong LRC, POS expected to send NACK`
+              });
+              global.port.write(NACK);
+            } else {
+              logger.log({
+                level: "info",
+                message: `Terminal resend response data with correct LRC, POS expected to send ACK`
+              });
+              global.port.write(ACK);
+              terminalPayment(hexValue, calculated.ecn);
+            }
+          } else {
+            sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+              success: true,
+              action: "APPROVED_FLAGGED"
+            });
+          }
+        }, 8e3);
+      }
+      if (requestType === "CREDIT_PAYMENT") {
+        setTimeout(() => {
+          isTimeOutset = false;
+          const hexValue = fetchFullDetails();
+          const lrcResponse = checkLrc(hexValue);
+          if (!lrcResponse) {
+            global.port.write(NACK);
+          } else {
+            global.port.write(ACK);
+            terminalCreditPayment(hexValue, calculated.ecn);
+          }
+        }, 8e3);
+      }
+    };
+    module2.exports.reset = () => {
+      count = MAX_COUNT;
+      lrcCount = WRONG_LRC_MAX_COUNT;
+      ackOrNack = null;
+    };
+    module2.exports.checkACKorNACK = () => {
+      setTimeout(() => {
+        if (ackOrNack == null) {
+          count--;
+          if (count >= 0) {
+            logger.log({
+              level: "info",
+              message: `POS send Purchase command, Terminal doesn't send any reply`
+            });
+            resendData();
+          } else {
+            sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+              success: true,
+              action: "TERMINAL_ERROR"
+            });
+          }
+        }
+      }, 2e3);
+    };
+    var resendData = () => {
+      if (requestType == "STATUS_CHECK") {
+        calculated = generateStatusReq();
+      }
+      if (requestType == "LOGON") {
+        calculated = generateLogonRequest();
+      }
+      if (requestType == "PAYMENT" || requestType === "CREDIT_PAYMENT") {
+        calculated = generatePaymentRequest(requestPayload);
+      }
+      global.port.write(calculated.buffer);
+      exports2.checkACKorNACK();
+    };
+    module2.exports.initialize = async () => {
+      if (!config.terminal || config.terminal === "enable") {
+        global.port = new SerialPort({
+          path: config.simulation ? config.simulationPort : config.com,
+          baudRate: 9600,
+          dataBits: 8,
+          stopBits: 1,
+          parity: "none"
+        });
+        global.port.on("data", (data) => {
+          console.log(data);
+          if (data.toString("hex").length == 2 && data.toString("hex") == "15") {
+            count--;
+            ackOrNack = data;
+            if (count >= 0) {
+              logger.log({
+                level: "info",
+                message: `POS send Purchase command, Terminal reply NACK`
+              });
+              resendData();
+            } else {
+              sendMessage2("clientRoom", "PAYMENT_MESSAGE", {
+                success: true,
+                action: "TERMINAL_ERROR"
+              });
+              return;
+            }
+          } else if (data.toString("hex").length == 2 && data.toString("hex") == "06") {
+            ackOrNack = data;
+          } else if (data.length > 2) {
+            global.port.write(ACK);
+            if (!isTimeOutset) {
+              isTimeOutset = true;
+              triggerTimer();
+            }
+            requestParser(data, requestType, calculated?.ecn);
+          }
+        });
+      }
+    };
+    module2.exports.sentToTerminal = (type, body) => {
+      requestType = type;
+      requestPayload = body;
+      if (requestType == "STATUS_CHECK") {
+        calculated = generateStatusReq();
+        try {
+          createTransaction({
+            ecn: calculated.ecn,
+            requestType,
+            requestPayload: null,
+            requestHex: calculated.buffer.toString("hex")
+          });
+        } catch (error) {
+          logger.log({
+            level: "error",
+            message: `Failed to store transaction: ${error.message}`
+          });
+        }
+        global.port.write(calculated.buffer);
+      }
+      if (requestType == "LOGON") {
+        calculated = generateLogonRequest();
+        try {
+          createTransaction({
+            ecn: calculated.ecn,
+            requestType,
+            requestPayload: null,
+            requestHex: calculated.buffer.toString("hex")
+          });
+        } catch (error) {
+          logger.log({
+            level: "error",
+            message: `Failed to store transaction: ${error.message}`
+          });
+        }
+        global.port.write(calculated.buffer);
+      }
+      if (requestType == "PAYMENT" || requestType == "CREDIT_PAYMENT") {
+        exports2.reset();
+        calculated = generatePaymentRequest(body);
+        console.log(calculated);
+        try {
+          createTransaction({
+            ecn: calculated.ecn,
+            requestType,
+            requestPayload: body,
+            requestHex: calculated.hexString
+          });
+        } catch (error) {
+          logger.log({
+            level: "error",
+            message: `Failed to store transaction: ${error.message}`
+          });
+        }
+        global.port.write(calculated.buffer);
+        exports2.checkACKorNACK();
+      }
+    };
+  }
+});
+
+// src/index.js
+var utilsHelper = require_utils_helper();
+var winston = require_winston();
+var manageConfig = require_manageConfig();
+var queue = require_queue();
+var sendMessage = require_sendMessage();
+var communication = require_communication();
+var hexRequest = require_hexRequest();
+var httpRequest = require_httpRequest();
+var parser = require_parser();
+var responseHandler = require_responseHandler();
+var transactionStore = require_transactionStore();
+module.exports = {
+  ...utilsHelper,
+  logger: winston,
+  manageConfig,
+  queue,
+  sendMessage,
+  communication,
+  hexRequest,
+  httpRequest,
+  parser,
+  responseHandler,
+  // Transaction store utilities
+  getTransactionByEcn: transactionStore.getTransactionByEcn,
+  getRecentTransactions: transactionStore.getRecentTransactions,
+  getTransactionsByStatus: transactionStore.getTransactionsByStatus,
+  cleanupOldTransactions: transactionStore.cleanupOldTransactions,
+  // Auto-purge control
+  startAutoPurge: transactionStore.startAutoPurge,
+  stopAutoPurge: transactionStore.stopAutoPurge,
+  isAutoPurgeRunning: transactionStore.isAutoPurgeRunning
+};