multi-db-orm 3.0.12 → 3.1.1

package/engines/metrics.js

@@ -1,78 +1,158 @@
-class Metrics {
-
-    loglevel = 1
-    dbstats;
-
-    constructor(loglevel) {
-        this.loglevel = loglevel;
-        this.dbstats = {
-            reads: 0,
-            batchReads: 0,
-            inserts: 0,
-            updates: 0,
-            deletes: 0
-        }
-    }
-
-    printStatus() {
-        console.log(dbstats)
-    }
-
-    reset() {
-        this.dbstats = {
-            reads: 0,
-            batchReads: 0,
-            inserts: 0,
-            updates: 0,
-            deletes: 0
-        }
-    }
-
-    getStatus() {
-        this.dbstats.readsTotal = this.dbstats.reads + this.dbstats.batchReads;
-        return this.dbstats;
-    }
-
-    async get(modelname, filter) {
-        this.dbstats.batchReads++;
-        if (this.loglevel > 4)
-            this.printStatus()
-    }
-
-    async getOne(modelname, filter) {
-        this.dbstats.reads++;
-        if (this.loglevel > 4)
-            this.printStatus()
-    }
-
-    async create(modelname, object) {
-        this.dbstats.inserts++;
-        if (this.loglevel > 4)
-            this.printStatus()
-    }
-
-    async insert(modelname, object) {
-        this.dbstats.inserts++;
-        if (this.loglevel > 4)
-            printStatus()
-    }
-
-    async update(modelname, filter, object) {
-        this.dbstats.updates++;
-        if (this.loglevel > 4)
-            this.printStatus()
-    }
-
-    async delete(modelname, filter) {
-        this.dbstats.deletes++;
-        if (this.loglevel > 4)
-            this.printStatus()
-    }
-
-}
-
-
-
-module.exports = {
-    Metrics
+class Metrics {
+
+    loglevel = 1
+    dbstats;
+
+    constructor(loglevel) {
+        this.loglevel = loglevel;
+        this.dbstats = {
+            reads: 0,
+            batchReads: 0,
+            inserts: 0,
+            updates: 0,
+            deletes: 0
+        }
+    }
+    setLogLevel(level) {
+        this.loglevel = level;
+    }
+
+    printStatus() {
+        console.log(this.dbstats)
+    }
+
+    reset() {
+        this.dbstats = {
+            reads: 0,
+            batchReads: 0,
+            inserts: 0,
+            updates: 0,
+            deletes: 0
+        }
+    }
+
+    getStatus() {
+        this.dbstats.readsTotal = this.dbstats.reads + this.dbstats.batchReads;
+        return this.dbstats;
+    }
+
+    async get(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.batchReads++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'get', start, { filter })
+    }
+
+    async getOne(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.reads++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'getOne', start, { filter })
+    }
+
+    async create(modelname, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.inserts++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'create', start, { object })
+    }
+
+    async insert(modelname, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.inserts++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'insert', start, { object })
+    }
+
+    async update(modelname, filter, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.updates++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'update', start, { filter, object })
+    }
+
+    async delete(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
+        this.dbstats.deletes++;
+        if (this.loglevel > 4)
+            this.printStatus()
+        this._logOperation(modelname, 'delete', start, { filter })
+    }
+
+    _safeStringify(v) {
+        try {
+            return JSON.stringify(v)
+        } catch (e) {
+            return String(v)
+        }
+    }
+
+    startSpan(operation) {
+        return { startTime: process.hrtime.bigint(), operation }
+    }
+
+    updateSpan() {
+        return this.startSpan('update')
+    }
+
+    insertSpan() {
+        return this.startSpan('insert')
+    }
+
+    getSpan() {
+        return this.startSpan('get')
+    }
+
+    getOneSpan() {
+        return this.startSpan('getOne')
+    }
+
+    createSpan() {
+        return this.startSpan('create')
+    }
+
+    deleteSpan() {
+        return this.startSpan('delete')
+    }
+
+    _logOperation(modelname, operation, startTime, details) {
+        if (!(this.loglevel > 3)) return
+        const elapsedMs = Number(process.hrtime.bigint() - startTime) / 1e6
+        if (this.loglevel > 4) {
+            const parts = []
+            if (details) {
+                if (details.filter !== undefined) parts.push(`filter=${this._safeStringify(details.filter)}`)
+                if (details.object !== undefined) parts.push(`object=${this._safeStringify(details.object)}`)
+                if (details.sort !== undefined) parts.push(`sort=${this._safeStringify(details.sort)}`)
+            }
+            const detailStr = parts.length ? parts.join(' ') : ''
+            console.log(`${operation} ${modelname} in ${elapsedMs.toFixed(3)}ms`, detailStr)
+        } else {
+            console.log(`${operation} ${modelname} in ${elapsedMs.toFixed(3)}ms`)
+        }
+    }
+
+}
+
+
+
+module.exports = {
+    Metrics
 }

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,156 @@
-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) {
+        const span = this.metrics.getSpan();
+        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()
+        this.metrics.get(modelname, filter, options, span);
+        return snapshot;
+
+    }
+
+    async getOne(modelname, filter, options) {
+        const span = this.metrics.getOneSpan();
+        var snapshot = await this.getdb().collection(modelname).findOne(filter)
+        this.metrics.getOne(modelname, filter, options, span);
+        return snapshot;
+    }
+
+    async create(modelname, sampleObject) {
+        this.sync.create(modelname, sampleObject)
+        const span = this.metrics.createSpan();
+        this.metrics.create(modelname, sampleObject, span);
+
+        if (this.loglevel > 3)
+            console.log('CREATE : Not required in DB Type', this.dbType)
+    }
+
+    async insert(modelname, object) {
+        this.sync.insert(modelname, object)
+        const span = this.metrics.insertSpan();
+
+        const collref = this.getdb().collection(modelname)
+        try {
+            const res = await collref.insertOne(object);
+            this.metrics.insert(modelname, object, span);
+            return res;
+        } catch (e) {
+
+            throw e;
+
+        }
+
+    }
+
+    async update(modelname, filter, object) {
+        this.sync.update(modelname, filter, object)
+        const span = this.metrics.updateSpan();
+        var resp = await this.getdb().collection(modelname).updateMany(filter, { $set: object })
+        this.metrics.update(modelname, filter, object, span)
+        return resp;
+    }
+
+    async delete(modelname, filter) {
+        this.sync.delete(modelname, filter)
+        const span = this.metrics.deleteSpan();
+        var resp = await this.getdb().collection(modelname).deleteMany(filter)
+        this.metrics.delete(modelname, filter, span)
+        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>;
+}