@salilvnair/jsxpa/public/lib/provider/nedb/service/nedb-repository.service.js

React Persistant API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_common_util_1 = require("../util/json-common.util");
var nedb_manager_service_1 = require("./nedb-manager.service");
var NeDBConstant = require("../constant/nedb.constant");
var nedb_service_1 = require("./nedb.service");
var NeDBRepository = /** @class */ (function () {
    function NeDBRepository() {
        this.initializedNeDB = false;
        this.initializedNeDBConfig = false;
        this.neDBConnectionManager = new nedb_manager_service_1.NeDBConnectionManager();
        this.neDBService = new nedb_service_1.NeDBService();
        this.init();
    }
    NeDBRepository.prototype.init = function () {
        if (!this.initializedNeDBConfig) {
            this.initNeDBConfig();
            this.initializedNeDBConfig = true;
        }
        if (!this.initializedNeDB) {
            this.initNeDb();
            this.initializedNeDB = true;
        }
    };
    NeDBRepository.prototype.initNeDb = function () {
        if (this.neDBConfig.inMemoryDB) {
            this.neDB = this.neDBConnectionManager.getInMemoryInstance();
        }
        else {
            if (this.neDBConfig.createExplicitDB) {
                this.initExplicitDB();
            }
            else {
                this.initAppDefinedDB();
            }
        }
    };
    NeDBRepository.prototype.setPersistance = function (inMemory) {
        if (inMemory) {
            this.neDB = this.neDBConnectionManager.getInMemoryInstance();
        }
        else {
            this.initExplicitDB();
        }
    };
    NeDBRepository.prototype.initExplicitDB = function () {
        this.neDB = this.neDBConnectionManager.getDefinedInstance(this.getDatabaseFolderName(), this.getDatabaseNameFromRepo());
    };
    NeDBRepository.prototype.initAppDefinedDB = function () {
        this.neDB = this.neDBConnectionManager.getInstance();
    };
    NeDBRepository.prototype.getDatabaseNameFromRepo = function () {
        var value = this.databaseName();
        if (value) {
            return value.toLocaleLowerCase();
        }
        return value;
    };
    NeDBRepository.prototype.getDatabaseFolderName = function () {
        return NeDBConstant.NEDB_CONFIG_DATABASE_FOLDER_NAME;
    };
    NeDBRepository.prototype.initNeDBConfig = function () {
        this.neDBConfig = this.neDBConnectionManager.getNeDBConfig(this.config);
    };
    NeDBRepository.prototype.compactDatabase = function () {
        this.neDB.persistence.compactDatafile();
    };
    NeDBRepository.prototype.find = function (entity) {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.find(entity, { multi: true }, function (err, entityDatas) {
                if (err !== null) {
                    return reject(err);
                }
                resolve(entityDatas);
            });
        });
    };
    NeDBRepository.prototype.selectAll = function () {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.find({}, function (err, entityDatas) {
                if (err !== null) {
                    return reject(err);
                }
                resolve(entityDatas);
            });
        });
    };
    NeDBRepository.prototype.selectAllSync = function () {
        return this.neDBService.selectAllSync(this.getDatabaseNameFromRepo());
    };
    NeDBRepository.prototype.selectOneSync = function (id) {
        return this.neDBService.selectOneSync(id, this.getDatabaseNameFromRepo());
    };
    NeDBRepository.prototype.selectOneByColumnSync = function (coloumnName, coloumnValue) {
        return this.neDBService.selectOneByColumnSync(coloumnName, coloumnValue, this.getDatabaseNameFromRepo());
    };
    NeDBRepository.prototype.findOne = function (id) {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.find({ _id: id }, function (err, entityData) {
                if (err !== null) {
                    return reject(err);
                }
                resolve(entityData);
            });
        });
    };
    NeDBRepository.prototype.update = function (oldEntity, newEntity) {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.update(oldEntity, newEntity, {}, function (err, entityData) {
                if (err !== null) {
                    console.dir(err);
                    return reject(err);
                }
                resolve(entityData);
            });
        });
    };
    NeDBRepository.prototype.save = function (entity) {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.insert(entity, function (err, entityData) {
                if (err !== null) {
                    return reject(err);
                }
                resolve(entityData);
            });
        });
    };
    NeDBRepository.prototype.delete = function (entity, removeNullValues, removeEmptyValues) {
        var self = this;
        if (removeNullValues) {
            json_common_util_1.JsonCommonUtil.removeNullValues(entity);
        }
        else if (removeEmptyValues) {
            json_common_util_1.JsonCommonUtil.removeEmptyValues(entity);
        }
        if (removeEmptyValues && removeNullValues) {
            json_common_util_1.JsonCommonUtil.removeNEValues(entity);
        }
        return new Promise(function (resolve, reject) {
            self.neDB.remove(entity, { multi: true }, function (err, deleteCount) {
                if (err !== null)
                    return reject(err);
                resolve(deleteCount);
            });
        });
    };
    NeDBRepository.prototype.deleteById = function (id) {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.remove({ _id: id }, function (err, deleteCount) {
                if (err !== null)
                    return reject(err);
                resolve(deleteCount);
            });
        });
    };
    NeDBRepository.prototype.deleteAll = function () {
        var self = this;
        return new Promise(function (resolve, reject) {
            self.neDB.remove({}, { multi: true }, function (err, deleteCount) {
                if (err !== null)
                    return reject(err);
                resolve(deleteCount);
            });
        });
    };
    return NeDBRepository;
}());
exports.NeDBRepository = NeDBRepository;