@houlak/plexo-sdk 0.1.0

package/lib/sdk/PaymentGatewayMock.js

@@ -0,0 +1,336 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentGatewayMock = void 0;
+var mocks_1 = require("./mocks/mocks");
+var IndexSDK_1 = require("./models/IndexSDK");
+var PaymentGatewayMock = /** @class */ (function () {
+    function PaymentGatewayMock() {
+    }
+    PaymentGatewayMock.prototype.AddCommerceAsync = function (commerce) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.commerceMock), { name: commerce.name }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.AddIssuerCommerceAsync = function (issuerData) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.issuerDataMock), issuerData),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.DeleteCommerceAsync = function (commerceIdRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.DeleteInstrumentAsync = function (info) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.DeleteIssuerCommerceAsync = function (commerceIssuerIdRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.GetCommerceIssuersAsync = function (commerceIdRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: [__assign(__assign({}, mocks_1.mocks.issuerDataMock), { commerceId: commerceIdRequest.commerceId })],
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.GetCommercesAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: [mocks_1.mocks.commerceMock],
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.GetSupportedIssuersAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: [mocks_1.mocks.issuerMock],
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.GetSupportedPaymentProcessorsAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: [mocks_1.mocks.issuerProcessorMock],
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.ModifyCommerceAsync = function (commerceModifyRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.commerceMock), commerceModifyRequest),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.GetInstrumentsAsync = function (authorizationInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: [mocks_1.mocks.paymentInstrumentMock],
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.SetDefaultCommerceAsync = function (commerceIdRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.AuthorizeAsync = function (authorization) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.sessionMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.CancelAsync = function (cancel) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.transactionMock), { transactions: {
+                                purchase: mocks_1.mocks.transactionMock.transactions.purchase,
+                                reserve: mocks_1.mocks.transactionMock.transactions.reserve,
+                                cancel: __assign(__assign({}, mocks_1.mocks.transactionMock.transactions.cancel), { clientReferenceId: cancel.clientReferenceId }),
+                            } }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.CodeActionAsync = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.transactionMock), { paymentCode: __assign(__assign({}, mocks_1.mocks.transactionMock.paymentCode), { code: request.code }) }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.StartReserveAsync = function (payment) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.transactionMock), { amount: payment.financialInclusion.billedAmount, transactions: {
+                                purchase: mocks_1.mocks.transactionMock.transactions.purchase,
+                                reserve: __assign(__assign({}, mocks_1.mocks.transactionMock.transactions.reserve), { clientReferenceId: payment.clientReferenceId, expirationUTC: payment.expirationUTC }),
+                                cancel: mocks_1.mocks.transactionMock.transactions.cancel,
+                            } }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.StatusAsync = function (payment) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.transactionMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.ExpressCheckoutAsync = function (expressCheckout) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.sessionMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.ObtainCsvTransactionsAsync = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: 'CsvTransactionsMock',
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.ObtainTransactionsAsync = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.transactionCursorMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.PurchaseAsync = function (payment) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.transactionMock), { amount: payment.financialInclusion.billedAmount, currency: __assign(__assign({}, mocks_1.mocks.transactionMock.currency), { currencyId: payment.currencyId }), transactions: {
+                                purchase: __assign(__assign({}, mocks_1.mocks.transactionMock.transactions.purchase), { clientReferenceId: payment.clientReferenceId }),
+                                reserve: mocks_1.mocks.transactionMock.transactions.reserve,
+                                cancel: mocks_1.mocks.transactionMock.transactions.cancel,
+                            } }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.CreateBankInstrumentAsync = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock), { issuer: __assign(__assign({}, mocks_1.mocks.paymentInstrumentMock.issuer), { issuerId: request.issuerId }) }),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.EndReserveAsync = function (reserve) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.transactionMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.UnwrapInstrumentCallbackAsync = function (serverSignedInstrumentCallback) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.instrumentCallbackMock), serverSignedInstrumentCallback.object),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.UnwrapTransactionCallbackAsync = function (serverSignedTransactionCallback) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: __assign(__assign({}, mocks_1.mocks.transactionCallbackMock), serverSignedTransactionCallback.object),
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.SignInstrumentCallback = function (serverResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.clientSignedResponseMock,
+                    }];
+            });
+        });
+    };
+    PaymentGatewayMock.prototype.SignTransactionCallback = function (serverResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        resultCode: IndexSDK_1.ResultCodes.Ok,
+                        response: mocks_1.mocks.clientSignedResponseMock,
+                    }];
+            });
+        });
+    };
+    return PaymentGatewayMock;
+}());
+exports.PaymentGatewayMock = PaymentGatewayMock;

package/lib/sdk/enums/plexo-error-enum.d.ts

@@ -0,0 +1,37 @@
+export declare enum PlexoErrorEnum {
+    ExceptionHandlingTransaction = 1200,
+    PlexoAuthorizationError = 1201,
+    InstrumentNotFound = 1202,
+    PlexoPaymentError = 1203,
+    PlexoUnknownError = 1204,
+    InvalidCard = 1205,
+    InvalidCurrency = 1206,
+    InvalidIssuer = 1207,
+    InvalidInstrument = 1208,
+    InvalidVerification = 1209,
+    AlreadyExists = 1210,
+    MissingFields = 1211,
+    CodeExpired = 1212,
+    RequiresSessionExtendedAmount = 1213,
+    RequiresClientExtendedAmount = 1214,
+    ExternalLimitedCard = 1215,
+    Forbidden = 1216,
+    ExpiredSession = 1217,
+    InvalidSession = 1218,
+    SystemError = 1219,
+    DisabledCard = 1220,
+    ExpiredCard = 1221,
+    ClientServerError = 1222,
+    DuplicateTransaction = 1223,
+    ArgumentError = 1224,
+    Started = 1225,
+    Pending = 1226,
+    Denied = 1227,
+    Expired = 1228,
+    NotProcessed = 1229,
+    UnableToCancel = 1230,
+    IssuerOperationNotSupported = 1231,
+    ExtendedCreditVerificationRequired = 1232,
+    BadArgument = 1233,
+    Generic = 9999
+}

package/lib/sdk/enums/plexo-error-enum.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlexoErrorEnum = void 0;
+var PlexoErrorEnum;
+(function (PlexoErrorEnum) {
+    PlexoErrorEnum[PlexoErrorEnum["ExceptionHandlingTransaction"] = 1200] = "ExceptionHandlingTransaction";
+    PlexoErrorEnum[PlexoErrorEnum["PlexoAuthorizationError"] = 1201] = "PlexoAuthorizationError";
+    PlexoErrorEnum[PlexoErrorEnum["InstrumentNotFound"] = 1202] = "InstrumentNotFound";
+    PlexoErrorEnum[PlexoErrorEnum["PlexoPaymentError"] = 1203] = "PlexoPaymentError";
+    PlexoErrorEnum[PlexoErrorEnum["PlexoUnknownError"] = 1204] = "PlexoUnknownError";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidCard"] = 1205] = "InvalidCard";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidCurrency"] = 1206] = "InvalidCurrency";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidIssuer"] = 1207] = "InvalidIssuer";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidInstrument"] = 1208] = "InvalidInstrument";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidVerification"] = 1209] = "InvalidVerification";
+    PlexoErrorEnum[PlexoErrorEnum["AlreadyExists"] = 1210] = "AlreadyExists";
+    PlexoErrorEnum[PlexoErrorEnum["MissingFields"] = 1211] = "MissingFields";
+    // I don't really know what code this is talking about, but it seemed important
+    PlexoErrorEnum[PlexoErrorEnum["CodeExpired"] = 1212] = "CodeExpired";
+    PlexoErrorEnum[PlexoErrorEnum["RequiresSessionExtendedAmount"] = 1213] = "RequiresSessionExtendedAmount";
+    // I guess one of these two have to do with extended credits / insufficient funds
+    PlexoErrorEnum[PlexoErrorEnum["RequiresClientExtendedAmount"] = 1214] = "RequiresClientExtendedAmount";
+    // When a card reached a certain limit imposed by the issuer or the cardholder?
+    PlexoErrorEnum[PlexoErrorEnum["ExternalLimitedCard"] = 1215] = "ExternalLimitedCard";
+    PlexoErrorEnum[PlexoErrorEnum["Forbidden"] = 1216] = "Forbidden";
+    PlexoErrorEnum[PlexoErrorEnum["ExpiredSession"] = 1217] = "ExpiredSession";
+    PlexoErrorEnum[PlexoErrorEnum["InvalidSession"] = 1218] = "InvalidSession";
+    PlexoErrorEnum[PlexoErrorEnum["SystemError"] = 1219] = "SystemError";
+    PlexoErrorEnum[PlexoErrorEnum["DisabledCard"] = 1220] = "DisabledCard";
+    PlexoErrorEnum[PlexoErrorEnum["ExpiredCard"] = 1221] = "ExpiredCard";
+    PlexoErrorEnum[PlexoErrorEnum["ClientServerError"] = 1222] = "ClientServerError";
+    PlexoErrorEnum[PlexoErrorEnum["DuplicateTransaction"] = 1223] = "DuplicateTransaction";
+    PlexoErrorEnum[PlexoErrorEnum["ArgumentError"] = 1224] = "ArgumentError";
+    // Now transaction errors
+    PlexoErrorEnum[PlexoErrorEnum["Started"] = 1225] = "Started";
+    PlexoErrorEnum[PlexoErrorEnum["Pending"] = 1226] = "Pending";
+    PlexoErrorEnum[PlexoErrorEnum["Denied"] = 1227] = "Denied";
+    PlexoErrorEnum[PlexoErrorEnum["Expired"] = 1228] = "Expired";
+    PlexoErrorEnum[PlexoErrorEnum["NotProcessed"] = 1229] = "NotProcessed";
+    PlexoErrorEnum[PlexoErrorEnum["UnableToCancel"] = 1230] = "UnableToCancel";
+    PlexoErrorEnum[PlexoErrorEnum["IssuerOperationNotSupported"] = 1231] = "IssuerOperationNotSupported";
+    PlexoErrorEnum[PlexoErrorEnum["ExtendedCreditVerificationRequired"] = 1232] = "ExtendedCreditVerificationRequired";
+    PlexoErrorEnum[PlexoErrorEnum["BadArgument"] = 1233] = "BadArgument";
+    PlexoErrorEnum[PlexoErrorEnum["Generic"] = 9999] = "Generic";
+})(PlexoErrorEnum = exports.PlexoErrorEnum || (exports.PlexoErrorEnum = {}));

package/lib/sdk/helpers/signature/signatureHelper.d.ts

@@ -0,0 +1,10 @@
+import { ClientSignedResponse, GenericSignedObject, GenericStateObject, InstrumentCallback, ServerResponse, TransactionCallback } from '../..';
+import { Certificate } from '../../types/signatureHelper.type';
+export declare const canonizeJson: <T>(object: T) => T;
+export declare const SignatureHelper: {
+    getCertificate: () => Promise<Certificate>;
+    getSignatureFromPlexo: <T extends object>(objectToSign: GenericStateObject<T>) => Promise<GenericSignedObject<T>>;
+    getSignatureFromCallback: (response: ServerResponse<InstrumentCallback | TransactionCallback>) => Promise<ServerResponse<ClientSignedResponse>>;
+    getPlexoSignature: <T_1 extends object>(fingerprint: string, response: GenericSignedObject<T_1>) => Promise<ServerResponse<T_1>>;
+    toCamelKeys: <T_2 extends object>(object: T_2) => T_2;
+};