@achyutlabsau/vue-payment-gateway 0.0.1

package/dist/useLinkly-Cj-lTWld.js

@@ -0,0 +1,452 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { QSpinnerHourglass, Dialog } from "quasar";
+import { i as isNetworkError, a as isServerError, t as timeout, g as generateTransactionId } from "./index-C8vc_75e.js";
+import axios, { isAxiosError, HttpStatusCode } from "axios";
+import { v7 } from "uuid";
+import { e as environment, b as state } from "./state-0HFa2Xwz.js";
+const LINKLY_CONSTANTS = {
+  PATHS: {
+    TRANSACTION: "transaction",
+    PAIRING: "pairing/cloudpos",
+    TOKENS: "tokens/cloudpos",
+    REPRINT_RECEIPT: "reprintreceipt"
+  },
+  STORAGE_KEYS: {
+    PAIRING_SECRET: "___linklyPairingSecret",
+    REFRESH_TOKEN: "___linklyRefreshToken",
+    TOKEN_EXPIRY: "___linklyRefreshTokenExpiry",
+    LAST_TRANSACTION_ID: "___linklyLastTransactionId"
+  },
+  TIMEOUT: {
+    MAX_INTERVAL: 18e4,
+    // 3 minutes
+    BASE_INTERVAL: 2e3,
+    INTERVAL_INCREMENT: 1e3
+  },
+  URLS: {
+    DEVELOPMENT: {
+      AUTH_BASE: "https://auth.sandbox.cloud.pceftpos.com/v1/",
+      BASE: "https://rest.pos.sandbox.cloud.pceftpos.com/v1/sessions/"
+    },
+    PRODUCTION: {
+      AUTH_BASE: "https://auth.cloud.pceftpos.com/v1/",
+      BASE: "https://rest.pos.cloud.pceftpos.com/v1/sessions/"
+    }
+  }
+};
+const DEFAULT_REQUEST_PARAMS = {
+  async: false
+};
+const MAX_INTERVAL_TIME = 18e4;
+const BASE_INTERVAL = 2e3;
+const INTERVAL_INCREMENT = 1e3;
+const { PATHS, STORAGE_KEYS } = LINKLY_CONSTANTS;
+class LinklyPaymentGateway {
+  constructor() {
+    __publicField(this, "_api");
+    __publicField(this, "_authApi");
+    __publicField(this, "token", null);
+    __publicField(this, "tokenExpiry", null);
+    __publicField(this, "pairingSecret", null);
+    const urlConfig = environment.value === "production" ? LINKLY_CONSTANTS.URLS.PRODUCTION : LINKLY_CONSTANTS.URLS.DEVELOPMENT;
+    this._api = axios.create({
+      baseURL: urlConfig.BASE,
+      headers: { Accept: "application/json" }
+    });
+    this._authApi = axios.create({
+      baseURL: urlConfig.AUTH_BASE,
+      headers: { Accept: "application/json" }
+    });
+    this._setupInterceptors();
+    this._loadSavedCredentials();
+  }
+  _loadSavedCredentials() {
+    const { STORAGE_KEYS: STORAGE_KEYS2 } = LINKLY_CONSTANTS;
+    this.pairingSecret = localStorage.getItem(STORAGE_KEYS2.PAIRING_SECRET);
+    this.token = localStorage.getItem(STORAGE_KEYS2.REFRESH_TOKEN);
+    const savedTokenExpiry = localStorage.getItem(STORAGE_KEYS2.TOKEN_EXPIRY);
+    if (savedTokenExpiry) {
+      this.tokenExpiry = parseInt(savedTokenExpiry, 10);
+    }
+  }
+  _setupInterceptors() {
+    this._api.interceptors.request.use((config) => {
+      if (this.token) {
+        config.headers.Authorization = `Bearer ${this.token}`;
+      }
+      return config;
+    });
+  }
+  // New method to check and renew token if needed
+  async _ensureValidToken() {
+    if (!this.token || !this.tokenExpiry || this.tokenExpiry - Date.now() < 60 * 60 * 1e3) {
+      try {
+        if (this.pairingSecret) {
+          await this.getLinklyAuthToken(this.pairingSecret);
+        } else {
+          throw new Error("No valid authentication method available");
+        }
+      } catch (error) {
+        throw new Error("Failed to renew authentication token. Please check your Linkly account credentials.");
+      }
+    }
+  }
+  async pairPinpad(pairingData) {
+    var _a;
+    try {
+      const response = await this._authApi.post(PATHS.PAIRING, pairingData);
+      if (response.data.secret) {
+        this._savePairingSecret(response.data.secret);
+        await this.getLinklyAuthToken(response.data.secret);
+      }
+      return {
+        success: true,
+        secret: response.data.secret,
+        message: "Pinpad Paired successfully."
+      };
+    } catch (error) {
+      if (isAxiosError(error)) {
+        const status = (_a = error.response) == null ? void 0 : _a.status;
+        let message = "An unexpected error occurred during pinpad pairing.";
+        switch (status) {
+          case HttpStatusCode.Unauthorized:
+            message = "Looks like the username, password or pair code is no longer valid, or your account has been disabled. Try re-pairing the PIN pad or resetting the password.";
+            break;
+          case HttpStatusCode.BadRequest:
+            message = "Invalid request! Correct the request and try again.";
+            break;
+          case HttpStatusCode.RequestTimeout:
+            message = "Request Timeout. This should be rare: a transient error has occurred, possibly due to server overloading.";
+            break;
+          default:
+            if (isServerError(status)) {
+              message = "A server error has occurred. Wait a few seconds and attempt the request again. If the problem persists, contact Linkly Support.";
+            }
+        }
+        if (isNetworkError(error)) {
+          message = "You are not connected to the internet";
+        }
+        return {
+          success: false,
+          message,
+          secret: ""
+        };
+      }
+      return {
+        success: false,
+        message: "An unexpected error occurred.",
+        secret: ""
+      };
+    }
+  }
+  _savePairingSecret(secret) {
+    this.pairingSecret = secret;
+    localStorage.setItem(STORAGE_KEYS.PAIRING_SECRET, secret);
+  }
+  _clearCredentials() {
+    const { STORAGE_KEYS: STORAGE_KEYS2 } = LINKLY_CONSTANTS;
+    this.pairingSecret = null;
+    this.token = null;
+    this.tokenExpiry = null;
+    localStorage.removeItem(STORAGE_KEYS2.PAIRING_SECRET);
+    localStorage.removeItem(STORAGE_KEYS2.REFRESH_TOKEN);
+    localStorage.removeItem(STORAGE_KEYS2.TOKEN_EXPIRY);
+  }
+  async getLinklyAuthToken(secret) {
+    var _a;
+    const { STORAGE_KEYS: STORAGE_KEYS2 } = LINKLY_CONSTANTS;
+    try {
+      const tokenData = {
+        secret,
+        posName: state.productName,
+        posVersion: state.productVersion,
+        posId: state.posId,
+        posVendorId: state.productVendorName
+      };
+      const response = await this._authApi.post(PATHS.TOKENS, tokenData);
+      this.token = response.data.token;
+      this.tokenExpiry = Date.now() + response.data.expirySeconds * 1e3;
+      localStorage.setItem(STORAGE_KEYS2.REFRESH_TOKEN, response.data.token);
+      localStorage.setItem(STORAGE_KEYS2.TOKEN_EXPIRY, String(this.tokenExpiry));
+      return response.data;
+    } catch (error) {
+      console.error("Get token error:", error);
+      if (axios.isAxiosError(error) && ((_a = error.response) == null ? void 0 : _a.status) === HttpStatusCode.Unauthorized) {
+        this._clearCredentials();
+        throw new Error("Authentication failed. Pairing may have been reset or credentials changed.");
+      }
+      throw error;
+    }
+  }
+  async sendTransactionRequest(data) {
+    await this._ensureValidToken();
+    const sessionId = v7();
+    localStorage.setItem(STORAGE_KEYS.LAST_TRANSACTION_ID, sessionId);
+    try {
+      const response = await this._api.post(`${sessionId}/${PATHS.TRANSACTION}`, data, {
+        params: DEFAULT_REQUEST_PARAMS
+      });
+      if (response.status === HttpStatusCode.Accepted) {
+        return this.getTransactionStatus(sessionId);
+      }
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        const status = error.response.status;
+        if (status === HttpStatusCode.Unauthorized) {
+          try {
+            await this.getLinklyAuthToken(this.token);
+            return this.sendTransactionRequest(data);
+          } catch {
+            throw new Error("Failed to authenticate. Please check your Linkly account credentials.");
+          }
+        }
+        if (status === HttpStatusCode.RequestTimeout || isServerError(error)) {
+          return this.getTransactionStatus(sessionId);
+        }
+      }
+      throw error;
+    }
+  }
+  async getTransactionStatus(transactionId) {
+    let interval = BASE_INTERVAL;
+    const doRequest = async () => {
+      var _a;
+      try {
+        const response = await this._api.get(`${transactionId}/${PATHS.TRANSACTION}`, {
+          params: DEFAULT_REQUEST_PARAMS
+        });
+        if (response.status === HttpStatusCode.Accepted) {
+          return doRequest();
+        }
+        return response.data;
+      } catch (error) {
+        if (axios.isAxiosError(error)) {
+          const status = ((_a = error.response) == null ? void 0 : _a.status) ?? 0;
+          if (status === HttpStatusCode.RequestTimeout || isServerError(error)) {
+            if (interval < MAX_INTERVAL_TIME) {
+              await timeout(BASE_INTERVAL);
+              interval = Math.min(interval + INTERVAL_INCREMENT, MAX_INTERVAL_TIME);
+              return doRequest();
+            }
+            throw new Error("Unable to get the transaction details. Please contact service provider!");
+          } else if (status === HttpStatusCode.Unauthorized) {
+            await this.getLinklyAuthToken(this.token);
+            return doRequest();
+          }
+        }
+        throw error;
+      }
+    };
+    return doRequest();
+  }
+  async getLastTransactionStatus() {
+    const txnId = localStorage.getItem(STORAGE_KEYS.LAST_TRANSACTION_ID);
+    if (!txnId) {
+      throw new Error("No transaction found.");
+    }
+    return this.getTransactionStatus(txnId);
+  }
+  async reprintReceipt(data) {
+    const uuid = v7();
+    const res = await this._api.post(`${uuid}/${PATHS.REPRINT_RECEIPT}`, data, {
+      params: DEFAULT_REQUEST_PARAMS
+    });
+    return res.data;
+  }
+}
+var TransactionTypes = /* @__PURE__ */ ((TransactionTypes2) => {
+  TransactionTypes2["Purchase"] = "P";
+  TransactionTypes2["Refund"] = "R";
+  return TransactionTypes2;
+})(TransactionTypes || {});
+var CurrencyCodes = /* @__PURE__ */ ((CurrencyCodes2) => {
+  CurrencyCodes2["AustralianDollar"] = "AUD";
+  return CurrencyCodes2;
+})(CurrencyCodes || {});
+var ReceiptAutoPrint = /* @__PURE__ */ ((ReceiptAutoPrint2) => {
+  ReceiptAutoPrint2["ReturnToPOS"] = "0";
+  ReceiptAutoPrint2["MixedPrint"] = "7";
+  ReceiptAutoPrint2["AllReceiptsFromPINPad"] = "9";
+  return ReceiptAutoPrint2;
+})(ReceiptAutoPrint || {});
+var ResponseCodes = /* @__PURE__ */ ((ResponseCodes2) => {
+  ResponseCodes2["APPROVED"] = "00";
+  ResponseCodes2["Approved"] = "08";
+  ResponseCodes2["TXN_CANCELLED"] = "HD";
+  ResponseCodes2["INSUFFICIENT_FUND"] = "HB";
+  ResponseCodes2["GENERAL_DECLINE"] = "99";
+  ResponseCodes2["PINPAD_OFFLINE"] = "PF";
+  return ResponseCodes2;
+})(ResponseCodes || {});
+const dialogDefaultOpts = {
+  message: "Processing the payment...",
+  class: "text-lg",
+  progress: {
+    // spinner: QSpinnerClock,
+    spinner: QSpinnerHourglass,
+    color: "amber"
+  },
+  persistent: true,
+  html: true,
+  ok: false,
+  cancel: {
+    label: "Close",
+    noCaps: true,
+    color: "red",
+    outline: true
+  }
+};
+const updateDialog = (dialog, transactionOutcome) => {
+  if (transactionOutcome === TransactionOutcome.APPROVED) {
+    dialog.update({
+      title: "Success!",
+      class: "text-green-500",
+      progress: false,
+      message: '<div class="text-gray-800 text-base">Transaction Accepted!</div>'
+    });
+  } else if (transactionOutcome === TransactionOutcome.DECLINED) {
+    dialog.update({
+      title: "Failed!",
+      class: "text-red-500",
+      progress: false,
+      message: '<div class="text-gray-800 text-base">Transaction Declined!</div>'
+    });
+  } else if (transactionOutcome === TransactionOutcome.CANCELLED) {
+    dialog.update({
+      title: "Failed!",
+      class: "text-red-500",
+      progress: false,
+      message: '<div class="text-gray-800 text-base">Transaction Cancelled!</div>'
+    });
+  } else if (transactionOutcome === TransactionOutcome.UNKNOWN) {
+    dialog.update({
+      title: "Failed!",
+      class: "text-red-500",
+      progress: false,
+      message: '<div class="text-gray-800 text-base">Transaction Failed!</div>'
+    });
+  } else {
+    dialog.update({
+      title: "Failed!",
+      class: "text-red-500",
+      progress: false,
+      message: '<div class="text-gray-800 text-base">Transaction Failed!</div>'
+    });
+  }
+};
+var TransactionOutcome = /* @__PURE__ */ ((TransactionOutcome2) => {
+  TransactionOutcome2["APPROVED"] = "APPROVED";
+  TransactionOutcome2["CANCELLED"] = "CANCELLED";
+  TransactionOutcome2["DECLINED"] = "DECLINED";
+  TransactionOutcome2["UNKNOWN"] = "UNKNOWN";
+  return TransactionOutcome2;
+})(TransactionOutcome || {});
+const useLinkly = () => {
+  const linklyAPI = new LinklyPaymentGateway();
+  const pairPinpad = async (pairData) => {
+    const dialog = Dialog.create({ ...dialogDefaultOpts, message: "Pairing with the terminal..." });
+    const res = await linklyAPI.pairPinpad(pairData);
+    dialog.update({
+      title: res.success ? "Success!" : "Failed!",
+      class: res.success ? "text-green-500" : "text-red-500",
+      message: res.message,
+      progress: false
+    });
+    return res;
+  };
+  const _initiateTransaction = async (data, TxnType) => {
+    var _a, _b, _c;
+    const payload = {
+      Request: {
+        Merchant: "00",
+        Application: "00",
+        TxnRef: generateTransactionId(),
+        TxnType,
+        CurrencyCode: CurrencyCodes.AustralianDollar,
+        CutReceipt: data.CutReceipt,
+        AmtPurchase: data.AmtPurchase,
+        ReceiptAutoPrint: data.ReceiptAutoPrint
+      }
+    };
+    const dialog = Dialog.create({ ...dialogDefaultOpts });
+    try {
+      const res = await linklyAPI.sendTransactionRequest(payload);
+      if (((_a = res == null ? void 0 : res.Response) == null ? void 0 : _a.ResponseCode) === ResponseCodes.APPROVED || ((_b = res == null ? void 0 : res.Response) == null ? void 0 : _b.ResponseCode) === ResponseCodes.Approved) {
+        updateDialog(
+          dialog,
+          "APPROVED"
+          /* APPROVED */
+        );
+        return {
+          result: "APPROVED",
+          data: res.Response
+        };
+      }
+      if (((_c = res == null ? void 0 : res.Response) == null ? void 0 : _c.ResponseCode) === ResponseCodes.GENERAL_DECLINE) {
+        updateDialog(
+          dialog,
+          "DECLINED"
+          /* DECLINED */
+        );
+        return {
+          result: "DECLINED",
+          data: res.Response
+        };
+      }
+      updateDialog(
+        dialog,
+        "UNKNOWN"
+        /* UNKNOWN */
+      );
+      return {
+        result: "UNKNOWN",
+        data: res.Response
+      };
+    } catch (error) {
+      updateDialog(
+        dialog,
+        "UNKNOWN"
+        /* UNKNOWN */
+      );
+      throw error;
+    }
+  };
+  const initiatePurchase = async (data) => {
+    return _initiateTransaction(data, TransactionTypes.Purchase);
+  };
+  const initiateRefund = async (data) => {
+    return _initiateTransaction(data, TransactionTypes.Refund);
+  };
+  const reprintReceipt = async (txnRef) => {
+    const reprintPayload = {
+      Request: {
+        Merchant: "00",
+        Application: "00",
+        ReceiptAutoPrint: ReceiptAutoPrint.ReturnToPOS,
+        ReprintType: "2",
+        OriginalTxnRef: txnRef
+      }
+    };
+    return linklyAPI.reprintReceipt(reprintPayload);
+  };
+  return {
+    pairPinpad,
+    initiatePurchase,
+    initiateRefund,
+    reprintReceipt,
+    getTransactionBySessionId: linklyAPI.getTransactionStatus,
+    getLastTransaction: linklyAPI.getLastTransactionStatus
+  };
+};
+export {
+  CurrencyCodes as C,
+  ReceiptAutoPrint as R,
+  TransactionOutcome as T,
+  TransactionTypes as a,
+  ResponseCodes as b,
+  dialogDefaultOpts as d,
+  useLinkly as u
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@achyutlabsau/vue-payment-gateway",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    "./linkly": {
+      "types": "./dist/linkly.d.ts",
+      "import": "./dist/linkly.js"
+    },
+    "./smartpay": {
+      "types": "./dist/smartpay.d.ts",
+      "import": "./dist/smartpay.js"
+    },
+    "./tyro": {
+      "types": "./dist/tyro.d.ts",
+      "import": "./dist/tyro.js"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "uuid": "^11.x.x",
+    "axios": "^1.7.x",
+    "quasar": "^2.x.x",
+    "vue": "^3.5.x"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "@vitejs/plugin-vue": "^5.2.1",
+    "uuid": "^11.0.3",
+    "axios": "^1.7.9",
+    "quasar": "^2.x.x",
+    "typescript": "5.7.2",
+    "vite": "^6.0.3",
+    "vite-plugin-dts": "^4.3.0",
+    "vue": "^3.5.13",
+    "vue-tsc": "^2.1.10"
+  }
+}