Node.js: Aerospike simple wrap using promises

AlgaAerospike.js

/**
 * Created by www.Alga.me on 12/7/17.
 * 
 * # npm install aerospike
 */

import aerospike from 'aerospike'

export default class Aerospike {
    constructor(props = {}) {
        this.props = props;
        this.isConnected = false;
    }

    createConnection() {
        if(this.isConnected) {
            return Promise.resolve();
        }

        this.aerospike = aerospike;
        this.filter = aerospike.filter;
        this.client = this.aerospike.client({
            'hosts': this.props.connection,
            policies: {
                key: 1
            }
        });

        return new Promise((resolve,reject)=> {
            this.client.connect((err) => {
                if (err) {
                    return reject(err);
                }

                this.isConnected = true;
                resolve();
            });
        });
    }

    disconnect(){
        this.client.close();
    }

    testConnection(){
        return Promise.resolve()
            .then(()=>this.createConnection())
            .then(()=>this.isConnected)
    }

    setSet(set){
        this.props.set = set;
    }

    key(key){
        return new this.aerospike.Key(this.props.namespace, this.props.set, key);
    }

    put(id, rec){
        const key = this.key(id);
        return new Promise((resolve,reject)=>{
            this.client.put(key, rec, (err) => {
                if (err) {
                    return reject(err);
                }

                resolve();
            })
        });
    }

    createWithKey(key, rec){
        return new Promise((resolve,reject)=>{
            this.client.put(key, rec, (err) => {
                if (err) {
                    return reject(err);
                }

                resolve();
            })
        });
    }

    destroy(id){
        const key = this.key(id);
        return new Promise((resolve,reject)=>{
            this.client.remove(key, (err) => {
                if (err) {
                    return reject(err);
                }

                resolve();
            })
        });
    }

    scan(options) {

        Object.assign({
            concurrent: true,
            nobins: false
        }, options);

        return new Promise((resolve,reject)=>{
            const scan = this.client.scan(this.props.namespace, this.props.set);
            scan.concurrent = true;
            scan.nobins = false;

            let recordCount = 0;
            let recordsArray = [];
            const stream = scan.foreach();

            stream.on('data', function (record,a,key,c,d) {
                recordCount++;

                recordsArray.push({
                    key,
                    record
                })
            });

            stream.on('error', function (error) {
                reject(error);
            });

            stream.on('end', function (record,a,b) {
                resolve(recordsArray);
            });
        });
    }

    query(filters) {

        return new Promise((resolve,reject)=>{
            const scan = this.client.query(this.props.namespace, this.props.set, { filters });

            let recordCount = 0;
            let recordsArray = [];
            const stream = scan.foreach();

            stream.on('data', function (record,a,key,c,d) {
                recordCount++;

                recordsArray.push({
                    key,
                    record
                })
            });

            stream.on('error', function (error) {
                reject(error);
            });

            stream.on('end', function (record,a,b) {
                resolve(recordsArray);
            });
        });
    }

    read(id){
        const key = this.key(id);

        return new Promise((resolve,reject)=> {
            this.client.get(key, function (error, record, metadata) {
                if (error) {
                    reject(error);
                }

                resolve(record);
            })
        });
    }
}