@resolveio/server-lib 3.2.10 → 3.2.11

package/managers/support.manager.d.ts

@@ -1,22 +0,0 @@
-import { SupportMethodModel } from '../models/support-method.model';
-import ResolveIOMainServer from '../server-app';
-export declare class SupportManager {
-    private _mainServer;
-    _supportMethods: SupportMethodModel;
-    private _mailer;
-    private _aws;
-    private serverConfig;
-    private clientDir;
-    private _sendQueue;
-    private _runningQueue;
-    constructor(mainServer: any, serverConfig: any, clientDir: any);
-    getMainServer(): ResolveIOMainServer;
-    supportMethods(supportMethod: SupportMethodModel): void;
-    callSupportMethod(ws: WebSocket, messageId: any, supportMethod: any, ...methodData: any[]): void;
-    callSupportMethodInternal(supportMethod: any, ...methodData: any[]): Promise<any>;
-    callMethodInternal(method: any, ...methodData: any[]): Promise<any>;
-    private sendWS;
-    sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[]): void;
-    readFile(fileName: any): Promise<{}>;
-    readImage(fileName: any): Promise<{}>;
-}

package/managers/support.manager.js

@@ -1,320 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var nodemailer = require("nodemailer");
-var aws = require("aws-sdk");
-var collections_1 = require("../support-methods/collections");
-var support_1 = require("../support-methods/support");
-var counters_1 = require("../support-methods/counters");
-var mongoose_1 = require("mongoose");
-var common_1 = require("../util/common");
-var log_collection_1 = require("../collections/log.collection");
-var method_manager_1 = require("./method.manager");
-var path = require("path");
-var fs = require("fs");
-var SupportManager = /** @class */ (function () {
-    function SupportManager(mainServer, serverConfig, clientDir) {
-        var _this = this;
-        this._supportMethods = {};
-        this._sendQueue = [];
-        this._runningQueue = false;
-        this._mainServer = mainServer;
-        this.serverConfig = serverConfig;
-        this.clientDir = clientDir;
-        collections_1.loadSupportCollectionMethods(this);
-        support_1.loadSupportMethods(this);
-        counters_1.loadCounterMethods(this);
-        this._mailer = nodemailer.createTransport({
-            SES: new aws.SES({
-                apiVersion: '2010-12-01',
-                accessKeyId: serverConfig.AWSACCESSKEYID,
-                secretAccessKey: serverConfig.AWSSECRETACCESSKEY,
-                region: serverConfig.AWSSES_REGION
-            })
-        });
-        this._aws = new aws.S3({
-            accessKeyId: serverConfig.AWSACCESSKEYID,
-            secretAccessKey: serverConfig.AWSSECRETACCESSKEY,
-            region: serverConfig.AWSREGION
-        });
-        setInterval(function () {
-            if (!_this._runningQueue) {
-                if (_this._sendQueue.length) {
-                    _this._runningQueue = true;
-                    var _loop_1 = function (i) {
-                        var ws = _this._mainServer.getWS(_this._sendQueue[i].id_ws);
-                        if (ws && ws.readyState === ws.OPEN) {
-                            if (ws.bufferedAmount < 20480) {
-                                var sendItem = _this._sendQueue.pop();
-                                ws.send(JSON.stringify(sendItem.data), function (error) {
-                                    if (error) {
-                                        console.log('Error on WS: ', error);
-                                        _this._mainServer.unsubscribeWS(ws);
-                                    }
-                                });
-                                // if (sendItem.method !== 'countQuery' && sendItem.method !== 'countCollectionWithQuery' && sendItem.method !== 'find' && sendItem.method !== 'findOne' && sendItem.method !== 'findWithOptions' && sendItem.method !== 'setWSAppVersion' && sendItem.method !== 'uploadFileAndSave') {
-                                if (common_1.getBinarySize(JSON.stringify(sendItem.methodData)) < 200000 && common_1.getBinarySize(JSON.stringify(sendItem.data)) < 200000) {
-                                    log_collection_1.Logs.create({
-                                        _id: mongoose_1.Types.ObjectId().toHexString(),
-                                        date: new Date(),
-                                        type: 'client-response',
-                                        title: 'Client Response - Support',
-                                        message: 'User: ' + ws['user'] + ', MessageId: ' + sendItem.data.messageId + ', Support Method: ' + sendItem.method,
-                                        payload: JSON.stringify([sendItem.methodData, sendItem.data]),
-                                        method: sendItem.method,
-                                        user: ws['user'],
-                                        messageId: sendItem.data.messageId
-                                    });
-                                }
-                                else {
-                                    log_collection_1.Logs.create({
-                                        _id: mongoose_1.Types.ObjectId().toHexString(),
-                                        date: new Date(),
-                                        type: 'client-response',
-                                        title: 'Client Response - Support',
-                                        message: 'User: ' + ws['user'] + ', MessageId: ' + sendItem.data.messageId + ', Support Method: ' + sendItem.method,
-                                        payload: 'Too Big',
-                                        method: sendItem.method,
-                                        user: ws['user'],
-                                        messageId: sendItem.data.messageId
-                                    });
-                                }
-                                // }
-                            }
-                        }
-                        else {
-                            _this._sendQueue.splice(i, 1);
-                        }
-                    };
-                    for (var i = _this._sendQueue.length - 1; i >= 0; i--) {
-                        _loop_1(i);
-                    }
-                    _this._runningQueue = false;
-                }
-            }
-        }, 25);
-    }
-    SupportManager.prototype.getMainServer = function () {
-        return this._mainServer;
-    };
-    // Add methods to private methods object
-    SupportManager.prototype.supportMethods = function (supportMethod) {
-        this._supportMethods = Object.assign(this._supportMethods, supportMethod);
-    };
-    // Call/run method (Emit on Socket)
-    SupportManager.prototype.callSupportMethod = function (ws, messageId, supportMethod) {
-        var _this = this;
-        var methodData = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-            methodData[_i - 3] = arguments[_i];
-        }
-        var _a;
-        var that = this;
-        if (!that._supportMethods[supportMethod]) {
-            console.log('No Support Method: ' + supportMethod);
-            that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Support Method: ' + supportMethod);
-            var serverRes = {
-                messageId: messageId,
-                hasError: true,
-                data: 'Internal Error'
-            };
-            this.sendWS(ws, supportMethod, methodData, serverRes);
-            return;
-        }
-        if ((methodData.length > 1 || methodData[0])) {
-            if (!that._supportMethods[supportMethod].check) {
-                console.error('No Check Function For Support Method ' + supportMethod);
-                that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Support Method ' + supportMethod);
-                var serverRes = {
-                    messageId: messageId,
-                    hasError: true,
-                    data: 'Internal Error'
-                };
-                this.sendWS(ws, supportMethod, methodData, serverRes);
-                return;
-            }
-            else if (!that._supportMethods[supportMethod].check._schema) {
-                console.error('No Check Schema For Method ' + supportMethod);
-                that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Support Method ' + supportMethod);
-                var serverRes = {
-                    messageId: messageId,
-                    hasError: true,
-                    data: 'Internal Error'
-                };
-                this.sendWS(ws, supportMethod, methodData, serverRes);
-                return;
-            }
-            else {
-                var valObj = {};
-                var valKeys = Object.keys(that._supportMethods[supportMethod].check._schema);
-                var rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
-                for (var i = 0; i < methodData.length; i++) {
-                    valObj[rootKeys[i]] = methodData[i];
-                }
-                try {
-                    that._supportMethods[supportMethod].check.validate(valObj);
-                }
-                catch (errors) {
-                    if (errors) {
-                        console.error('Error in Support Method Check (' + supportMethod + ')', errors);
-                        that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Match Error On Support Method ' + supportMethod + '\n\nData Being Checked\n' + JSON.stringify(valObj, null, 2) + '\n\nErrors\n' + JSON.stringify(errors, null, 2));
-                        var serverRes = {
-                            messageId: messageId,
-                            hasError: true,
-                            data: 'Internal Error'
-                        };
-                        this.sendWS(ws, supportMethod, methodData, serverRes);
-                        return;
-                    }
-                }
-            }
-        }
-        (_a = that._supportMethods[supportMethod].function).call.apply(_a, [Object.assign({}, that, SupportManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] })].concat(methodData)).then(function (res) {
-            var serverRes = {
-                messageId: messageId,
-                hasError: false,
-                data: res
-            };
-            _this.sendWS(ws, supportMethod, methodData, serverRes);
-        }, function (err) {
-            var serverRes = {
-                messageId: messageId,
-                hasError: true,
-                data: err
-            };
-            _this.sendWS(ws, supportMethod, methodData, serverRes);
-        });
-    };
-    SupportManager.prototype.callSupportMethodInternal = function (supportMethod) {
-        var methodData = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            methodData[_i - 1] = arguments[_i];
-        }
-        var _a;
-        var that = this;
-        if (!that._supportMethods[supportMethod]) {
-            console.log('No Support Method: ' + supportMethod);
-            return;
-        }
-        if ((methodData.length > 1 || (methodData[0] && typeof (methodData[0]) !== 'function')) && !that._supportMethods[supportMethod].skipValidation) {
-            if (!that._supportMethods[supportMethod].check) {
-                console.error('No Check Function For Method ' + supportMethod);
-                return;
-            }
-            else if (!that._supportMethods[supportMethod].check._schema) {
-                console.error('No Check Schema For Method ' + supportMethod);
-                return;
-            }
-        }
-        var promise = (_a = that._supportMethods[supportMethod].function).call.apply(_a, [Object.assign({}, that, SupportManager.prototype)].concat(methodData));
-        if (methodData[methodData.length - 1] && typeof (methodData[methodData.length - 1]) === 'function') {
-            promise.then(function (res) { return methodData[methodData.length - 1](null, res); }, function (err) { return methodData[methodData.length - 1](err, null); });
-        }
-        return promise;
-    };
-    SupportManager.prototype.callMethodInternal = function (method) {
-        var methodData = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            methodData[_i - 1] = arguments[_i];
-        }
-        var _a;
-        var that = this;
-        if (!that._mainServer.getMethodManager()._methods[method]) {
-            console.log('No Method: ' + method);
-            return;
-        }
-        if ((methodData.length > 1 || (methodData[0] && typeof (methodData[0]) !== 'function')) && !that._mainServer.getMethodManager()._methods[method].skipValidation) {
-            if (!that._mainServer.getMethodManager()._methods[method].check) {
-                console.error('No Check Function For Method ' + method);
-                return;
-            }
-            else if (!that._mainServer.getMethodManager()._methods[method].check._schema) {
-                console.error('No Check Schema For Method ' + method);
-                return;
-            }
-        }
-        var promise = (_a = that._mainServer.getMethodManager()._methods[method].function).call.apply(_a, [Object.assign({}, that, method_manager_1.MethodManager.prototype)].concat(methodData));
-        if (methodData[methodData.length - 1] && typeof (methodData[methodData.length - 1]) === 'function') {
-            promise.then(function (res) { return methodData[methodData.length - 1](null, res); }, function (err) { return methodData[methodData.length - 1](err, null); });
-        }
-        return promise;
-    };
-    SupportManager.prototype.sendWS = function (ws, method, methodData, data) {
-        this._sendQueue.splice(0, 0, {
-            id_ws: ws['id_socket'],
-            method: method,
-            methodData: methodData,
-            data: data
-        });
-    };
-    SupportManager.prototype.sendEmail = function (sendTo, subject, text, html, attachments) {
-        this._mailer.sendMail({
-            replyTo: undefined,
-            from: this.serverConfig.MAIL_FROM,
-            to: sendTo,
-            subject: subject,
-            text: text,
-            html: html,
-            attachments: attachments
-        }, function (err, info) {
-            if (err) {
-                console.log(err);
-            }
-        });
-    };
-    SupportManager.prototype.readFile = function (fileName) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', function (err, res) {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(res);
-                    }
-                });
-            }
-            else {
-                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'utf-8', function (err, res) {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve(res);
-                        }
-                    });
-                }
-            }
-        });
-    };
-    SupportManager.prototype.readImage = function (fileName) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', function (err, res) {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(res);
-                    }
-                });
-            }
-            else {
-                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'base64', function (err, res) {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve(res);
-                        }
-                    });
-                }
-            }
-        });
-    };
-    return SupportManager;
-}());
-exports.SupportManager = SupportManager;

package/methods/accounts.d.ts

@@ -1,2 +0,0 @@
-import { MethodManager } from '../managers/method.manager';
-export declare function loadAccountMethods(methodManager: MethodManager): void;

package/methods/accounts.js

@@ -1,253 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(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 });
-var simpl_schema_1 = require("simpl-schema");
-var mongoose_1 = require("mongoose");
-var user_collection_1 = require("../collections/user.collection");
-var handlebars = require("handlebars");
-var jwt = require("jsonwebtoken");
-var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
-var queue_response_collection_1 = require("../collections/queue-response.collection");
-var index_1 = require("../index");
-function loadAccountMethods(methodManager) {
-    methodManager.methods({
-        setWSAppVersion: {
-            skipQueue: true,
-            check: new simpl_schema_1.default({
-                version: Number
-            }),
-            function: function (version) {
-                return logged_in_users_collection_1.LoggedInUsers.updateOne({ id_ws: this.id_ws }, { $set: { app_version: version } }).exec();
-            }
-        },
-        reloadWS: {
-            skipQueue: true,
-            check: new simpl_schema_1.default({
-                id_ws: String
-            }),
-            function: function (id_ws) {
-                var _this = this;
-                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        queue_response_collection_1.QueueResponses.create({
-                            _id: mongoose_1.Types.ObjectId().toHexString(),
-                            __v: 0,
-                            method: 'reloadWSCommand',
-                            method_data: [],
-                            id_ws: id_ws,
-                            messageId: 0,
-                            id_user: this.id_user,
-                            user: this.user,
-                            response: {
-                                messageId: 0,
-                                hasError: false,
-                                data: 'reloadWSCommand'
-                            }
-                        }).then(function (val) {
-                            // console.log(val);
-                        });
-                        resolve();
-                        return [2 /*return*/];
-                    });
-                }); });
-            }
-        },
-        reconnectWS: {
-            skipQueue: true,
-            check: new simpl_schema_1.default({
-                id_ws: String
-            }),
-            function: function (id_ws) {
-                var _this = this;
-                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        queue_response_collection_1.QueueResponses.create({
-                            _id: mongoose_1.Types.ObjectId().toHexString(),
-                            __v: 0,
-                            method: 'reconnectWSCommand',
-                            method_data: [],
-                            id_ws: id_ws,
-                            messageId: 0,
-                            id_user: this.id_user,
-                            user: this.user,
-                            response: {
-                                messageId: 0,
-                                hasError: false,
-                                data: 'reconnectWSCommand'
-                            }
-                        });
-                        resolve();
-                        return [2 /*return*/];
-                    });
-                }); });
-            }
-        },
-        disconnectWS: {
-            skipQueue: true,
-            check: new simpl_schema_1.default({
-                id_ws: String
-            }),
-            function: function (id_ws) {
-                var _this = this;
-                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        queue_response_collection_1.QueueResponses.create({
-                            _id: mongoose_1.Types.ObjectId().toHexString(),
-                            __v: 0,
-                            method: 'disconnectWSCommand',
-                            method_data: [],
-                            id_ws: id_ws,
-                            messageId: 0,
-                            id_user: this.id_user,
-                            user: this.user,
-                            response: {
-                                messageId: 0,
-                                hasError: false,
-                                data: 'disconnectWSCommand'
-                            }
-                        });
-                        resolve();
-                        return [2 /*return*/];
-                    });
-                }); });
-            }
-        },
-        createUserAndEmailEnrollment: {
-            check: new simpl_schema_1.default({
-                data: {
-                    type: user_collection_1.Users['simplschema']
-                }
-            }),
-            function: function (data) {
-                var _this = this;
-                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    var userId, user;
-                    var _this = this;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                userId = mongoose_1.Types.ObjectId().toHexString();
-                                return [4 /*yield*/, user_collection_1.Users.create({
-                                        _id: userId,
-                                        __v: 0,
-                                        username: data.username,
-                                        email: data.email,
-                                        fullname: data.fullname,
-                                        roles: data.roles,
-                                        active: true,
-                                        readonly: false,
-                                        services: {
-                                            enrollment: jwt.sign({ id_user: userId }, this.serverConfig['JWT_SECRET'], {
-                                                expiresIn: 3 * 24 * 60 * 60 * 1000 // 3 days
-                                            })
-                                        },
-                                        phonenumber: data.phonenumber
-                                    })];
-                            case 1:
-                                user = _a.sent();
-                                user.setPassword(randomString(20, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'), (function (err, res) {
-                                    user.save();
-                                    var emailData = {
-                                        fullname: user.fullname,
-                                        user: _this.user,
-                                        url: _this.serverConfig['ROOT_URL'] + '/enroll-account?' + encodeURIComponent(_this.serverConfig['SERVER_URL']) + '&' + user.services.enrollment
-                                    };
-                                    _this.readFile('email-templates/enrollment.html').then(function (html) {
-                                        var template = handlebars.compile(html);
-                                        handlebars.registerHelper('equals', function (a, b) {
-                                            return a === b;
-                                        });
-                                        _this.sendEmail(user.email, 'ResolveIO (' + index_1.ResolveIOServer.getClientName() + ') - Enrollment Email', '', template(emailData));
-                                        resolve(true);
-                                    }, function (errEmail) { return reject(errEmail); });
-                                }));
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            }
-        },
-        resetUserPassword: {
-            check: new simpl_schema_1.default({
-                userId: {
-                    type: String
-                }
-            }),
-            function: function (userId) {
-                var _this = this;
-                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    var user, emailData_1;
-                    var _this = this;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, user_collection_1.Users.findOne({ _id: userId })];
-                            case 1:
-                                user = _a.sent();
-                                if (user) {
-                                    user.services.forgot_password = jwt.sign({ id_user: userId }, this.serverConfig['JWT_SECRET']);
-                                    emailData_1 = {
-                                        userToChangePassword: user.fullname,
-                                        userWhoResetPassword: this.user,
-                                        url: this.serverConfig['ROOT_URL'] + '/forgot-password?' + encodeURIComponent(this.serverConfig['SERVER_URL']) + '&' + user.services.forgot_password
-                                    };
-                                    user_collection_1.Users.updateOne({ _id: user._id }, { $set: { services: user.services } }).exec(function (err, res) {
-                                        _this.readFile('email-templates/forgot-password.html').then(function (html) {
-                                            var template = handlebars.compile(html);
-                                            handlebars.registerHelper('equals', function (a, b) {
-                                                return a === b;
-                                            });
-                                            _this.sendEmail(user.email, 'ResolveIO (' + index_1.ResolveIOServer.getClientName() + ') - Forgot Password', '', template(emailData_1));
-                                            resolve(true);
-                                        }, function (errEmail) { return reject(errEmail); });
-                                    });
-                                }
-                                return [2 /*return*/];
-                        }
-                    });
-                }); });
-            }
-        }
-    });
-}
-exports.loadAccountMethods = loadAccountMethods;
-function randomString(length, chars) {
-    var result = '';
-    for (var i = length; i > 0; --i) {
-        result += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return result;
-}

package/methods/aws.d.ts

@@ -1,2 +0,0 @@
-import { MethodManager } from '../managers/method.manager';
-export declare function loadAWSMethods(methodManager: MethodManager): void;