@houlak/plexo-sdk 1.0.23 → 1.0.24

package/lib/handler/services/evaluator.service.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -67,6 +78,85 @@ var getTransactionStatus = function (transaction, transactionType) {
         };
     }
 };
+/**
+ * This function validates the response format to unify the response structure
+ * and to avoid errors when accessing the response properties.
+ */
+var validateTransactionResponse = function (request, response, transactionName) {
+    var _a;
+    var parsedResponse = response;
+    var mockString = 'nan-nananan-nana-nanana';
+    var isPurchase = transactionName === 'Purchase';
+    // This is a list of result codes that are considered incomplete responses
+    // and should be handled differently.
+    // 9: The Payment instrument is disabled.
+    // 10: The Payment instrument is expired.
+    // 15: The Payment instrument does not exist.
+    var resultCodesWithIncompleteResponse = [9, 10, 15];
+    var isIncompleteResponse = resultCodesWithIncompleteResponse.includes(response.resultCode);
+    if (isPurchase && isIncompleteResponse) {
+        var paymentRequest = request;
+        var currencyMap = {
+            1: { currencyId: 1, name: 'Peso', plural: 'Pesos', symbol: '$' },
+            2: { currencyId: 2, name: 'Dólar', plural: 'Dólares', symbol: 'USD' },
+        };
+        var currencyData = currencyMap[paymentRequest.currencyId] || {
+            currencyId: paymentRequest.currencyId,
+            name: 'Unknown',
+            plural: 'Unknown',
+            symbol: '?',
+        };
+        parsedResponse = __assign(__assign({}, response), { response: {
+                currentState: index_1.TransactionType.Purchase,
+                amount: paymentRequest.items[0].amount,
+                commerce: {
+                    commerceId: (_a = paymentRequest.optionalCommerceId) !== null && _a !== void 0 ? _a : 0,
+                    name: mockString,
+                },
+                currency: currencyData,
+                fieldInformation: {
+                    address: mockString,
+                    aggregatorId: mockString,
+                    birthDate: mockString,
+                    cardIssuer: mockString,
+                    city: mockString,
+                    commerceCity: mockString,
+                    commerceCountry: mockString,
+                    commerceRut: mockString,
+                    cybersourceDeviceFingerprint: mockString,
+                    email: mockString,
+                    expiration: mockString,
+                    firstName: mockString,
+                    lastName: mockString,
+                    mcc: mockString,
+                    name: mockString,
+                    paymentFacilitatorIntegratorId: mockString,
+                    paymentProcessorId: mockString,
+                    provider: mockString,
+                    providerCommerceNumber: mockString,
+                    softDescriptor: mockString,
+                    subCommerceAddress: mockString,
+                    subMerchantId: mockString,
+                },
+                instrumentToken: paymentRequest.paymentInstrumentInput.instrumentToken,
+                instrumentName: mockString,
+                installments: paymentRequest.installments,
+                transactionId: mockString,
+                isAnonymous: false,
+                isAsyncPayment: false,
+                transactions: {
+                    purchase: {
+                        clientReferenceId: paymentRequest.clientReferenceId,
+                        clientMetadata: paymentRequest.optionalMetadata,
+                        status: index_1.TransactionResult.Denied,
+                        transactionCode: response.resultCode,
+                        transactionResultText: response.errorMessage,
+                    },
+                },
+            } });
+    }
+    return parsedResponse;
+};
 var genericEvaluator = function (request, response, withoutParams) {
     if (withoutParams === void 0) { withoutParams = false; }
     return __awaiter(void 0, void 0, void 0, function () {
@@ -88,14 +178,20 @@ var genericEvaluator = function (request, response, withoutParams) {
     });
 };
 var transactionEvaluator = function (request, response, transactionName, transactionType) {
+    logger_lib_1.default.info({ request: request, response: response, transactionName: transactionName }, '[PX-SDK] Transaction Evaluator');
+    if (!response) {
+        return new BaseResponse_1.BaseResponse(plexo_error_enum_1.PlexoErrorEnum.PlexoUnknownError, false, "Plexo unknown error on: ".concat(transactionName), response);
+    }
+    // Validate the response format to unify the response structure
+    var parsedResponse = validateTransactionResponse(request, response, transactionName);
     var errorCode = plexo_error_enum_1.PlexoErrorEnum.Generic;
     var errorMessage = '';
     var plexoOrTransactionError = '';
     var resultCode = response.resultCode;
-    var transactionStatus = getTransactionStatus(response === null || response === void 0 ? void 0 : response.response, transactionType);
+    var transactionStatus = getTransactionStatus(parsedResponse.response, transactionType);
     if (resultCode !== index_1.ResultCodes.Ok) {
-        errorCode = response.resultCode;
-        errorMessage = response.errorMessage;
+        errorCode = parsedResponse.resultCode;
+        errorMessage = parsedResponse.errorMessage;
         plexoOrTransactionError = 'PLEXO ERROR';
     }
     if (transactionStatus.status !== index_1.TransactionResult[index_1.TransactionResult.Ok] &&
@@ -109,7 +205,7 @@ var transactionEvaluator = function (request, response, transactionName, transac
         transactionStatus.status === index_1.TransactionResult[index_1.TransactionResult.Pending]) {
         // Maybe we should add some project configuration to define
         // wether or not we want to log successful transactions 🤔
-        return new BaseResponse_1.BaseResponse(undefined, true, 'Success', response.response);
+        return new BaseResponse_1.BaseResponse(undefined, true, 'Success', parsedResponse.response);
     }
     logger_lib_1.default.info({
         transactionName: transactionName,
@@ -117,8 +213,6 @@ var transactionEvaluator = function (request, response, transactionName, transac
         errorCode: errorCode,
         errorMessage: errorMessage,
     });
-    logger_lib_1.default.info({ request: request }, 'Request --> ');
-    logger_lib_1.default.info({ response: response }, 'Response --> ');
-    return new BaseResponse_1.BaseResponse(errorCode, false, errorMessage, response.response);
+    return new BaseResponse_1.BaseResponse(errorCode, false, errorMessage, parsedResponse.response);
 };
 exports.Evaluator = { genericEvaluator: genericEvaluator, transactionEvaluator: transactionEvaluator };

package/lib/lib/logger.lib.d.ts

@@ -1,10 +1,2 @@
-declare const logger: import("pino").Logger<{
-    level: string;
-    base: null;
-    nestedKey: string;
-    transport: any;
-    serializers: {
-        data: (data: any | Error) => any;
-    };
-}>;
+declare const logger: import("pino").Logger<never>;
 export default logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houlak/plexo-sdk",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "Node SDK for Plexo payment services",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",