@riocrypto/common-server 1.0.1603 → 1.0.1605

package/build/common/src/errors/missing-security-question-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingSecurityQuestionError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingSecurityQuestionError extends custom_error_1.CustomError {
+    constructor() {
+        super("Security question is not registered");
+        this.statusCode = 401;
+        this.internalCode = 17;
+        Object.setPrototypeOf(this, MissingSecurityQuestionError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Security question is not registered",
+            },
+        ];
+    }
+}
+exports.MissingSecurityQuestionError = MissingSecurityQuestionError;

package/build/common/src/errors/missing-user-data-error.d.ts

@@ -0,0 +1,15 @@
+import { CustomError } from "./custom-error";
+export declare class MissingUserDataError extends CustomError {
+    private customMessage;
+    private missingFields;
+    private userId;
+    statusCode: number;
+    internalCode: number;
+    constructor(customMessage: string, missingFields: string[], userId: string);
+    serializeErrors(): {
+        code: number;
+        fields: string[];
+        userId: string;
+        message: string;
+    }[];
+}

package/build/common/src/errors/missing-user-data-error.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingUserDataError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingUserDataError extends custom_error_1.CustomError {
+    constructor(customMessage, missingFields, userId) {
+        super(customMessage);
+        this.customMessage = customMessage;
+        this.missingFields = missingFields;
+        this.userId = userId;
+        this.statusCode = 400;
+        this.internalCode = 88;
+        Object.setPrototypeOf(this, MissingUserDataError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                fields: this.missingFields,
+                userId: this.userId,
+                message: this.customMessage,
+            },
+        ];
+    }
+}
+exports.MissingUserDataError = MissingUserDataError;

package/build/common/src/errors/missing-user-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class MissingUserError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/missing-user-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingUserError = void 0;
+const custom_error_1 = require("./custom-error");
+class MissingUserError extends custom_error_1.CustomError {
+    constructor() {
+        super("Auth is not registered to a user");
+        this.statusCode = 401;
+        this.internalCode = 18;
+        Object.setPrototypeOf(this, MissingUserError.prototype);
+    }
+    serializeErrors() {
+        return [
+            { code: this.internalCode, message: "Auth is not registered to a user" },
+        ];
+    }
+}
+exports.MissingUserError = MissingUserError;

package/build/common/src/errors/not-authorized-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class NotAuthorizedError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/not-authorized-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not authorized");
+        this.statusCode = 401;
+        this.internalCode = 19;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Not authorized" }];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/common/src/errors/not-broker-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class NotBrokerError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/not-broker-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotBrokerError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotBrokerError extends custom_error_1.CustomError {
+    constructor() {
+        super("To call this endpoint as a user, you must be a broker");
+        this.statusCode = 401;
+        this.internalCode = 20;
+        Object.setPrototypeOf(this, NotBrokerError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "To do this operation as a user, you must be a broker",
+            },
+        ];
+    }
+}
+exports.NotBrokerError = NotBrokerError;

package/build/common/src/errors/not-found-error.d.ts

@@ -0,0 +1,11 @@
+import { CustomError } from "./custom-error";
+export declare class NotFoundError extends CustomError {
+    private object;
+    statusCode: number;
+    internalCode: number;
+    constructor(object: string);
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/not-found-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor(object) {
+        super(`${object} not found`);
+        this.object = object;
+        this.statusCode = 404;
+        this.internalCode = 21;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: `${this.object} not found` }];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/common/src/errors/password-already-used-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class PasswordAlreadyUsedError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/password-already-used-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordAlreadyUsedError = void 0;
+const custom_error_1 = require("./custom-error");
+class PasswordAlreadyUsedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Password already used");
+        this.statusCode = 400;
+        this.internalCode = 26;
+        Object.setPrototypeOf(this, PasswordAlreadyUsedError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Password already used" }];
+    }
+}
+exports.PasswordAlreadyUsedError = PasswordAlreadyUsedError;

package/build/common/src/errors/request-validation-error.d.ts

@@ -0,0 +1,13 @@
+import { CustomError } from "./custom-error";
+import { ValidationError } from "express-validator";
+export declare class RequestValidationError extends CustomError {
+    errors: ValidationError[];
+    statusCode: number;
+    internalCode: number;
+    constructor(errors: ValidationError[]);
+    serializeErrors(): {
+        code: number;
+        message: any;
+        field: string;
+    }[];
+}

package/build/common/src/errors/request-validation-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const custom_error_1 = require("./custom-error");
+class RequestValidationError extends custom_error_1.CustomError {
+    constructor(errors) {
+        super("Invalid request parameters");
+        this.errors = errors;
+        this.statusCode = 400;
+        this.internalCode = 27;
+        Object.setPrototypeOf(this, RequestValidationError.prototype);
+    }
+    serializeErrors() {
+        return this.errors.map((err) => {
+            return { code: this.internalCode, message: err.msg, field: err.param };
+        });
+    }
+}
+exports.RequestValidationError = RequestValidationError;

package/build/common/src/errors/rio-settings-already-exists-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class RioSettingsAlreadyExistsError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/rio-settings-already-exists-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RioSettingsAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class RioSettingsAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Rio settings already exists");
+        this.statusCode = 409;
+        this.internalCode = 28;
+        Object.setPrototypeOf(this, RioSettingsAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [
+            { code: this.internalCode, message: "Rio settings already exists" },
+        ];
+    }
+}
+exports.RioSettingsAlreadyExistsError = RioSettingsAlreadyExistsError;

package/build/common/src/errors/rio-settings-not-found-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class RioSettingsNotFoundError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/rio-settings-not-found-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RioSettingsNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class RioSettingsNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Rio settings not found");
+        this.statusCode = 404;
+        this.internalCode = 29;
+        Object.setPrototypeOf(this, RioSettingsNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [
+            { code: this.internalCode, message: "Missing internal Rio settings" },
+        ];
+    }
+}
+exports.RioSettingsNotFoundError = RioSettingsNotFoundError;

package/build/common/src/errors/secret-manager-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class SecretManagerError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/secret-manager-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretManagerError = void 0;
+const custom_error_1 = require("./custom-error");
+class SecretManagerError extends custom_error_1.CustomError {
+    constructor() {
+        super("Internal error");
+        this.statusCode = 500;
+        this.internalCode = 38;
+        Object.setPrototypeOf(this, SecretManagerError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Internal errror",
+            },
+        ];
+    }
+}
+exports.SecretManagerError = SecretManagerError;

package/build/common/src/errors/unavailable-in-sandbox-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class UnavailableInSandboxError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/unavailable-in-sandbox-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnavailableInSandboxError = void 0;
+const custom_error_1 = require("./custom-error");
+class UnavailableInSandboxError extends custom_error_1.CustomError {
+    constructor() {
+        super("This endpoint is not available in sandbox");
+        this.statusCode = 501;
+        this.internalCode = 36;
+        Object.setPrototypeOf(this, UnavailableInSandboxError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "This endpoint is not available in sandbox",
+            },
+        ];
+    }
+}
+exports.UnavailableInSandboxError = UnavailableInSandboxError;

package/build/common/src/errors/user-already-exists-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class UserAlreadyExistsError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/user-already-exists-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class UserAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("User already exists");
+        this.statusCode = 409;
+        this.internalCode = 30;
+        Object.setPrototypeOf(this, UserAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "User already exists" }];
+    }
+}
+exports.UserAlreadyExistsError = UserAlreadyExistsError;

package/build/common/src/errors/user-not-enabled-in-us-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class UserNotEnabledInUSError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/user-not-enabled-in-us-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserNotEnabledInUSError = void 0;
+const custom_error_1 = require("./custom-error");
+class UserNotEnabledInUSError extends custom_error_1.CustomError {
+    constructor() {
+        super("User not approved to operate in the US");
+        this.statusCode = 403;
+        this.internalCode = 42;
+        Object.setPrototypeOf(this, UserNotEnabledInUSError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "User not approved to operate in the US",
+            },
+        ];
+    }
+}
+exports.UserNotEnabledInUSError = UserNotEnabledInUSError;

package/build/common/src/errors/verification-failed-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class VerificationFailedError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/verification-failed-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationFailedError = void 0;
+const custom_error_1 = require("./custom-error");
+class VerificationFailedError extends custom_error_1.CustomError {
+    constructor() {
+        super("SMS verification failed");
+        this.statusCode = 401;
+        this.internalCode = 31;
+        Object.setPrototypeOf(this, VerificationFailedError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Verification failed" }];
+    }
+}
+exports.VerificationFailedError = VerificationFailedError;

package/build/common/src/errors/wrong-order-state-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class WrongOrderStateError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/wrong-order-state-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongOrderStateError = void 0;
+const custom_error_1 = require("./custom-error");
+class WrongOrderStateError extends custom_error_1.CustomError {
+    constructor() {
+        super("Order is not in the correct state to call this method");
+        this.statusCode = 400;
+        this.internalCode = 32;
+        Object.setPrototypeOf(this, WrongOrderStateError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Order is not in the correct state to call this method",
+            },
+        ];
+    }
+}
+exports.WrongOrderStateError = WrongOrderStateError;

package/build/common/src/errors/wrong-password-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class WrongPasswordError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/wrong-password-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongPasswordError = void 0;
+const custom_error_1 = require("./custom-error");
+class WrongPasswordError extends custom_error_1.CustomError {
+    constructor() {
+        super("Wrong password");
+        this.statusCode = 401;
+        this.internalCode = 33;
+        Object.setPrototypeOf(this, WrongPasswordError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Wrong password" }];
+    }
+}
+exports.WrongPasswordError = WrongPasswordError;

package/build/common/src/errors/wrong-processor-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class WrongProcessorError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/wrong-processor-error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongProcessorError = void 0;
+const custom_error_1 = require("./custom-error");
+class WrongProcessorError extends custom_error_1.CustomError {
+    constructor() {
+        super("Order not assigned to this processor");
+        this.statusCode = 400;
+        this.internalCode = 34;
+        Object.setPrototypeOf(this, WrongProcessorError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                code: this.internalCode,
+                message: "Order not assigned to this processor",
+            },
+        ];
+    }
+}
+exports.WrongProcessorError = WrongProcessorError;

package/build/common/src/errors/wrong-security-answer-error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "./custom-error";
+export declare class WrongSecurityAnswerError extends CustomError {
+    statusCode: number;
+    internalCode: number;
+    constructor();
+    serializeErrors(): {
+        code: number;
+        message: string;
+    }[];
+}

package/build/common/src/errors/wrong-security-answer-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongSecurityAnswerError = void 0;
+const custom_error_1 = require("./custom-error");
+class WrongSecurityAnswerError extends custom_error_1.CustomError {
+    constructor() {
+        super("Wrong security answer");
+        this.statusCode = 401;
+        this.internalCode = 35;
+        Object.setPrototypeOf(this, WrongSecurityAnswerError.prototype);
+    }
+    serializeErrors() {
+        return [{ code: this.internalCode, message: "Wrong security answer" }];
+    }
+}
+exports.WrongSecurityAnswerError = WrongSecurityAnswerError;

package/build/common/src/events/address-check-failed-event.d.ts

@@ -0,0 +1,8 @@
+import { Subjects } from "./subjects";
+export interface AddressCheckFailedEvent {
+    subject: Subjects.AddressCheckFailed;
+    data: {
+        orderId: string;
+        address: string;
+    };
+}

package/build/common/src/events/address-check-failed-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/common/src/events/address-check-passed-event.d.ts

@@ -0,0 +1,8 @@
+import { Subjects } from "./subjects";
+export interface AddressCheckPassedEvent {
+    subject: Subjects.AddressCheckPassed;
+    data: {
+        orderId: string;
+        address: string;
+    };
+}

package/build/common/src/events/address-check-passed-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/common/src/events/address-verification-initiated-event.d.ts

@@ -0,0 +1,7 @@
+import { Subjects } from "./subjects";
+export interface AddressVerificationInitiatedEvent {
+    subject: Subjects.AddressVerificationInitiated;
+    data: {
+        id: string;
+    };
+}

package/build/common/src/events/address-verification-initiated-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/common/src/events/address-verification-sent-event.d.ts

@@ -0,0 +1,7 @@
+import { Subjects } from "./subjects";
+export interface AddressVerificationSentEvent {
+    subject: Subjects.AddressVerificationSent;
+    data: {
+        id: string;
+    };
+}