multi-db-orm 2.1.1 → 2.1.3

package/README.md

@@ -10,6 +10,7 @@ Supported databases:
 2. Google Firestore
 3. SQlite3
 4. Oracle
+4. MySQL
 
 ### Install
 The package is available on npm
@@ -24,11 +25,12 @@ npm install --save mongodb
 npm install --save firebase-admin
 npm install --save sqlite3
 npm install --save oracledb oracle-instantclient
+npm install --save mysql
 ```
 
 Configure the database
 ```
-const { MultiDbORM, FireStoreDB, MongoDB, SQLiteDB, Sync } = require("multi-db-orm");
+const { MultiDbORM, FireStoreDB, MongoDB, SQLiteDB, MySQLDB, Sync } = require("multi-db-orm");
 
 // You can choose to initialize any or all of the supported databases in singe app
 
@@ -53,6 +55,15 @@ var oracledb = new OracleDB({
         connection_pool_name:'your-conn-pool-name' //optional
     });
 
+// MySQLDB
+var mysqldb = new MySQLDB({
+    "host": "db.mysql.com",
+    "port": "3306",
+    "username": "test",
+    "password": "Password@123",
+    "database": "test"
+});
+
 var db = firebasedb;
 ```
 

package/engines/firestoredb.d.ts

@@ -0,0 +1,39 @@
+import { MultiDbORM, MultiDbORMOptions } from './MultiDbORM';
+
+interface ServiceAccount {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+}
+
+export declare class FireStoreDB extends MultiDbORM {
+    admin: any; // Replace 'any' with actual Firebase Admin library types
+    serviceAccount: ServiceAccount;
+
+    constructor(serviceAccount: ServiceAccount, appname?: string);
+
+    async run(query: string): Promise<any>;
+
+    attachOptions(modelref: any, options: any): any;
+
+    async _get(modelname: string, filter: any, options?: any): Promise<any>;
+
+    async get(modelname: string, filter: any, options?: any): Promise<any>;
+
+    async getOne(modelname: string, filter: any, id?: string, options?: any): Promise<any>;
+
+    async create(modelname: string, sampleObject: any): Promise<any>;
+
+    async insert(modelname: string, object: any, id?: string): Promise<any>;
+
+    async update(modelname: string, filter: any, object: any, id?: string): Promise<any>;
+
+    async delete(modelname: string, filter: any, id?: string): Promise<any>;
+}

package/engines/index.d.ts

@@ -0,0 +1,5 @@
+export { MultiDbORM } from './engines/multidb';
+export { SQLiteDB } from './engines/sqlitedb';
+export { MongoDB } from './engines/mongodb';
+export { FireStoreDB } from './engines/firestoredb';
+export { OracleDB } from './engines/oracledb';

package/engines/metrics.d.ts

@@ -0,0 +1,9 @@
+export class Metrics {
+    constructor(loglevel: number);
+    get(modelname: string, filter: any, options: any): void;
+    getOne(modelname: string, filter: any): void;
+    create(modelname: string, sampleObject: any): void;
+    insert(modelname: string, object: any): void;
+    update(modelname: string, filter: any, object: any): void;
+    delete(modelname: string, filter: any): void;
+}

package/engines/mongodb.d.ts

@@ -0,0 +1,18 @@
+import MongoClient from 'mongodb/lib/mongo_client';
+import { MultiDbORM, MultiDbORMOptions } from './MultiDbORM';
+
+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);
+
+    async _close(): Promise<void>;
+
+    async _connect(): Promise<void>;
+
+    async run(query: string): Promise<any>;
+}

package/engines/multidb.d.ts

@@ -0,0 +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>;
+}

package/engines/mysqldb.d.ts

@@ -0,0 +1,42 @@
+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 class MySQLDB extends MultiDbORM {
+    db: typeof import('mysql')
+    mysql: typeof import('mysql');
+    connection: import('mysql').Connection;
+
+    constructor(credentials: {
+        host: string;
+        port: string;
+        username: string;
+        password: string;
+        database: string;
+        connectionLimit?: Number;
+        connectTimeout?: Number;
+        acquireTimeout?: Number;
+        timeout?: Number;
+    });
+
+    run(query: string): Promise<any[]>;
+
+    closePool(): void;
+}

package/engines/mysqldb.js

@@ -0,0 +1,212 @@
+const mysql = require('mysql');
+const { MultiDbORM } = require('./multidb');
+
+class MySQLDB extends MultiDbORM {
+
+    mysql;
+    pool;
+    dataMap = {
+        "id": "VARCHAR(50) NOT NULL PRIMARY KEY",
+        "string": "VARCHAR(4000)",
+        "number": "DOUBLE",
+        "boolean": "BOOL",
+        "array": "TEXT",
+        "object": "JSON"
+    };
+
+    constructor(credentials) {
+        super();
+        this.mysql = mysql;
+        this.pool = mysql.createPool({
+            connectionLimit: credentials.connectionLimit || 10,
+            host: credentials.host,
+            port: credentials.port,
+            user: credentials.username,
+            password: credentials.password,
+            database: credentials.database,
+            waitForConnections: true,
+            queueLimit: 0,
+            connectTimeout: credentials.connectTimeout || 10000,
+            acquireTimeout: credentials.acquireTimeout || 10000,
+            timeout: credentials.timeout || 60000
+        });
+
+        this.pool.on('connection', (connection) => {
+            if (this.loglevel > 1)
+                console.log('MySQLDB: New connection acquired');
+        });
+
+        this.pool.on('error', (err) => {
+            if (this.loglevel > 0)
+                console.error('MySQLDB: Pool error:', err);
+        });
+
+        this.dbType = 'mysql';
+        this.reqMade = 0;
+    }
+
+    async run(query) {
+        var that = this;
+        this.reqMade++;
+        return new Promise(function (resolve, reject) {
+            that.pool.query(query, function (err, results) {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(results);
+                }
+                if (that.loglevel > 3) {
+                    console.log("Query ", query, ' -> ', results);
+                }
+            });
+        });
+    }
+
+    async get(modelname, filter, options) {
+        this.metrics.get(modelname, filter, options);
+        var where = '';
+        for (var key in filter) {
+            where = where + `${key} = '${filter[key]}' AND `;
+        }
+        where = where + " 1 ";
+        var sort = "";
+        if (options) {
+            if (options.apply) {
+                if (options.apply.ineq) {
+                    where = where + ` AND '${options.apply.field}' ${options.apply.ineq.op} '${options.apply.ineq.value}'`;
+                }
+                if (options.apply.sort) {
+                    sort = `ORDER BY ${options.apply.field} ${options.apply.sort}`;
+                }
+            } else if (options.sort) {
+                sort = `ORDER BY`;
+                for (let i = 0; i < options.sort.length; i++) {
+                    sort = sort + ` ${options.sort[i].field} ${options.sort[i].order}`;
+                    if (i < options.sort.length - 1) {
+                        sort = sort + ' , ';
+                    }
+                }
+            }
+        }
+        var query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} ;`;
+        return await this.run(query);
+    }
+
+    async getOne(modelname, filter) {
+        this.metrics.getOne(modelname, filter);
+        var where = '';
+        for (var key in filter) {
+            where = where + `${key} = '${filter[key]}' AND `;
+        }
+        where = where + " 1 ";
+        var query = `SELECT * FROM ${modelname} WHERE ${where} LIMIT 1;`;
+        var row = await this.run(query);
+        return row[0];
+    }
+
+    async create(modelname, sampleObject) {
+        this.sync.create(modelname, sampleObject);
+        this.metrics.create(modelname, sampleObject);
+
+        var cols = '';
+        for (var key in sampleObject) {
+            var type = this.dataMap[typeof (sampleObject[key])] || 'TEXT';
+            cols = cols + `${key} ${type},`;
+        }
+        cols = cols.substring(0, cols.length - 1);
+        var query = `CREATE TABLE IF NOT EXISTS ${modelname} (${cols});`;
+        try {
+            return await this.run(query);
+        } catch (err) {
+            if (this.loglevel > 0)
+                console.log(err);
+            throw err
+        }
+    }
+
+    async insert(modelname, object) {
+        this.sync.insert(modelname, object);
+        this.metrics.insert(modelname, object);
+        var cols = '';
+        var vals = '';
+        for (var key in object) {
+            cols = cols + `${key},`;
+            let val = object[key]
+            if (typeof val == 'object')
+                val = JSON.stringify(object[key])
+            if (typeof val == "undefined")
+                vals = vals + `Null,`;
+            else if (typeof val == 'boolean')
+                vals = vals + `${val},`;
+            else
+                vals = vals + `'${val}',`;
+        }
+        cols = cols.substring(0, cols.length - 1);
+        vals = vals.substring(0, vals.length - 1);
+
+        var query = `INSERT INTO ${modelname} (${cols}) VALUES(${vals});`;
+
+        try {
+            return await this.run(query);
+        } catch (err) {
+            if (err.code && err.code === 'ER_NO_SUCH_TABLE') {
+                await this.create(modelname, object);
+                return await this.run(query);
+            } else {
+                throw err;
+            }
+        }
+    }
+
+    async update(modelname, filter, object) {
+        this.sync.update(modelname, filter, object);
+        this.metrics.update(modelname, filter, object);
+
+        var where = '';
+        var vals = '';
+        for (var key in filter) {
+            where = where + `${key} = '${filter[key]}' AND `;
+        }
+        for (var key in object) {
+            vals = vals + ` ${key} = '${object[key]}',`;
+        }
+        where = where + " 1 ";
+        vals = vals.substring(0, vals.length - 1);
+
+        var query = `UPDATE ${modelname} SET ${vals} WHERE ${where};`;
+        return await this.run(query);
+    }
+
+    async delete(modelname, filter) {
+        this.sync.delete(modelname, filter);
+        this.metrics.delete(modelname, filter);
+
+        var where = '';
+        for (var key in filter) {
+            where = where + `${key} = '${filter[key]}' AND `;
+        }
+        where = where + " 1 ";
+        var query = `DELETE FROM ${modelname} WHERE ${where};`;
+        return await this.run(query);
+    }
+
+    closePool() {
+        return new Promise((res, rej) => {
+            this.pool.end((err) => {
+                if (err) {
+                    rej(err)
+                    if (this.loglevel > 1)
+                        console.error('Error closing connection pool:', err);
+                } else {
+                    res()
+                    if (this.loglevel > 1)
+                        console.log('MySQLDB: Connection pool closed');
+                }
+            });
+        })
+    }
+}
+
+module.exports = {
+    MySQLDB
+};

package/engines/oracledb.d.ts

@@ -0,0 +1,24 @@
+import { MultiDbORM, MultiDbORMOptions } from './MultiDbORM';
+
+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);
+
+    async connect(): Promise<void>;
+
+    async run(query: string): Promise<any>;
+}

package/engines/oracledb.js

@@ -28,17 +28,18 @@ class OracleDB extends MultiDbORM {
         net_service_name,
         wallet_dir,
         connection_pool_name,
-        wallet_password }) {
+        wallet_password,
+        lib_dir }) {
         super()
         const oracledb = require('oracledb')
         const oracleInstantClient = require("oracle-instantclient");
         if (!wallet_password)
             wallet_password = password
-        process.env.LD_LIBRARY_PATH = oracleInstantClient.path
+        process.env.LD_LIBRARY_PATH = lib_dir || oracleInstantClient.path
         process.env.TS_ADMIN = wallet_dir
         oracledb.initOracleClient({
             configDir: wallet_dir,
-            libDir: oracleInstantClient.path
+            libDir: lib_dir || oracleInstantClient.path
         })
         oracledb.autoCommit = true;
         oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT

package/engines/sqlitedb.d.ts

@@ -0,0 +1,11 @@
+import { MultiDbORM, MultiDbORMOptions } from './MultiDbORM';
+
+export declare class SQLiteDB extends MultiDbORM {
+    sqlite3: typeof import('sqlite3');
+    db: typeof import('sqlite3')
+
+    constructor(filepath?: string);
+
+    async run(query: string): Promise<any>;
+
+}

package/index.d.ts

@@ -0,0 +1,5 @@
+export { MultiDbORM } from './engines/multidb';
+export { SQLiteDB } from './engines/sqlitedb';
+export { MongoDB } from './engines/mongodb';
+export { FireStoreDB } from './engines/firestoredb';
+export { OracleDB } from './engines/oracledb';

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "multi-db-orm",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "CRUD , Backup , Restore and Migration library for multiple databases",
   "main": "index.js",
   "dependencies": {
-    "fs": "0.0.1-security",
-    "node-firestore-import-export": "^1.1.0"
+    "fs": "0.0.1-security"
   },
   "devDependencies": {
     "firebase-admin": "^9.3.0",
     "mongodb": "^3.6.3",
+    "mysql": "^2.18.1",
     "oracle-instantclient": "^1.0.1",
     "oracledb": "^6.1.0",
     "sqlite3": "^5.0.0"
@@ -45,4 +45,4 @@
     "url": "https://github.com/shiveshnavin/multi-db-orm/issues"
   },
   "homepage": "https://github.com/shiveshnavin/multi-db-orm#readme"
-}
+}

package/sync.d.ts

@@ -0,0 +1,6 @@
+export class Sync {
+    create(modelname: string, sampleObject: any): void;
+    insert(modelname: string, object: any): void;
+    update(modelname: string, filter: any, object: any): void;
+    delete(modelname: string, filter: any): void;
+}

package/test/test.js

@@ -1,10 +1,11 @@
 const { Game } = require("./models");
 const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, Sync, OracleDB } = require("../index");
-const path = require('path')
+const path = require('path');
+const { MySQLDB } = require("../engines/mysqldb");
 
 
 
-var testCount = 3
+var testCount = 0
 function checkTestsCompleted() {
     if (--testCount <= 0) {
         process.exit(0)
@@ -199,34 +200,59 @@ async function testOracleDb() {
     }
     oracledb.loglevel = 1
     await oracledb.connect()
-    var res = await oracledb.create('games', gm);
+    test(oracledb)
+}
+
+
+
+async function testMysqlDb() {
+    let creds = require('../creds/mysql.json')
+    var mysqldb = new MySQLDB(creds);
+    console.log(mysqldb.metrics.getStatus())
+    mysqldb.loglevel = 1
+    await mysqldb.connect()
+    test(mysqldb)
+}
+
+
+async function test(db) {
+    testCount++
+    var gm = new Game('IndVSPak', Date.now(), 'Dhoni', 67.33, 'paid')
+    gm.completed = true
+    gm.runs = ['a', 'b']
+    gm.extras = {
+        location: 'India',
+        raining: false,
+        match: 1
+    }
+    var res = await db.create('games', gm);
     gm.id = Date.now()
-    res = await oracledb.insert('games', gm);
+    res = await db.insert('games', gm);
     gm.id = Date.now()
 
-    res = await oracledb.insert('games', gm);
+    res = await db.insert('games', gm);
     gm.amount = 1
     gm.id = Date.now()
 
-    res = await oracledb.insert('games', gm);
-    res = await oracledb.get('games', { amount: 1 });
-    res = await oracledb.getOne('games', { amount: 1 });
-    res = await oracledb.update('games', { amount: 1 }, { userid: 'xxxx' });
-    res = await oracledb.getOne('games', { userid: 'xxxx' });
+    res = await db.insert('games', gm);
+    res = await db.get('games', { amount: 1 });
+    res = await db.getOne('games', { amount: 1 });
+    res = await db.update('games', { amount: 1 }, { userid: 'xxxx' });
+    res = await db.getOne('games', { userid: 'xxxx' });
 
-    res = await oracledb.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
+    res = await db.insert('games', new Game('IndVSPak1', Date.now(), 'Dhoni', 100, 'free'));
 
-    res = await oracledb.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
+    res = await db.insert('games', new Game('IndVSPak2', Date.now(), 'Dhoni', 200, 'free'));
 
-    res = await oracledb.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
+    res = await db.insert('games', new Game('IndVSPak3', Date.now(), 'Dhoni', 300, 'paid'));
 
-    res = await oracledb.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
+    res = await db.insert('games', new Game('IndVSPak4', Date.now(), 'Dhoni', 400, 'paid'));
 
-    res = await oracledb.get('games', undefined, { sort: [{ field: 'timeStamp', order: 'asc' }, { field: 'amount', order: 'asc' }], limit: 5, offset: 1 })
+    res = await db.get('games', undefined, { sort: [{ field: 'timeStamp', order: 'asc' }, { field: 'amount', order: 'asc' }], limit: 5, offset: 1 })
 
-    res = await oracledb.get('games', { type: 'paid' }, { sort: [{ field: 'amount', order: 'desc' }, { field: 'timeStamp', order: 'desc' }] })
+    res = await db.get('games', { type: 'paid' }, { sort: [{ field: 'amount', order: 'desc' }, { field: 'timeStamp', order: 'desc' }] })
 
-    res = await oracledb.get('games', { amount: 400 }, {
+    res = await db.get('games', { amount: 400 }, {
         apply: {
             field: 'timeStamp',
             sort: 'desc',
@@ -239,16 +265,16 @@ async function testOracleDb() {
         limit: 2, offset: 1
     })
 
-    res = await oracledb.delete('games', { id: 'IndVSPak1' });
-    res = await oracledb.getOne('games', { id: 'IndVSPak1' });
+    res = await db.delete('games', { id: 'IndVSPak1' });
+    res = await db.getOne('games', { id: 'IndVSPak1' });
 
     console.log('SQLite DB Tests Successfull')
-    console.log(oracledb.metrics.getStatus())
+    console.log(db.metrics.getStatus())
     checkTestsCompleted();
 }
 
-
 // testSqlite();
 // testFireStore();
 // testMongo();
-// testOracleDb()
+// testOracleDb()
+testMysqlDb()