multi-db-orm 1.3.2 → 2.0.2

package/.vscode/launch.json

@@ -4,6 +4,19 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "name": "Launch via NPM",
+            "request": "launch",
+            "runtimeArgs": [
+                "run-script",
+                "test"
+            ],
+            "runtimeExecutable": "npm",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
+        },
         {
             "type": "node",
             "request": "launch",

package/README.md

@@ -9,6 +9,7 @@ Supported databases:
 1. MongoDB
 2. Google Firestore
 3. SQlite3
+4. Oracle
 
 ### Install
 The package is available on npm
@@ -17,6 +18,15 @@ npm install multi-db-orm
 `
 
 ### Initialize
+Install the target optional database dependencies based on your usage
+```
+npm install --save mongodb
+npm install --save firebase-admin
+npm install --save sqlite3
+npm install --save oracledb oracle-instantclient
+```
+
+Configure the database
 ```
 const { MultiDbORM, FireStoreDB, MongoDB, SQLiteDB, Sync } = require("multi-db-orm");
 
@@ -32,6 +42,17 @@ var sqlitedb = new SQLiteDB("/path/to/mydatabase.db"); // if no path is passed ,
 // MongoDB
 var mongodb = new MongoDB("mongodb+srv://username:PassW0rd@host.server.net/my_db_name","my_db_name");
 
+// OracleDB
+// Download client credentials (Wallet) and extract to /path/to/your/extracted/wallet-dir
+// Oracle field names are case insensetive, Always name your fields in snake case
+var oracledb = new OracleDB({
+        username: 'your-username',
+        password: 'your-password',
+        wallet_dir: '/path/to/your/extracted/wallet-dir',
+        net_service_name: 'connstring-high', //get any one from tnsnames.ora
+        connection_pool_name:'your-conn-pool-name' //optional
+    });
+
 var db = firebasedb;
 ```
 

package/databases.js

@@ -2,11 +2,12 @@ const { MultiDbORM } = require("./engines/multidb");
 const { FireStoreDB } = require("./engines/firestoredb");
 const { MongoDB } = require("./engines/mongodb");
 const { SQLiteDB } = require("./engines/sqlitedb");
-
+const { OracleDB } = require('./engines/oracledb')
 
 module.exports = {
     MultiDbORM,
     FireStoreDB,
     MongoDB,
-    SQLiteDB
+    SQLiteDB,
+    OracleDB
 }

package/engines/multidb.js

@@ -1,4 +1,4 @@
-const {Sync} = require('../sync')
+const { Sync } = require('../sync')
 const { Metrics } = require('./metrics')
 class MultiDbORM {
 
@@ -16,6 +16,10 @@ class MultiDbORM {
         this.metrics = new Metrics(this.loglevel)
     }
 
+    async connect() {
+
+    }
+
     setdb(db) {
         this.reqMade = 0
         this.db = db;

package/engines/oracledb.js

@@ -0,0 +1,232 @@
+const path = require("path");
+const { MultiDbORM } = require("./multidb");
+var fs = require('fs')
+
+class OracleDB extends MultiDbORM {
+
+    connection_pool_name
+    schema
+    pool_creation
+    dataMap = {
+        "id": "VARCHAR(50) NOT NULL PRIMARY KEY",
+        "string": "VARCHAR2(4000)",
+        "number": "NUMBER",
+        "boolean": "VARCHAR(5)",
+        "array": "CLOB",
+        "object": "CLOB",
+    }
+
+
+    static async initOracleLibraries() {
+
+    }
+
+    constructor({
+        username,
+        password,
+        net_service_name,
+        wallet_dir,
+        connection_pool_name }) {
+        super()
+        const oracledb = require('oracledb')
+        const oracleInstantClient = require("oracle-instantclient");
+
+        process.env.LD_LIBRARY_PATH = oracleInstantClient.path
+        process.env.TS_ADMIN = wallet_dir
+        oracledb.initOracleClient()
+        oracledb.autoCommit = true;
+        oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT
+        oracledb.fetchAsString = [oracledb.CLOB];
+
+        this.connection_pool_name = connection_pool_name || username
+        this.db = oracledb
+        this.schema = username
+        this.pool_creation = oracledb.createPool({
+            user: username,
+            password: password,
+            configDir: wallet_dir,
+            connectString: net_service_name,
+            poolAlias: this.connection_pool_name
+        }).then(async (pool) => {
+            console.log(`OracleDB Initialized`);
+        }).catch(e => {
+            console.log("Error initializing oracle DB: " + e.message)
+            throw e
+        })
+
+        this.dbType = 'oracle'
+        this.reqMade = 0
+    }
+
+    async connect() {
+        await this.pool_creation
+    }
+
+    async run(query) {
+        let connection
+        var that = this
+        this.reqMade++
+        return new Promise(async function (resolve, reject) {
+            try {
+                connection = await that.db.getConnection(that.connection_pool_name);
+                let resp = await connection.execute(query)
+                resolve(resp);
+                if (that.loglevel > 3)
+                    console.log("Query ", query, ' -> ', resp)
+
+            } catch (err) {
+                reject(err)
+            } finally {
+                if (connection) {
+                    try {
+                        await connection.close();
+                    } catch (err) {
+                        throw (err);
+                    }
+                }
+            }
+        })
+
+
+    }
+
+    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 = 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} `
+        var row = await this.run(query)
+
+        return row.rows
+    }
+
+    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 = 1 ";
+        var query = `SELECT * FROM ${modelname} WHERE ${where} AND rownum < 2`
+        var row = await this.run(query)
+        return row.rows[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])] || 'VARCHAR(4000)'
+            if (Array.isArray(sampleObject[key])) {
+                type = this.dataMap['array']
+            }
+            if (key == 'id') {
+                type = this.dataMap['id']
+            }
+            cols = cols + `"${key}" ${type}, `
+        }
+        cols = cols.substring(0, cols.length - 2)
+        var query = `CREATE TABLE ${modelname} (${cols})`
+        try {
+            return await this.run(query)
+        } catch (err) {
+            if (!err.message.indexOf("name is already used")) {
+                console.log(err)
+            }
+            return undefined;
+        }
+    }
+
+    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 value = object[key]
+            if (typeof value == 'object')
+                value = JSON.stringify(value)
+            vals = vals + `'${value}',`
+        }
+        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.message && err.message.indexOf('SQLITE_ERROR: no such table: ') > -1) {
+                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 = 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 = 1";
+        var query = `DELETE FROM ${modelname} WHERE ${where}`
+        return await this.run(query)
+    }
+}
+
+
+
+module.exports = {
+    OracleDB
+}

package/index.js

@@ -1,4 +1,4 @@
-const { MultiDBSafe,FireStoreDB,MongoDB,SQLiteDB } = require("./databases");
+const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, OracleDB } = require("./databases");
 const { Sync } = require("./sync");
 
 module.exports = {
@@ -6,5 +6,6 @@ module.exports = {
     FireStoreDB,
     MongoDB,
     SQLiteDB,
+    OracleDB,
     Sync
 }

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "multi-db-orm",
-  "version": "1.3.2",
+  "version": "2.0.2",
   "description": "CRUD , Backup , Restore and Migration library for multiple databases",
   "main": "index.js",
   "dependencies": {
-    "firebase-admin": "^9.3.0",
     "fs": "0.0.1-security",
+    "node-firestore-import-export": "^1.1.0"
+  },
+  "devDependencies": {
+    "firebase-admin": "^9.3.0",
     "mongodb": "^3.6.3",
-    "node-firestore-import-export": "^1.1.0",
+    "oracle-instantclient": "^1.0.1",
+    "oracledb": "^6.1.0",
     "sqlite3": "^5.0.0"
   },
-  "devDependencies": {},
   "scripts": {
+    "postinstall": "node postinstall.js",
     "test": "node test/test.js"
   },
   "repository": {

package/postinstall.js

@@ -0,0 +1,9 @@
+console.log(`
+!!!!! MULTI DB ORM !!!
+!!!!! Make sure to install one of the target dependencies !!!!
+npm install --save mongodb
+npm install --save firebase-admin
+npm install --save sqlite3
+npm install --save oracledb oracle-instantclient
+!!!!! MULTI DB ORM !!!
+`)

package/test/test.js

@@ -1,5 +1,7 @@
 const { Game } = require("./models");
-const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, Sync } = require("../index");
+const { MultiDBSafe, FireStoreDB, MongoDB, SQLiteDB, Sync, OracleDB } = require("../index");
+const path = require('path')
+
 
 
 var testCount = 3
@@ -181,6 +183,70 @@ async function testMongo() {
 
 }
 
-testSqlite();
+
+async function testOracleDb() {
+    var oracledb = new OracleDB(require('../creds/oracle/creds.json'));
+    console.log(oracledb.metrics.getStatus())
+    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
+    }
+    oracledb.loglevel = 1
+    await oracledb.connect()
+    var res = await oracledb.create('games', gm);
+    gm.id = Date.now()
+    res = await oracledb.insert('games', gm);
+    gm.id = Date.now()
+
+    res = await oracledb.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 oracledb.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 oracledb.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 oracledb.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 oracledb.get('games', { amount: 400 }, {
+        apply: {
+            field: 'timeStamp',
+            sort: 'desc',
+            ineq: {
+                op: '>=',
+                value: 1
+            }
+        },
+        sort: [{ field: 'amount', order: 'asc' }, { field: 'timeStamp', order: 'desc' }],
+        limit: 2, offset: 1
+    })
+
+    res = await oracledb.delete('games', { id: 'IndVSPak1' });
+    res = await oracledb.getOne('games', { id: 'IndVSPak1' });
+
+    console.log('SQLite DB Tests Successfull')
+    console.log(oracledb.metrics.getStatus())
+    checkTestsCompleted();
+}
+
+
+// testSqlite();
 // testFireStore();
-// testMongo();
+// testMongo();
+// testOracleDb()