@riocrypto/common-server 1.0.506

package/build/middlewares/require-priveleges.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requirePriveleges = void 0;
+const missing_user_error_1 = require("../errors/missing-user-error");
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const requirePriveleges = (req, res, next) => {
+    if (req.currentAuth && !req.user) {
+        throw new missing_user_error_1.MissingUserError();
+    }
+    if (!req.partnerId && !req.user && !req.currentAdminAuth) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+};
+exports.requirePriveleges = requirePriveleges;

package/build/middlewares/validate-auth.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const validateAuth: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-auth.js

@@ -0,0 +1,30 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAuth = void 0;
+const missing_password_error_1 = require("../errors/missing-password-error");
+const missing_security_question_error_1 = require("../errors/missing-security-question-error");
+const validateAuth = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const auth = req.currentAuth;
+    if (auth) {
+        if (auth.missing.includes("password")) {
+            throw new missing_password_error_1.MissingPasswordError();
+        }
+        if (auth.missing.includes("securityQuestion")) {
+            throw new missing_security_question_error_1.MissingSecurityQuestionError();
+        }
+        if (auth.missing.includes("securityAnswer")) {
+            throw new missing_security_question_error_1.MissingSecurityQuestionError();
+        }
+    }
+    next();
+});
+exports.validateAuth = validateAuth;

package/build/middlewares/validate-kyc.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const validateKYC: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/validate-kyc.js

@@ -0,0 +1,30 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKYC = void 0;
+const missing_kyc_approval_error_1 = require("../errors/missing-kyc-approval-error");
+const kyc_status_1 = require("../types/kyc-status");
+const user_type_1 = require("../types/user-type");
+const validateKYC = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const user = req.user;
+    if ((user === null || user === void 0 ? void 0 : user.type) === user_type_1.UserType.Individual) {
+        if (user.kycStatus !== kyc_status_1.KYCStatus.Passed) {
+            throw new missing_kyc_approval_error_1.MissingKYCApprovalError();
+        }
+    }
+    if ((user === null || user === void 0 ? void 0 : user.type) === user_type_1.UserType.Business) {
+        if (user.kycStatus !== kyc_status_1.KYCStatus.businessApproved) {
+            throw new missing_kyc_approval_error_1.MissingKYCApprovalError();
+        }
+    }
+    next();
+});
+exports.validateKYC = validateKYC;

package/build/middlewares/validate-order.js

@@ -0,0 +1,20 @@
+"use strict";
+// import { Request, Response, NextFunction } from "express";
+// import { NotAuthorizedError } from "../errors/not-authorized-error";
+// export const validateOrder = async (
+//   req: Request,
+//   res: Response,
+//   next: NextFunction
+// ) => {
+//   const order = req.order;
+//   if (!order) {
+//     throw new NotAuthorizedError();
+//   }
+//   if (req.partnerId && req.partnerId !== order.partnerId) {
+//     throw new NotAuthorizedError();
+//   }
+//   if (req.user && req.user._id.valueOf() !== order.userId) {
+//     throw new NotAuthorizedError();
+//   }
+//   next();
+// };

package/build/middlewares/validate-request.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const validateRequest: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/validate-request.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRequest = void 0;
+const express_validator_1 = require("express-validator");
+const request_validation_error_1 = require("../errors/request-validation-error");
+const validateRequest = (req, res, next) => {
+    const errors = (0, express_validator_1.validationResult)(req);
+    if (!errors.isEmpty()) {
+        throw new request_validation_error_1.RequestValidationError(errors.array());
+    }
+    next();
+};
+exports.validateRequest = validateRequest;

package/build/middlewares/verify-admin-api-key.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from "express";
+declare global {
+    namespace Express {
+        interface Request {
+            validAdminApiKey?: boolean;
+        }
+    }
+}
+export declare const verifyAdminApiKey: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/verify-admin-api-key.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAdminApiKey = void 0;
+const verifyAdminApiKey = (req, res, next) => {
+    let apiKey = req.header("x-api-key");
+    if (apiKey === process.env.ORIGINAL_ADMIN_API_KEY) {
+        req.validAdminApiKey = true;
+    }
+    next();
+};
+exports.verifyAdminApiKey = verifyAdminApiKey;

package/build/models/admin-auth.d.ts

@@ -0,0 +1,16 @@
+import { Mongoose, Model, Document } from "mongoose";
+interface AdminAuthAttrs {
+    email: string;
+    password: string;
+    previousPasswords?: string[];
+}
+interface AdminAuthDoc extends Document {
+    email: string;
+    password: string;
+    previousPasswords?: string[];
+}
+interface AdminAuthModel extends Model<AdminAuthDoc> {
+    build(attrs: AdminAuthAttrs): AdminAuthDoc;
+}
+declare const buildAdminAuth: (mongoose: Mongoose) => AdminAuthModel;
+export { buildAdminAuth, AdminAuthDoc };

package/build/models/admin-auth.js

@@ -0,0 +1,59 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdminAuth = void 0;
+const password_1 = require("../services/password");
+const buildAdminAuth = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.AdminAuth) {
+        return mongoose.model("AdminAuth");
+    }
+    const AdminSchema = new mongoose.Schema({
+        email: {
+            type: String,
+            required: true,
+        },
+        password: {
+            type: String,
+            required: true,
+        },
+        previousPasswords: [
+            {
+                type: String,
+                required: false,
+            },
+        ],
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+                delete ret.password;
+            },
+        },
+    });
+    AdminSchema.pre("save", function (done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isModified("password")) {
+                const hashed = yield password_1.Password.toHash(this.get("password"));
+                this.set("password", hashed);
+            }
+            done();
+        });
+    });
+    AdminSchema.statics.build = (attrs) => {
+        return new AdminAuth(attrs);
+    };
+    const AdminAuth = mongoose.model("AdminAuth", AdminSchema);
+    return AdminAuth;
+};
+exports.buildAdminAuth = buildAdminAuth;

package/build/models/auth.d.ts

@@ -0,0 +1,24 @@
+import { APIKey } from "../types/api-key";
+import { SecurityQuestion } from "../types/security-question";
+import { Mongoose, Model, Document } from "mongoose";
+interface AuthAttrs {
+    phoneNumber: string;
+    password?: string;
+    securityQuestion?: SecurityQuestion;
+    securityAnswer?: string;
+    previousPasswords?: string[];
+    apiKeys?: APIKey[];
+}
+interface AuthDoc extends Document {
+    phoneNumber: string;
+    password?: string;
+    securityQuestion?: SecurityQuestion;
+    securityAnswer?: string;
+    previousPasswords?: string[];
+    apiKeys?: APIKey[];
+}
+interface AuthModel extends Model<AuthDoc> {
+    build(attrs: AuthAttrs): AuthDoc;
+}
+declare const buildAuth: (mongoose: Mongoose) => AuthModel;
+export { buildAuth, AuthDoc };

package/build/models/auth.js

@@ -0,0 +1,83 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAuth = void 0;
+const password_1 = require("../services/password");
+const buildAuth = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.Auth) {
+        return mongoose.model("Auth");
+    }
+    const AuthSchema = new mongoose.Schema({
+        phoneNumber: {
+            type: String,
+            required: true,
+        },
+        password: {
+            type: String,
+        },
+        securityQuestion: {
+            type: String,
+        },
+        securityAnswer: {
+            type: String,
+        },
+        previousPasswords: [
+            {
+                type: String,
+            },
+        ],
+        apiKeys: [
+            {
+                value: {
+                    type: String,
+                    required: true,
+                },
+                label: {
+                    type: String,
+                },
+                id: {
+                    type: String,
+                    required: true,
+                },
+            },
+        ],
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+                delete ret.password;
+                delete ret.securityAnswer;
+                delete ret.previousPasswords;
+                for (let apiKey of ret.apiKeys) {
+                    delete apiKey.value;
+                }
+            },
+        },
+    });
+    AuthSchema.pre("save", function (done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isModified("password")) {
+                const hashed = yield password_1.Password.toHash(this.get("password"));
+                this.set("password", hashed);
+            }
+            done();
+        });
+    });
+    AuthSchema.statics.build = (attrs) => {
+        return new Auth(attrs);
+    };
+    const Auth = mongoose.model("Auth", AuthSchema);
+    return Auth;
+};
+exports.buildAuth = buildAuth;

package/build/models/bank-payout.d.ts

@@ -0,0 +1,20 @@
+import { Mongoose, Model, Document } from "mongoose";
+interface BankPayoutAttrs {
+    orderId: string;
+    originBank: string;
+    destinationBank?: string;
+    accountNumber: string;
+    status: string;
+}
+interface BankPayoutDoc extends Document {
+    orderId: string;
+    originBank: string;
+    destinationBank?: string;
+    accountNumber: string;
+    status: string;
+}
+interface BankPayoutModel extends Model<BankPayoutDoc> {
+    build(attrs: BankPayoutAttrs): BankPayoutDoc;
+}
+declare const buildBankPayout: (mongoose: Mongoose) => BankPayoutModel;
+export { buildBankPayout, BankPayoutDoc };

package/build/models/bank-payout.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBankPayout = void 0;
+const buildBankPayout = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.BankPayout) {
+        return mongoose.model("BankPayout");
+    }
+    const BankPayoutSchema = new mongoose.Schema({
+        orderId: {
+            type: String,
+            required: true,
+        },
+        originBank: {
+            type: String,
+            required: true,
+        },
+        accountNumber: {
+            type: String,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+        destinationBank: {
+            type: String,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BankPayoutSchema.statics.build = (attrs) => {
+        return new BankPayout(attrs);
+    };
+    const BankPayout = mongoose.model("BankPayout", BankPayoutSchema);
+    return BankPayout;
+};
+exports.buildBankPayout = buildBankPayout;

package/build/models/business-user.d.ts

@@ -0,0 +1,57 @@
+import { Country } from "../types/country";
+import { KYCStatus } from "../types/kyc-status";
+import { Language } from "../types/language";
+import { PlatformFeeRange } from "../types/platform-fee-range";
+import { USState } from "../types/us-state";
+import { UserAttribute } from "../types/user-attribute";
+import { UserType } from "../types/user-type";
+import { Mongoose, Model, Document } from "mongoose";
+interface BusinessUserAttrs {
+    authId?: string;
+    type: UserType;
+    companyName: string;
+    legalRepresentative: string;
+    phoneNumber: string;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    COIFile?: string;
+    KYCReportFile?: string;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    brokerId?: string;
+    platformFeeRanges?: PlatformFeeRange[];
+}
+interface BusinessUserModel extends Model<BusinessUserDoc> {
+    build(attrs: BusinessUserAttrs): BusinessUserDoc;
+}
+interface BusinessUserDoc extends Document {
+    authId?: string;
+    type: UserType;
+    companyName: string;
+    legalRepresentative: string;
+    phoneNumber: string;
+    email: string;
+    street1: string;
+    street2?: string;
+    city: string;
+    state: USState | string;
+    postalCode: string;
+    country: Country;
+    kycStatus: KYCStatus;
+    COIFile?: string;
+    KYCReportFile?: string;
+    cpf?: string;
+    language?: Language;
+    attributes?: UserAttribute[];
+    brokerId?: string;
+    platformFeeRanges?: PlatformFeeRange[];
+}
+declare const buildBusinessUser: (mongoose: Mongoose) => BusinessUserModel;
+export { buildBusinessUser, BusinessUserDoc };

package/build/models/business-user.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBusinessUser = void 0;
+const buildBusinessUser = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.BusinessUser) {
+        return mongoose.model("BusinessUser");
+    }
+    const BusinessUserSchema = new mongoose.Schema({
+        authId: {
+            type: String,
+        },
+        type: {
+            type: String,
+            required: true,
+        },
+        companyName: {
+            type: String,
+            required: true,
+        },
+        legalRepresentative: {
+            type: String,
+            required: true,
+        },
+        phoneNumber: {
+            type: String,
+            required: true,
+        },
+        email: {
+            type: String,
+            required: true,
+        },
+        street1: {
+            type: String,
+            required: true,
+        },
+        street2: {
+            type: String,
+        },
+        city: {
+            type: String,
+            required: true,
+        },
+        state: {
+            type: String,
+            required: true,
+        },
+        postalCode: {
+            type: String,
+            required: true,
+        },
+        country: {
+            type: String,
+            required: true,
+        },
+        language: {
+            type: String,
+        },
+        cpf: {
+            type: String,
+        },
+        attributes: [
+            {
+                type: String,
+            },
+        ],
+        kycStatus: {
+            type: String,
+            required: true,
+        },
+        COIFile: {
+            type: String,
+        },
+        KYCReportFile: {
+            type: String,
+        },
+        brokerId: {
+            type: String,
+        },
+        platformFeeRanges: [
+            {
+                min: {
+                    type: Number,
+                    required: true,
+                },
+                max: {
+                    type: Number,
+                    required: true,
+                },
+                fee: {
+                    type: Number,
+                    required: true,
+                },
+            },
+        ],
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id.valueOf();
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    BusinessUserSchema.statics.build = (attrs) => {
+        return new BusinessUser(attrs);
+    };
+    const BusinessUser = mongoose.model("BusinessUser", BusinessUserSchema);
+    return BusinessUser;
+};
+exports.buildBusinessUser = buildBusinessUser;

package/build/models/ccxt-order.d.ts

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+interface CCXTOrderAttrs {
+    orderId: string;
+    ccxtId: string;
+    status: string;
+}
+interface CCXTOrderDoc extends mongoose.Document {
+    orderId: string;
+    status: string;
+    ccxtId: string;
+}
+interface CCXTOrderModel extends mongoose.Model<CCXTOrderDoc> {
+    build(attrs: CCXTOrderAttrs): CCXTOrderDoc;
+}
+declare const buildCCXTOrder: (mongoose: typeof mongoose) => CCXTOrderModel;
+export { buildCCXTOrder, CCXTOrderDoc };

package/build/models/ccxt-order.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCCXTOrder = void 0;
+const buildCCXTOrder = (mongoose) => {
+    // if model is already defined, return it
+    if (mongoose.models.CCXTOrder) {
+        return mongoose.model("CCXTOrder");
+    }
+    const CCXTOrderSchema = new mongoose.Schema({
+        orderId: {
+            type: String,
+            required: true,
+        },
+        ccxtId: {
+            type: String,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    CCXTOrderSchema.statics.build = (attrs) => {
+        return new CCXTOrder(attrs);
+    };
+    const CCXTOrder = mongoose.model("CCXTOrder", CCXTOrderSchema);
+    return CCXTOrder;
+};
+exports.buildCCXTOrder = buildCCXTOrder;

package/build/models/checked-address.d.ts

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+import { AddressCheckResult } from "../types/address-check-result";
+interface CheckedAddressAttrs {
+    address: string;
+    result: AddressCheckResult;
+    lastChecked: Date;
+}
+interface CheckedAddressDoc extends mongoose.Document {
+    address: string;
+    result: AddressCheckResult;
+    lastChecked: Date;
+}
+interface CheckedAddressModel extends mongoose.Model<CheckedAddressDoc> {
+    build(attrs: CheckedAddressAttrs): CheckedAddressDoc;
+}
+declare const buildCheckedAddress: (mongoose: typeof mongoose) => CheckedAddressModel;
+export { buildCheckedAddress, CheckedAddressDoc };