@houlak/plexo-sdk 0.1.7 → 0.1.8-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>>;
+    AddCommerce: (commerceRequest: CommerceRequest, fixedCustomData: FixedCustomData) => 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[]>>;
+    DeleteIssuerCommerce: (commerceIssuerIdRequest: CommerceIssuerIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
+    GetCommerceIssuers: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<IssuerData[]>>;
+    GetCommerces: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<Commerce[]>>;
+    GetSupportedIssuers: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessors: (fixedCustomData: FixedCustomData) => Promise<BaseResponse<IssuerProcessor[]>>;
+    ModifyCommerce: (commerceModifyRequest: CommerceModifyRequest) => Promise<BaseResponse<Commerce>>;
+    GetInstruments: (authorizationInfo: AuthorizationInfo) => Promise<BaseResponse<PaymentInstrument[]>>;
+    SetDefaultCommerce: (commerceIdRequest: CommerceIdRequest) => Promise<BaseResponse<BaseServerResponse>>;
     Authorize: (authorization: Authorization) => Promise<BaseResponse<Session>>;
     Cancel: (cancellation: CancelRequest) => Promise<BaseResponse<Transaction>>;
-    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest) => Promise<BaseResponse<Session>>;
+    CodeAction: (request: CodeRequest) => Promise<BaseResponse<Transaction>>;
+    StartReserve: (payment: ReserveRequest) => Promise<BaseResponse<Transaction>>;
+    Status: (payment: Reference) => Promise<BaseResponse<Transaction>>;
+    ExpressCheckout: (expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData) => Promise<BaseResponse<Session>>;
+    ObtainCsvTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionsCSV>>;
+    ObtainTransactions: (query: TransactionQuery) => Promise<BaseResponse<TransactionCursor>>;
     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>>;
+    CreateBankInstrument: (request: CreateBankInstrumentRequest) => Promise<BaseResponse<PaymentInstrument>>;
+    EndReserve: (reserve: Reserve) => 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,17 +50,13 @@ 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)];
@@ -123,39 +130,76 @@ var GetCommerceIssuers = function (commerceIdRequest) { return __awaiter(void 0,
         }
     });
 }); };
-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 ModifyCommerce = function (commerceModifyRequest) { 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)];
+            case 1:
+                modifyCommerceResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(commerceModifyRequest, modifyCommerceResponse)];
+        }
+    });
+}); };
+var GetInstruments = function (authorizationInfo) { 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)];
+            case 1:
+                instrumentsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(authorizationInfo, instrumentsResponse)];
+        }
+    });
+}); };
+var SetDefaultCommerce = function (commerceIdRequest) { 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)];
+            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) { return __awaiter(void 0, void 0, void 0, function () {
     var authorizationResponse;
     return __generator(this, function (_a) {
@@ -175,21 +219,79 @@ var Cancel = function (cancellation) { return __awaiter(void 0, void 0, void 0,
             case 0: return [4 /*yield*/, paymentGatewayClient.CancelAsync(cancellation)];
             case 1:
                 transactionResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(cancellation, transactionResponse, 'Cancellation', index_1.TransactionType.cancel)];
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(cancellation, transactionResponse, 'Cancellation', index_1.TransactionType.Cancel)];
+        }
+    });
+}); };
+var CodeAction = function (request) { 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)];
+            case 1:
+                codeActionResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, codeActionResponse)];
         }
     });
 }); };
-var ExpressCheckout = function (expressCheckout) { return __awaiter(void 0, void 0, void 0, function () {
+var StartReserve = function (payment) { 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)];
+            case 1:
+                reserveResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(payment, reserveResponse, 'Reserve', index_1.TransactionType.Reserve)];
+        }
+    });
+}); };
+var Status = function (payment) { 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)];
+            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 ObtainCsvTransactions = function (query) { 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)];
+            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) { 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)];
+            case 1:
+                transactionsResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(query, transactionsResponse)];
+        }
+    });
+}); };
 var Purchase = function (purchase) { return __awaiter(void 0, void 0, void 0, function () {
     var purchaseResponse;
     return __generator(this, function (_a) {
@@ -197,68 +299,116 @@ var Purchase = function (purchase) { return __awaiter(void 0, void 0, void 0, fu
             case 0: return [4 /*yield*/, paymentGatewayClient.PurchaseAsync(purchase)];
             case 1:
                 purchaseResponse = _a.sent();
-                return [2 /*return*/, evaluator_service_1.Evaluator.transactionEvaluator(purchase, purchaseResponse, 'Purchase', index_1.TransactionType.purchase)];
+                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) { 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)];
+            case 1:
+                bankInstrumentResponse = _a.sent();
+                return [2 /*return*/, evaluator_service_1.Evaluator.genericEvaluator(request, bankInstrumentResponse)];
+        }
+    });
+}); };
+var EndReserve = function (reserve) { 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)];
+            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

@@ -42,19 +42,19 @@ var index_1 = require("../../sdk/index");
 var plexo_error_enum_1 = require("../../sdk/enums/plexo-error-enum");
 var BaseResponse_1 = require("../types/BaseResponse");
 var getTransactionStatus = function (transaction, transactionType) {
-    if (transactionType === index_1.TransactionType.cancel) {
+    if (transactionType === index_1.TransactionType.Cancel) {
         return {
             status: index_1.TransactionResult[+transaction.transactions.cancel.status],
             transactionResultText: transaction.transactions.cancel.transactionResultText,
         };
     }
-    if (transactionType === index_1.TransactionType.reserve) {
+    if (transactionType === index_1.TransactionType.Reserve) {
         return {
             status: index_1.TransactionResult[+transaction.transactions.reserve.status],
             transactionResultText: transaction.transactions.reserve.transactionResultText,
         };
     }
-    if (transactionType === index_1.TransactionType.purchase) {
+    if (transactionType === index_1.TransactionType.Purchase) {
         return {
             status: index_1.TransactionResult[+transaction.transactions.purchase.status],
             transactionResultText: transaction.transactions.purchase.transactionResultText,

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,15 +1,16 @@
 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>>;
+    AddCommerceAsync(commerce: CommerceRequest, fixedCustomData: FixedCustomData): 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[]>>;
+    GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>>;
+    GetSupportedIssuersAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessorsAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerProcessor[]>>;
     ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest): Promise<ServerResponse<Commerce>>;
     GetInstrumentsAsync(authorizationInfo: AuthorizationInfo): Promise<ServerResponse<PaymentInstrument[]>>;
     SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
@@ -18,14 +19,14 @@ export interface IPaymentGatewayClient {
     CodeActionAsync(request: CodeRequest): Promise<ServerResponse<Transaction>>;
     StartReserveAsync(payment: ReserveRequest): Promise<ServerResponse<Transaction>>;
     StatusAsync(payment: Reference): Promise<ServerResponse<Transaction>>;
-    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest): Promise<ServerResponse<Session>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): 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>>;
+    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>;
 }

package/lib/sdk/PaymentGatewayClient.d.ts

@@ -1,16 +1,16 @@
 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';
 import { IssuerProcessor } from './index';
 import { IPaymentGatewayClient } from './IPaymentGatewayClient';
+import { FixedCustomData } from './models/FixedCustomData';
 export declare class PaymentGatewayClient implements IPaymentGatewayClient {
-    AddCommerceAsync(commerce: CommerceRequest): Promise<ServerResponse<Commerce>>;
     AddIssuerCommerceAsync(issuerData: IssuerData): Promise<ServerResponse<IssuerData>>;
-    DeleteCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteInstrumentAsync(info: DeleteInstrumentRequest): Promise<ServerResponse<BaseServerResponse>>;
-    DeleteIssuerCommerceAsync(commerceIssuerIdRequest: CommerceIssuerIdRequest): Promise<ServerResponse<BaseServerResponse>>;
+    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[]>>;
+    GetCommercesAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<Commerce[]>>;
+    GetSupportedIssuersAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerInfo[]>>;
+    GetSupportedPaymentProcessorsAsync(fixedCustomData: FixedCustomData): Promise<ServerResponse<IssuerProcessor[]>>;
     ModifyCommerceAsync(commerceModifyRequest: CommerceModifyRequest): Promise<ServerResponse<Commerce>>;
     GetInstrumentsAsync(authorizationInfo: AuthorizationInfo): Promise<ServerResponse<PaymentInstrument[]>>;
     SetDefaultCommerceAsync(commerceIdRequest: CommerceIdRequest): Promise<BaseServerResponse>;
@@ -19,14 +19,15 @@ export declare class PaymentGatewayClient implements IPaymentGatewayClient {
     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>>;
+    ExpressCheckoutAsync(expressCheckout: ExpressCheckoutRequest, fixedCustomData: FixedCustomData): Promise<ServerResponse<Session>>;
+    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>;
 }