multi-db-orm 3.0.12 → 3.1.0

package/engines/mongodb.d.ts

@@ -1,18 +1,18 @@
-import MongoClient from 'mongodb/lib/mongo_client';
-import { MultiDbORM } from './multidb';
-
-export declare class MongoDB extends MultiDbORM {
-    mongodbname: string;
-    dbc: typeof import('mongodb');
-    db: typeof import('mongodb');
-    client: MongoClient;
-    url: string;
-
-    constructor(secureUrl: string, mongodbname: string);
-
-    _close(): Promise<void>;
-
-    _connect(): Promise<void>;
-
-    run(query: string): Promise<any>;
-}
+import MongoClient from 'mongodb/lib/mongo_client';
+import { MultiDbORM } from './multidb';
+
+export declare class MongoDB extends MultiDbORM {
+    mongodbname: string;
+    dbc: typeof import('mongodb');
+    db: typeof import('mongodb');
+    client: MongoClient;
+    url: string;
+
+    constructor(secureUrl: string, mongodbname: string);
+
+    _close(): Promise<void>;
+
+    _connect(): Promise<void>;
+
+    run(query: string): Promise<any>;
+}

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,41 +1,41 @@
-export class MultiDbORM {
-    db: any;
-    dbType: string;
-    reqMade: number;
-    lastQLatency: any;
-    loglevel: number;
-    sync: import('../sync').Sync;
-    metrics: import('./metrics').Metrics;
-
-    constructor(db: any);
-
-    connect(): Promise<void>;
-
-    setdb(db: any): void;
-
-    getdb(): any;
-
-    get(modelname: string, filter?: Record<string, any>, options?: {
-        apply?: {
-            field: string,
-            sort: string,
-            ineq: {
-                op: '>=' | '<=' | '=' | '>' | '<',
-                value: string | number | boolean
-            }
-        },
-        sort?: { field: string, order: 'asc' | 'desc' }[]
-        limit?: number,
-        offset?: number
-    }): Promise<any[]>;
-
-    getOne(modelname: string, filter: Record<string, any>): Promise<any>;
-
-    create(modelname: string, object: Record<string, any>): Promise<any>;
-
-    insert(modelname: string, object: Record<string, any>): Promise<any>;
-
-    update(modelname: string, filter: Record<string, any>, object: Record<string, any>): Promise<any>;
-
-    delete(modelname: string, filter?: Record<string, any>): Promise<any>;
-}
+export class MultiDbORM {
+    db: any;
+    dbType: string;
+    reqMade: number;
+    lastQLatency: any;
+    loglevel: number;
+    sync: import('../sync').Sync;
+    metrics: import('./metrics').Metrics;
+
+    constructor(db: any);
+
+    connect(): Promise<void>;
+
+    setdb(db: any): void;
+
+    getdb(): any;
+
+    get<T = any>(modelname: string, filter?: Record<string, any>, options?: {
+        apply?: {
+            field: string,
+            sort: string,
+            ineq: {
+                op: '>=' | '<=' | '=' | '>' | '<',
+                value: string | number | boolean
+            }
+        },
+        sort?: { field: string, order: 'asc' | 'desc' }[]
+        limit?: number,
+        offset?: number
+    }): Promise<T[]>;
+
+    getOne<T = any>(modelname: string, filter: Record<string, any>): Promise<T>;
+
+    create<T = any>(modelname: string, object: Record<string, any>): Promise<T>;
+
+    insert<T = any>(modelname: string, object: Record<string, any>): Promise<T>;
+
+    update<T = any>(modelname: string, filter: Record<string, any>, object: Record<string, any>): Promise<T>;
+
+    delete<T = any>(modelname: string, filter?: Record<string, any>): Promise<T>;
+}

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,25 +1,25 @@
-import { MultiDbORM } from './multidb';
-
-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';
+
+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;
+}

package/engines/oracledb.d.ts

@@ -1,24 +1,24 @@
-import { MultiDbORM } from './multidb';
-
-export interface OracleDBConfig {
-    username: string;
-    password: string;
-    net_service_name: string;
-    wallet_dir: string;
-    connection_pool_name?: string;
-    wallet_password?: string;
-    lib_dir?: string;
-}
-
-export declare class OracleDB extends MultiDbORM {
-    db: typeof import('oracledb')
-    connection_pool_name: string;
-    schema: string;
-    pool_creation: Promise<any>;
-
-    constructor(config: OracleDBConfig);
-
-    connect(): Promise<void>;
-
-    run(query: string): Promise<any>;
-}
+import { MultiDbORM } from './multidb';
+
+export interface OracleDBConfig {
+    username: string;
+    password: string;
+    net_service_name: string;
+    wallet_dir: string;
+    connection_pool_name?: string;
+    wallet_password?: string;
+    lib_dir?: string;
+}
+
+export declare class OracleDB extends MultiDbORM {
+    db: typeof import('oracledb')
+    connection_pool_name: string;
+    schema: string;
+    pool_creation: Promise<any>;
+
+    constructor(config: OracleDBConfig);
+
+    connect(): Promise<void>;
+
+    run(query: string): Promise<any>;
+}