multi-db-orm 2.1.7 → 2.1.9

package/engines/mongodb.js

@@ -1,149 +1,149 @@
-const { MultiDbORM } = require("./multidb");
-
-class MongoDB extends MultiDbORM {
-
-    mongodbname
-    dbc
-    client
-    url
-    constructor(secureUrl, mongodbname) {
-        super()
-
-        this.url = secureUrl;
-        this.mongodbname = mongodbname
-
-        const MongoClient = require('mongodb').MongoClient;
-        this.client = new MongoClient(this.url, {
-            useUnifiedTopology: true,
-            useNewUrlParser: true
-        });
-        this._connect();
-    }
-
-    async _close() {
-        this.dbc.close();
-    }
-
-    async _connect() {
-        var dbc = await this.client.connect();
-        this.dbc = dbc;
-        this.db = dbc.db(this.mongodbname);
-        console.log("MongoDB Initialized");
-        this.dbType = 'mongodb'
-    }
-
-    async run(query) {
-        if (this.loglevel > 3)
-            console.log('RUN : Not Supported in DB Type', this.dbType)
-    }
-    _inq2mongop(symbol) {
-        switch (symbol) {
-            case "=":
-                return "$eq";
-            case ">":
-                return "$gt";
-            case ">=":
-                return "$gte";
-            case "<":
-                return "$lt";
-            case "<=":
-                return "$lte";
-            case "!=":
-                return "$ne";
-        }
-    }
-    async get(modelname, filter, options) {
-        this.metrics.get(modelname, filter, options);
-        if (options && options.apply && options.apply.ineq) {
-            filter[`${options.apply.field}`] = {};
-            filter[`${options.apply.field}`][`${this._inq2mongop(options.apply.ineq.op)}`] = options.apply.ineq.value
-        }
-        var crs = this.getdb().collection(modelname).find(filter);
-        if (options) {
-            if (options.apply) {
-                if (options.apply.sort) {
-                    var order = 1;
-                    if (options.apply.sort == 'desc') {
-                        order = -1;
-                    }
-                    var sortOption = {};
-                    sortOption[`${options.apply.field}`] = order;
-                    crs = crs.sort(sortOption);
-                }
-
-            } else if (options.sort) {
-
-                var sortOption = {};
-                options.sort.forEach(srt => {
-                    var order = 1;
-                    if (srt.order == 'desc') {
-                        order = -1;
-                    }
-                    sortOption[`${srt.field}`] = order;
-                });
-                crs = crs.sort(sortOption);
-            }
-
-            if (options.limit) {
-                crs.limit(options.limit)
-            }
-
-            if (options.offset) {
-                crs.skip(options.offset)
-            }
-        }
-
-        var snapshot = await crs.toArray()
-        return snapshot;
-
-    }
-
-    async getOne(modelname, filter, options) {
-        this.metrics.getOne(modelname, filter, options);
-        var snapshot = await this.getdb().collection(modelname).findOne(filter)
-        return snapshot;
-    }
-
-    async create(modelname, sampleObject) {
-        this.sync.create(modelname, sampleObject)
-        this.metrics.create(modelname, sampleObject);
-
-        if (this.loglevel > 3)
-            console.log('CREATE : Not required in DB Type', this.dbType)
-    }
-
-    async insert(modelname, object) {
-        this.sync.insert(modelname, object)
-        this.metrics.insert(modelname, object)
-
-        const collref = this.getdb().collection(modelname)
-        try {
-            return await collref.insertOne(object);
-        } catch (e) {
-
-            throw e;
-
-        }
-
-    }
-
-    async update(modelname, filter, object) {
-        this.sync.update(modelname, filter, object)
-        this.metrics.update(modelname, filter, object)
-        var resp = await this.getdb().collection(modelname).updateMany(filter, { $set: object })
-        return resp;
-    }
-
-    async delete(modelname, filter) {
-        this.sync.delete(modelname, filter)
-        this.metrics.delete(modelname, filter)
-        var resp = await this.getdb().collection(modelname).deleteMany(filter)
-        return resp;
-    }
-}
-
-
-
-module.exports = {
-    MongoDB
+const { MultiDbORM } = require("./multidb");
+
+class MongoDB extends MultiDbORM {
+
+    mongodbname
+    dbc
+    client
+    url
+    constructor(secureUrl, mongodbname) {
+        super()
+
+        this.url = secureUrl;
+        this.mongodbname = mongodbname
+
+        const MongoClient = require('mongodb').MongoClient;
+        this.client = new MongoClient(this.url, {
+            useUnifiedTopology: true,
+            useNewUrlParser: true
+        });
+        this._connect();
+    }
+
+    async _close() {
+        this.dbc.close();
+    }
+
+    async _connect() {
+        var dbc = await this.client.connect();
+        this.dbc = dbc;
+        this.db = dbc.db(this.mongodbname);
+        console.log("MongoDB Initialized");
+        this.dbType = 'mongodb'
+    }
+
+    async run(query) {
+        if (this.loglevel > 3)
+            console.log('RUN : Not Supported in DB Type', this.dbType)
+    }
+    _inq2mongop(symbol) {
+        switch (symbol) {
+            case "=":
+                return "$eq";
+            case ">":
+                return "$gt";
+            case ">=":
+                return "$gte";
+            case "<":
+                return "$lt";
+            case "<=":
+                return "$lte";
+            case "!=":
+                return "$ne";
+        }
+    }
+    async get(modelname, filter, options) {
+        this.metrics.get(modelname, filter, options);
+        if (options && options.apply && options.apply.ineq) {
+            filter[`${options.apply.field}`] = {};
+            filter[`${options.apply.field}`][`${this._inq2mongop(options.apply.ineq.op)}`] = options.apply.ineq.value
+        }
+        var crs = this.getdb().collection(modelname).find(filter);
+        if (options) {
+            if (options.apply) {
+                if (options.apply.sort) {
+                    var order = 1;
+                    if (options.apply.sort == 'desc') {
+                        order = -1;
+                    }
+                    var sortOption = {};
+                    sortOption[`${options.apply.field}`] = order;
+                    crs = crs.sort(sortOption);
+                }
+
+            } else if (options.sort) {
+
+                var sortOption = {};
+                options.sort.forEach(srt => {
+                    var order = 1;
+                    if (srt.order == 'desc') {
+                        order = -1;
+                    }
+                    sortOption[`${srt.field}`] = order;
+                });
+                crs = crs.sort(sortOption);
+            }
+
+            if (options.limit) {
+                crs.limit(options.limit)
+            }
+
+            if (options.offset) {
+                crs.skip(options.offset)
+            }
+        }
+
+        var snapshot = await crs.toArray()
+        return snapshot;
+
+    }
+
+    async getOne(modelname, filter, options) {
+        this.metrics.getOne(modelname, filter, options);
+        var snapshot = await this.getdb().collection(modelname).findOne(filter)
+        return snapshot;
+    }
+
+    async create(modelname, sampleObject) {
+        this.sync.create(modelname, sampleObject)
+        this.metrics.create(modelname, sampleObject);
+
+        if (this.loglevel > 3)
+            console.log('CREATE : Not required in DB Type', this.dbType)
+    }
+
+    async insert(modelname, object) {
+        this.sync.insert(modelname, object)
+        this.metrics.insert(modelname, object)
+
+        const collref = this.getdb().collection(modelname)
+        try {
+            return await collref.insertOne(object);
+        } catch (e) {
+
+            throw e;
+
+        }
+
+    }
+
+    async update(modelname, filter, object) {
+        this.sync.update(modelname, filter, object)
+        this.metrics.update(modelname, filter, object)
+        var resp = await this.getdb().collection(modelname).updateMany(filter, { $set: object })
+        return resp;
+    }
+
+    async delete(modelname, filter) {
+        this.sync.delete(modelname, filter)
+        this.metrics.delete(modelname, filter)
+        var resp = await this.getdb().collection(modelname).deleteMany(filter)
+        return resp;
+    }
+}
+
+
+
+module.exports = {
+    MongoDB
 }

package/engines/multidb.d.ts

@@ -1,29 +1,29 @@
-export class MultiDbORM {
-    db: any;
-    dbType: string;
-    reqMade: number;
-    lastQLatency: any;
-    loglevel: number;
-    sync: import('../sync').Sync;
-    metrics: import('./metrics').Metrics;
-
-    constructor(db: any);
-
-    async connect(): Promise<void>;
-
-    setdb(db: any): void;
-
-    getdb(): any;
-
-    async get(modelname: string, filter: Record<string, any>): Promise<void>;
-
-    async getOne(modelname: string, filter: Record<string, any>): Promise<void>;
-
-    async create(modelname: string, object: Record<string, any>): Promise<void>;
-
-    async insert(modelname: string, object: Record<string, any>): Promise<void>;
-
-    async update(modelname: string, filter: Record<string, any>, object: Record<string, any>): Promise<void>;
-
-    async delete(modelname: string, filter: Record<string, any>): Promise<void>;
-}
+export class MultiDbORM {
+    db: any;
+    dbType: string;
+    reqMade: number;
+    lastQLatency: any;
+    loglevel: number;
+    sync: import('../sync').Sync;
+    metrics: import('./metrics').Metrics;
+
+    constructor(db: any);
+
+    async connect(): Promise<void>;
+
+    setdb(db: any): void;
+
+    getdb(): any;
+
+    async get(modelname: string, filter: Record<string, any>): Promise<any>;
+
+    async getOne(modelname: string, filter: Record<string, any>): Promise<any>;
+
+    async create(modelname: string, object: Record<string, any>): Promise<any>;
+
+    async insert(modelname: string, object: Record<string, any>): Promise<any>;
+
+    async update(modelname: string, filter: Record<string, any>, object: Record<string, any>): Promise<any>;
+
+    async delete(modelname: string, filter: Record<string, any>): Promise<any>;
+}

package/engines/multidb.js

@@ -1,68 +1,68 @@
-const { Sync } = require('../sync')
-const { Metrics } = require('./metrics')
-class MultiDbORM {
-
-    db
-    dbType
-    reqMade
-    lastQLatency
-    loglevel = 0
-    sync
-    metrics
-
-    constructor(db) {
-        this.db = db
-        this.sync = new Sync()
-        this.metrics = new Metrics(this.loglevel)
-    }
-
-    async connect() {
-
-    }
-
-    setdb(db) {
-        this.reqMade = 0
-        this.db = db;
-    }
-
-    getdb() {
-        this.reqMade++
-        return this.db;
-    }
-
-    async get(modelname, filter) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-    async getOne(modelname, filter) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-    async create(modelname, object) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-    async insert(modelname, object) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-    async update(modelname, filter, object) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-    async delete(modelname, filter) {
-        if (this.loglevel > 4)
-            console.log("Not implemented")
-    }
-
-}
-
-
-module.exports = {
-    MultiDbORM: MultiDbORM
+const { Sync } = require('../sync')
+const { Metrics } = require('./metrics')
+class MultiDbORM {
+
+    db
+    dbType
+    reqMade
+    lastQLatency
+    loglevel = 0
+    sync
+    metrics
+
+    constructor(db) {
+        this.db = db
+        this.sync = new Sync()
+        this.metrics = new Metrics(this.loglevel)
+    }
+
+    async connect() {
+
+    }
+
+    setdb(db) {
+        this.reqMade = 0
+        this.db = db;
+    }
+
+    getdb() {
+        this.reqMade++
+        return this.db;
+    }
+
+    async get(modelname, filter) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+    async getOne(modelname, filter) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+    async create(modelname, object) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+    async insert(modelname, object) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+    async update(modelname, filter, object) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+    async delete(modelname, filter) {
+        if (this.loglevel > 4)
+            console.log("Not implemented")
+    }
+
+}
+
+
+module.exports = {
+    MultiDbORM: MultiDbORM
 }

package/engines/mysqldb.d.ts

@@ -1,44 +1,44 @@
-import { MultiDbORM } from './multidb';
-
-declare module 'mysql' {
-    import { EventEmitter } from 'events';
-
-    export interface ConnectionConfig {
-        host: string;
-        port: number;
-        user: string;
-        password: string;
-        database?: string;
-    }
-
-    export class Connection extends EventEmitter {
-        constructor(config: ConnectionConfig);
-        connect(): void;
-        end(): void;
-        query(query: string, callback: (error: Error | null, results: any, fields: any) => void): void;
-    }
-}
-
-export type MySQLDBConfig = {
-    host: string;
-    port: string;
-    username: string;
-    password: string;
-    database: string;
-    connectionLimit?: Number;
-    connectTimeout?: Number;
-    acquireTimeout?: Number;
-    timeout?: Number;
-}
-
-export class MySQLDB extends MultiDbORM {
-    db: typeof import('mysql')
-    mysql: typeof import('mysql');
-    connection: import('mysql').Connection;
-
-    constructor(credentials: MySQLDBConfig);
-
-    run(query: string): Promise<any[]>;
-
-    closePool(): void;
-}
+import { MultiDbORM } from './multidb';
+
+declare module 'mysql' {
+    import { EventEmitter } from 'events';
+
+    export interface ConnectionConfig {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        database?: string;
+    }
+
+    export class Connection extends EventEmitter {
+        constructor(config: ConnectionConfig);
+        connect(): void;
+        end(): void;
+        query(query: string, callback: (error: Error | null, results: any, fields: any) => void): void;
+    }
+}
+
+export type MySQLDBConfig = {
+    host: string;
+    port: string;
+    username: string;
+    password: string;
+    database: string;
+    connectionLimit?: Number;
+    connectTimeout?: Number;
+    acquireTimeout?: Number;
+    timeout?: Number;
+}
+
+export class MySQLDB extends MultiDbORM {
+    db: typeof import('mysql')
+    mysql: typeof import('mysql');
+    connection: import('mysql').Connection;
+
+    constructor(credentials: MySQLDBConfig);
+
+    run(query: string): Promise<any[]>;
+
+    closePool(): void;
+}