k8w-promise-mysql/src/PromiseMyCluster.js

Simple native Promise wrapper for mysqljs/mysql

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
class PromiseMyCluster {
    constructor(cluster) {
        this._cluster = cluster;
        this.on = this._cluster.on.bind(this._cluster);
    }
    /**
     * @param option 默认为master
     *               "all"：所有节点，该参数下只能进行读操作
     *               "master"：主节点，可以进行读写操作
     *               "slave"：从节点，只能进行读操作
     */
    query(query, values, option = 'master') {
        let args = [];
        for (let i = 0; i < 2; ++i) {
            args.push(arguments[i]);
        }
        return new Promise((rs, rj) => {
            args.push((err, results, fields) => {
                if (err) {
                    rj(err);
                }
                else {
                    rs({
                        results: results,
                        fields: fields
                    });
                }
            });
            let pool;
            switch (option) {
                case 'master':
                    pool = this._cluster.of('MASTER*', 'random');
                    break;
                case 'slave':
                    pool = this._cluster.of('SLAVE*', 'random');
                    break;
                case 'all':
                default:
                    pool = this._cluster.of('*', 'random');
                    break;
            }
            pool.query.apply(pool, args);
        });
    }
    /**
     * @param option 默认为slave
     *               "all"：所有节点，该参数下只能进行读操作
     *               "master"：主节点，可以进行读写操作
     *               "slave"：从节点，只能进行读操作
     */
    select(query, values) {
        return this.query(query, values, 'slave');
    }
    ;
    /**
     * @param option 默认为slave
     *               "all"：所有节点，该参数下只能进行读操作
     *               "master"：主节点，可以进行读写操作
     *               "slave"：从节点，只能进行读操作
     */
    insert(query, values) {
        return this.query(query, values, 'master');
    }
    ;
    /**
     * @param option 默认为slave
     *               "all"：所有节点，该参数下只能进行读操作
     *               "master"：主节点，可以进行读写操作
     *               "slave"：从节点，只能进行读操作
     */
    update(query, values) {
        return this.query(query, values, 'master');
    }
    ;
    /**
     * @param option 默认为slave
     *               "all"：所有节点，该参数下只能进行读操作
     *               "master"：主节点，可以进行读写操作
     *               "slave"：从节点，只能进行读操作
     */
    delete(query, values) {
        return this.query(query, values, 'master');
    }
    end() {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((rs, rj) => {
                this._cluster.end(err => {
                    if (err) {
                        rj(err);
                    }
                    else {
                        rs();
                    }
                });
            });
        });
    }
}
exports.default = PromiseMyCluster;