@houlak/plexo-sdk 0.1.10 → 0.1.11-fx

package/lib/handler/PlexoHandler.d.ts

@@ -1,21 +1,32 @@
-import { Authorization, BaseServerResponse, CancelRequest, ClientSignedResponse, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, IssuerProcessor, PaymentRequest, ServerResponse, ServerSignedCallback, Session, Transaction, TransactionCallback } from '../sdk/index';
+import { Authorization, AuthorizationInfo, BaseServerResponse, CancelRequest, ClientSignedResponse, CodeRequest, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceModifyRequest, CommerceRequest, CreateBankInstrumentRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, IssuerProcessor, PaymentInstrument, PaymentRequest, Reference, Reserve, ReserveRequest, ServerResponse, Session, Transaction, TransactionCallback, TransactionCursor, TransactionQuery, TransactionsCSV } from '../sdk/index';
 import { BaseResponse } from './types/BaseResponse';
+import { FixedCustomData } from '../sdk/models/FixedCustomData';
 export declare const PlexoHandler: {
-    AddCommerce: (commerceRequest: CommerceRequest) => Promise<BaseResponse<Commerce>>;
-    AddIssuerCommerce: (issuerData: IssuerData) => Promise<BaseResponse<IssuerData>>;
-    GetCommerceIssuers: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<IssuerData[]>>;
-    GetCommerces: () => Promise<BaseResponse<Commerce[]>>;
-    DeleteCommerce: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
-    DeleteIssuerCommerce: (commerceIssuerIdRequest: CommerceIssuerIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
-    DeleteInstrument: (instrument: DeleteInstrumentRequest) => Promise<BaseResponse<BaseServerResponse>>;
-    GetSupportedIssuers: () => Promise<BaseResponse<IssuerInfo[]>>;
-    GetSupportedPaymentProcessors: () => Promise<BaseResponse<IssuerProcessor[]>>;
-    Authorize: (authorization: Authorization) => Promise<BaseResponse<Session>>;
-    Cancel: (cancellation: CancelRequest) => Promise<BaseResponse<Transaction>>;
-    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest) => Promise<BaseResponse<Session>>;
-    Purchase: (purchase: PaymentRequest) => Promise<BaseResponse<Transaction>>;
-    UnwrapInstrumentCallback: (instrumentCallback: ServerSignedCallback<InstrumentCallback>) => Promise<BaseResponse<InstrumentCallback>>;
-    UnwrapTransactionCallback: (transactionCallback: ServerSignedCallback<TransactionCallback>) => Promise<BaseResponse<TransactionCallback>>;
-    SignInstrumentCallback: (instrumentCallback: ServerResponse<InstrumentCallback>) => Promise<BaseResponse<ClientSignedResponse>>;
-    SignTransactionCallback: (transactionCallback: ServerResponse<TransactionCallback>) => Promise<BaseResponse<ClientSignedResponse>>;
+    AddCommerce: (commerceRequest: CommerceRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Commerce>>;
+    AddIssuerCommerce: (issuerData: IssuerData, fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerData>>;
+    DeleteCommerce: (commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<BaseServerResponse>>;
+    DeleteInstrument: (instrument: DeleteInstrumentRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<BaseServerResponse>>;
+    DeleteIssuerCommerce: (commerceIssuerIdRequest: CommerceIssuerIdRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<BaseServerResponse>>;
+    GetCommerceIssuers: (commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerData[]>>;
+    GetCommerces: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<Commerce[]>>;
+    GetSupportedIssuers: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessors: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerProcessor[]>>;
+    ModifyCommerce: (commerceModifyRequest: CommerceModifyRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Commerce>>;
+    GetInstruments: (authorizationInfo: AuthorizationInfo, fixedCustomData: FixedCustomData) => Promise<BaseResponse<PaymentInstrument[]>>;
+    SetDefaultCommerce: (commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<BaseServerResponse>>;
+    Authorize: (authorization: Authorization, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Session>>;
+    Cancel: (cancellation: CancelRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    CodeAction: (request: CodeRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    StartReserve: (payment: ReserveRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    Status: (payment: Reference, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Session>>;
+    ObtainCsvTransactions: (query: TransactionQuery, fixedCustomData: FixedCustomData) => Promise<BaseResponse<TransactionsCSV>>;
+    ObtainTransactions: (query: TransactionQuery, fixedCustomData: FixedCustomData) => Promise<BaseResponse<TransactionCursor>>;
+    Purchase: (purchase: PaymentRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    CreateBankInstrument: (request: CreateBankInstrumentRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<PaymentInstrument>>;
+    EndReserve: (reserve: Reserve, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Transaction>>;
+    UnwrapInstrumentCallback: (instrumentCallback: any, plexoUrl: string) => Promise<BaseResponse<InstrumentCallback>>;
+    UnwrapTransactionCallback: (transactionCallback: any, plexoUrl: string) => Promise<BaseResponse<TransactionCallback>>;
+    SignInstrumentCallback: (instrumentCallback: ServerResponse<InstrumentCallback>, plexoCertificatePath: string, plexoCertificatePassword: string) => Promise<BaseResponse<ClientSignedResponse>>;
+    SignTransactionCallback: (transactionCallback: any, plexoCertificatePath: string, plexoCertificatePassword: string) => Promise<BaseResponse<ClientSignedResponse>>;
 };

package/lib/handler/PlexoHandler.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) {
@@ -39,39 +50,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlexoHandler = void 0;
 var index_1 = require("../sdk/index");
 var evaluator_service_1 = require("./services/evaluator.service");
-var config_1 = require("../config/config");
-var PaymentGatewayMock_1 = require("../sdk/PaymentGatewayMock");
-var isTesting = config_1.config.env === 'TEST';
-var paymentGatewayClient = isTesting
-    ? new PaymentGatewayMock_1.PaymentGatewayMock()
-    : new index_1.PaymentGatewayClient();
-var AddCommerce = function (commerceRequest) { return __awaiter(void 0, void 0, void 0, function () {
+var utils_1 = require("../utils");
+var paymentGatewayClient = new index_1.PaymentGatewayClient();
+var AddCommerce = function (commerceRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var commerceResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.AddCommerceAsync(commerceRequest)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.AddCommerceAsync(commerceRequest, fixedCustomData)];
             case 1:
                 commerceResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceRequest, commerceResponse)];
         }
     });
 }); };
-var AddIssuerCommerce = function (issuerData) { return __awaiter(void 0, void 0, void 0, function () {
+var AddIssuerCommerce = function (issuerData, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var issuerResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.AddIssuerCommerceAsync(issuerData)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.AddIssuerCommerceAsync(issuerData, fixedCustomData)];
             case 1:
                 issuerResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(issuerData, issuerResponse)];
         }
     });
 }); };
-var DeleteCommerce = function (commerceIdRequest) { return __awaiter(void 0, void 0, void 0, function () {
+var DeleteCommerce = function (commerceIdRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var deleteResponse, wrappedDeleteResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteCommerceAsync(commerceIdRequest)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteCommerceAsync(commerceIdRequest, fixedCustomData)];
             case 1:
                 deleteResponse = _a.sent();
                 wrappedDeleteResponse = {
@@ -82,11 +89,11 @@ var DeleteCommerce = function (commerceIdRequest) { return __awaiter(void 0, voi
         }
     });
 }); };
-var DeleteInstrument = function (instrument) { return __awaiter(void 0, void 0, void 0, function () {
+var DeleteInstrument = function (instrument, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var deleteInstrumentResponse, wrappedDeleteResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteInstrumentAsync(instrument)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteInstrumentAsync(instrument, fixedCustomData)];
             case 1:
                 deleteInstrumentResponse = _a.sent();
                 wrappedDeleteResponse = {
@@ -97,11 +104,11 @@ var DeleteInstrument = function (instrument) { return __awaiter(void 0, void 0,
         }
     });
 }); };
-var DeleteIssuerCommerce = function (commerceIssuerIdRequest) { return __awaiter(void 0, void 0, void 0, function () {
+var DeleteIssuerCommerce = function (commerceIssuerIdRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var deleteIssuerResponse, wrappedDeleteResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteIssuerCommerceAsync(commerceIssuerIdRequest)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.DeleteIssuerCommerceAsync(commerceIssuerIdRequest, fixedCustomData)];
             case 1:
                 deleteIssuerResponse = _a.sent();
                 wrappedDeleteResponse = {
@@ -112,55 +119,92 @@ var DeleteIssuerCommerce = function (commerceIssuerIdRequest) { return __awaiter
         }
     });
 }); };
-var GetCommerceIssuers = function (commerceIdRequest) { return __awaiter(void 0, void 0, void 0, function () {
+var GetCommerceIssuers = function (commerceIdRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var commerceResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.GetCommerceIssuersAsync(commerceIdRequest)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetCommerceIssuersAsync(commerceIdRequest, fixedCustomData)];
             case 1:
                 commerceResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceIdRequest, commerceResponse)];
         }
     });
 }); };
-var GetCommerces = function () { return __awaiter(void 0, void 0, void 0, function () {
+var GetCommerces = function (fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var commercesResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.GetCommercesAsync()];
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetCommercesAsync(fixedCustomData)];
             case 1:
                 commercesResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(null, commercesResponse, true)];
         }
     });
 }); };
-var GetSupportedIssuers = function () { return __awaiter(void 0, void 0, void 0, function () {
+var GetSupportedIssuers = function (fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var issuersResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.GetSupportedIssuersAsync()];
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetSupportedIssuersAsync(fixedCustomData)];
             case 1:
                 issuersResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(null, issuersResponse, true)];
         }
     });
 }); };
-var GetSupportedPaymentProcessors = function () { return __awaiter(void 0, void 0, void 0, function () {
+var GetSupportedPaymentProcessors = function (fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var paymentProcessorsResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.GetSupportedPaymentProcessorsAsync()];
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetSupportedPaymentProcessorsAsync(fixedCustomData)];
             case 1:
                 paymentProcessorsResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(null, paymentProcessorsResponse, true)];
         }
     });
 }); };
-var Authorize = function (authorization) { return __awaiter(void 0, void 0, void 0, function () {
+var ModifyCommerce = function (commerceModifyRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var modifyCommerceResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ModifyCommerceAsync(commerceModifyRequest, fixedCustomData)];
+            case 1:
+                modifyCommerceResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceModifyRequest, modifyCommerceResponse)];
+        }
+    });
+}); };
+var GetInstruments = function (authorizationInfo, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var instrumentsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.GetInstrumentsAsync(authorizationInfo, fixedCustomData)];
+            case 1:
+                instrumentsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(authorizationInfo, instrumentsResponse)];
+        }
+    });
+}); };
+var SetDefaultCommerce = function (commerceIdRequest, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var setDefaultCommerceResponse, wrappedResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.SetDefaultCommerceAsync(commerceIdRequest, fixedCustomData)];
+            case 1:
+                setDefaultCommerceResponse = _a.sent();
+                wrappedResponse = {
+                    response: setDefaultCommerceResponse,
+                    resultCode: setDefaultCommerceResponse.resultCode,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceIdRequest, wrappedResponse)];
+        }
+    });
+}); };
+var Authorize = function (authorization, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var authorizationResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.AuthorizeAsync(authorization)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.AuthorizeAsync(authorization, fixedCustomData)];
             case 1:
                 authorizationResponse = _a.sent();
                 return [4 /*yield*/, evaluator_service_1.Evaluator.genericEvaluator(authorization, authorizationResponse)];
@@ -168,97 +212,203 @@ var Authorize = function (authorization) { return __awaiter(void 0, void 0, void
         }
     });
 }); };
-var Cancel = function (cancellation) { return __awaiter(void 0, void 0, void 0, function () {
+var Cancel = function (cancellation, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var transactionResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.CancelAsync(cancellation)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.CancelAsync(cancellation, fixedCustomData)];
             case 1:
                 transactionResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(cancellation, transactionResponse, 'Cancellation', index_1.TransactionType.Cancel)];
         }
     });
 }); };
-var ExpressCheckout = function (expressCheckout) { return __awaiter(void 0, void 0, void 0, function () {
+var CodeAction = function (request, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var codeActionResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.CodeActionAsync(request, fixedCustomData)];
+            case 1:
+                codeActionResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, codeActionResponse)];
+        }
+    });
+}); };
+var StartReserve = function (payment, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var reserveResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.StartReserveAsync(payment, fixedCustomData)];
+            case 1:
+                reserveResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(payment, reserveResponse, 'Reserve', index_1.TransactionType.Reserve)];
+        }
+    });
+}); };
+var Status = function (payment, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var statusResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.StatusAsync(payment, fixedCustomData)];
+            case 1:
+                statusResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(payment, statusResponse)];
+        }
+    });
+}); };
+var ExpressCheckout = function (expressCheckout, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var expressCheckoutResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.ExpressCheckoutAsync(expressCheckout)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.ExpressCheckoutAsync(expressCheckout, fixedCustomData)];
             case 1:
                 expressCheckoutResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(expressCheckout, expressCheckoutResponse)];
         }
     });
 }); };
-var Purchase = function (purchase) { return __awaiter(void 0, void 0, void 0, function () {
+var ObtainCsvTransactions = function (query, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var csvTransactionsStringResponse, csvTransactionsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ObtainCsvTransactionsAsync(query, fixedCustomData)];
+            case 1:
+                csvTransactionsStringResponse = _a.sent();
+                csvTransactionsResponse = __assign(__assign({}, csvTransactionsStringResponse), { response: {
+                        csv: csvTransactionsStringResponse.response,
+                    } });
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(query, csvTransactionsResponse)];
+        }
+    });
+}); };
+var ObtainTransactions = function (query, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var transactionsResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.ObtainTransactionsAsync(query, fixedCustomData)];
+            case 1:
+                transactionsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(query, transactionsResponse)];
+        }
+    });
+}); };
+var Purchase = function (purchase, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
     var purchaseResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.PurchaseAsync(purchase)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.PurchaseAsync(purchase, fixedCustomData)];
             case 1:
                 purchaseResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(purchase, purchaseResponse, 'Purchase', index_1.TransactionType.Purchase)];
         }
     });
 }); };
-var UnwrapInstrumentCallback = function (instrumentCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var instrumentCallbackResponse;
+var CreateBankInstrument = function (request, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var bankInstrumentResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.UnwrapInstrumentCallbackAsync(instrumentCallback)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.CreateBankInstrumentAsync(request, fixedCustomData)];
+            case 1:
+                bankInstrumentResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, bankInstrumentResponse)];
+        }
+    });
+}); };
+var EndReserve = function (reserve, fixedCustomData) { return __awaiter(void 0, void 0, void 0, function () {
+    var endReserveResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, paymentGatewayClient.EndReserveAsync(reserve, fixedCustomData)];
+            case 1:
+                endReserveResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(reserve, endReserveResponse, 'Reserve', index_1.TransactionType.Reserve)];
+        }
+    });
+}); };
+var UnwrapInstrumentCallback = function (instrumentCallback, plexoUrl) { return __awaiter(void 0, void 0, void 0, function () {
+    var instrumentCallbackCamelCase, instrumentCallbackResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                instrumentCallbackCamelCase = utils_1.caseUtils.toCamelKeys(instrumentCallback);
+                return [4 /*yield*/, paymentGatewayClient.UnwrapInstrumentCallbackAsync(instrumentCallbackCamelCase, plexoUrl)];
             case 1:
                 instrumentCallbackResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, instrumentCallbackResponse)];
         }
     });
 }); };
-var UnwrapTransactionCallback = function (transactionCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var transactionCallbackResponse;
+var UnwrapTransactionCallback = function (transactionCallback, plexoUrl) { return __awaiter(void 0, void 0, void 0, function () {
+    var transactionCallbackCamelCase, transactionCallbackResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.UnwrapTransactionCallbackAsync(transactionCallback)];
+            case 0:
+                transactionCallbackCamelCase = utils_1.caseUtils.toCamelKeys(transactionCallback);
+                return [4 /*yield*/, paymentGatewayClient.UnwrapTransactionCallbackAsync(transactionCallbackCamelCase, plexoUrl)];
             case 1:
                 transactionCallbackResponse = _a.sent();
                 return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, transactionCallbackResponse)];
         }
     });
 }); };
-var SignInstrumentCallback = function (instrumentCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var signInstrumentCallbackResponse;
+var SignInstrumentCallback = function (instrumentCallback, plexoCertificatePath, plexoCertificatePassword) { return __awaiter(void 0, void 0, void 0, function () {
+    var signInstrumentCallbackResponse, serverResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.SignInstrumentCallback(instrumentCallback)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.SignInstrumentCallback(instrumentCallback, plexoCertificatePath, plexoCertificatePassword)];
             case 1:
                 signInstrumentCallbackResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, signInstrumentCallbackResponse)];
+                serverResponse = {
+                    response: signInstrumentCallbackResponse,
+                    resultCode: signInstrumentCallbackResponse.object.object.resultCode,
+                    errorMessage: signInstrumentCallbackResponse.object.object.errorMessage,
+                    i18ErrorMessages: signInstrumentCallbackResponse.object.object.i18ErrorMessages,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(instrumentCallback, serverResponse)];
         }
     });
 }); };
-var SignTransactionCallback = function (transactionCallback) { return __awaiter(void 0, void 0, void 0, function () {
-    var signTransactionCallbackResponse;
+var SignTransactionCallback = function (transactionCallback, plexoCertificatePath, plexoCertificatePassword) { return __awaiter(void 0, void 0, void 0, function () {
+    var signTransactionCallbackResponse, serverResponse;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, paymentGatewayClient.SignTransactionCallback(transactionCallback)];
+            case 0: return [4 /*yield*/, paymentGatewayClient.SignTransactionCallback(transactionCallback, plexoCertificatePath, plexoCertificatePassword)];
             case 1:
                 signTransactionCallbackResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, signTransactionCallbackResponse)];
+                serverResponse = {
+                    response: signTransactionCallbackResponse,
+                    resultCode: signTransactionCallbackResponse.object.object.resultCode,
+                    errorMessage: signTransactionCallbackResponse.object.object.errorMessage,
+                    i18ErrorMessages: signTransactionCallbackResponse.object.object.i18ErrorMessages,
+                };
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(transactionCallback, serverResponse)];
         }
     });
 }); };
 exports.PlexoHandler = {
     AddCommerce: AddCommerce,
     AddIssuerCommerce: AddIssuerCommerce,
-    GetCommerceIssuers: GetCommerceIssuers,
-    GetCommerces: GetCommerces,
     DeleteCommerce: DeleteCommerce,
-    DeleteIssuerCommerce: DeleteIssuerCommerce,
     DeleteInstrument: DeleteInstrument,
+    DeleteIssuerCommerce: DeleteIssuerCommerce,
+    GetCommerceIssuers: GetCommerceIssuers,
+    GetCommerces: GetCommerces,
     GetSupportedIssuers: GetSupportedIssuers,
     GetSupportedPaymentProcessors: GetSupportedPaymentProcessors,
+    ModifyCommerce: ModifyCommerce,
+    GetInstruments: GetInstruments,
+    SetDefaultCommerce: SetDefaultCommerce,
     Authorize: Authorize,
     Cancel: Cancel,
+    CodeAction: CodeAction,
+    StartReserve: StartReserve,
+    Status: Status,
     ExpressCheckout: ExpressCheckout,
+    ObtainCsvTransactions: ObtainCsvTransactions,
+    ObtainTransactions: ObtainTransactions,
     Purchase: Purchase,
+    CreateBankInstrument: CreateBankInstrument,
+    EndReserve: EndReserve,
     UnwrapInstrumentCallback: UnwrapInstrumentCallback,
     UnwrapTransactionCallback: UnwrapTransactionCallback,
     SignInstrumentCallback: SignInstrumentCallback,

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

@@ -105,14 +105,14 @@ var transactionEvaluator = function (request, response, transactionName, transac
         // wether or not we want to log successful transactions 🤔
         return new BaseResponse_1.BaseResponse(undefined, true, 'Success', response.response);
     }
-    logger_lib_1.default.debug({
+    logger_lib_1.default.info({
         transactionName: transactionName,
         plexoOrTransactionError: plexoOrTransactionError,
         errorCode: errorCode,
         errorMessage: errorMessage,
     });
-    logger_lib_1.default.debug({ request: request }, 'Request --> ');
-    logger_lib_1.default.debug({ response: response }, 'Response --> ');
+    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);
 };
 exports.Evaluator = { genericEvaluator: genericEvaluator, transactionEvaluator: transactionEvaluator };

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { PlexoHandler } from './handler/PlexoHandler';
 export * as ModelsSDK from './sdk/models/IndexSDK';
+export * as ModelsAPI from './sdk/models/webhook';

package/lib/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelsSDK = exports.PlexoHandler = void 0;
+exports.ModelsAPI = exports.ModelsSDK = exports.PlexoHandler = void 0;
 var PlexoHandler_1 = require("./handler/PlexoHandler");
 Object.defineProperty(exports, "PlexoHandler", { enumerable: true, get: function () { return PlexoHandler_1.PlexoHandler; } });
+// Model for transaction callback (WS Service)
 exports.ModelsSDK = require("./sdk/models/IndexSDK");
+// Model for plexo webhook (API)
+exports.ModelsAPI = require("./sdk/models/webhook");

package/lib/lib/logger.lib.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var pino_1 = require("pino");
 var config_1 = require("../config/config");
-var transport = false;
+var transport = null;
 if (['LOCAL', 'TEST'].includes(config_1.config.env)) {
     transport = {
         target: 'pino-pretty',
         options: {
-            colorize: true
-        }
+            colorize: true,
+        },
     };
 }
 var logger = (0, pino_1.default)({

package/lib/sdk/IPaymentGatewayClient.d.ts

@@ -1,31 +1,32 @@
 import { IssuerProcessor } from '.';
+import { FixedCustomData } from './models/FixedCustomData';
 import { Authorization, AuthorizationInfo, CancelRequest, ClientSignedResponse, CodeRequest, Commerce, CommerceIdRequest, CommerceIssuerIdRequest, CommerceModifyRequest, CommerceRequest, CreateBankInstrumentRequest, DeleteInstrumentRequest, ExpressCheckoutRequest, InstrumentCallback, IssuerData, IssuerInfo, PaymentRequest, PaymentInstrument, Reference, Reserve, ReserveRequest, BaseServerResponse, ServerResponse, ServerSignedCallback, Session, Transaction, TransactionCallback, TransactionCursor, TransactionQuery } from './models/IndexSDK';
 export interface IPaymentGatewayClient {
-    AddCommerceAsync(commerce: CommerceRequest): Promise<ServerResponse<Commerce>>;
-    AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>>;
-    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
-    DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<BaseServerResponse>;
-    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest): Promise<BaseServerResponse>;
-    GetCommerceIssuersAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<IssuerData[]>>;
-    GetCommercesAsync(): Promise<ServerResponse<Commerce[]>>;
-    GetSupportedIssuersAsync(): Promise<ServerResponse<IssuerInfo[]>>;
-    GetSupportedPaymentProcessorsAsync(): Promise<ServerResponse<IssuerProcessor[]>>;
-    ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest): Promise<ServerResponse<Commerce>>;
-    GetInstrumentsAsync(authorizationInfo: AuthorizationInfo): Promise<ServerResponse<PaymentInstrument[]>>;
-    SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
-    AuthorizeAsync(authorization: Authorization): Promise<ServerResponse<Session>>;
-    CancelAsync(cancel: CancelRequest): Promise<ServerResponse<Transaction>>;
-    CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>>;
-    StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>>;
-    StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>>;
-    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest): Promise<ServerResponse<Session>>;
-    ObtainCsvTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<string>>;
-    ObtainTransactionsAsync(query: TransactionQuery): Promise<ServerResponse<TransactionCursor>>;
-    PurchaseAsync(payment: PaymentRequest): Promise<ServerResponse<Transaction>>;
-    CreateBankInstrumentAsync(request: CreateBankInstrumentRequest): Promise<ServerResponse<PaymentInstrument>>;
-    EndReserveAsync(reserve: Reserve): Promise<ServerResponse<Transaction>>;
-    UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>): Promise<ServerResponse<InstrumentCallback>>;
-    UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>): Promise<ServerResponse<TransactionCallback>>;
-    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>): Promise<ServerResponse<ClientSignedResponse>>;
-    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>): Promise<ServerResponse<ClientSignedResponse>>;
+    AddCommerceAsync(commerce: CommerceRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
+    AddIssuerCommerceAsync(issuerData: IssuerData, fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerData>>;
+    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<BaseServerResponse>;
+    DeleteInstrumentAsync(info: DeleteInstrumentRequest, fixedCustomData: FixedCustomData): Promise<BaseServerResponse>;
+    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest, fixedCustomData: FixedCustomData): Promise<BaseServerResponse>;
+    GetCommerceIssuersAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerData[]>>;
+    GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>>;
+    GetSupportedIssuersAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessorsAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerProcessor[]>>;
+    ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce>>;
+    GetInstrumentsAsync(authorizationInfo: AuthorizationInfo, fixedCustomData: FixedCustomData): Promise<ServerResponse<PaymentInstrument[]>>;
+    SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest, fixedCustomData: FixedCustomData): Promise<BaseServerResponse>;
+    AuthorizeAsync(authorization: Authorization, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
+    CancelAsync(cancel: CancelRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    CodeActionAsync(request: CodeRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    StartReserveAsync(payment: ReserveRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    StatusAsync(payment: Reference, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
+    ObtainCsvTransactionsAsync(query: TransactionQuery, fixedCustomData: FixedCustomData): Promise<ServerResponse<string>>;
+    ObtainTransactionsAsync(query: TransactionQuery, fixedCustomData: FixedCustomData): Promise<ServerResponse<TransactionCursor>>;
+    PurchaseAsync(payment: PaymentRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    CreateBankInstrumentAsync(request: CreateBankInstrumentRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<PaymentInstrument>>;
+    EndReserveAsync(reserve: Reserve, fixedCustomData: FixedCustomData): Promise<ServerResponse<Transaction>>;
+    UnwrapInstrumentCallbackAsync(serverSignedInstrumentCallback: ServerSignedCallback<InstrumentCallback>, plexoUrl: string): Promise<ServerResponse<InstrumentCallback>>;
+    UnwrapTransactionCallbackAsync(serverSignedTransactionCallback: ServerSignedCallback<TransactionCallback>, plexoUrl: string): Promise<ServerResponse<TransactionCallback>>;
+    SignInstrumentCallback(serverResponse: ServerResponse<InstrumentCallback>, plexoCertificatePath: string, plexoCertificatePassword: string): Promise<ClientSignedResponse>;
+    SignTransactionCallback(serverResponse: ServerResponse<TransactionCallback>, plexoCertificatePath: string, plexoCertificatePassword: string): Promise<ClientSignedResponse>;
 }