multi-db-orm 3.0.12 → 3.1.0

package/engines/sqlitedb.js

@@ -1,166 +1,166 @@
-const { MultiDbORM } = require("./multidb");
-var fs = require("fs");
-
-class SQLiteDB extends MultiDbORM {
-  sqlite3;
-  dataMap = {
-    string: "TEXT",
-    number: "REAL",
-    boolean: "BOOLEAN",
-  };
-  constructor(filepath) {
-    super();
-    var sqlite3 = require("sqlite3");
-    this.sqlite3 = sqlite3;
-    if (filepath == undefined) filepath = ":memory:";
-    else {
-      var currentPath = process.cwd();
-      if (!fs.existsSync(filepath)) {
-        filepath = currentPath + "/" + filepath;
-      }
-    }
-    this.db = new sqlite3.Database(filepath);
-    console.log("SQLite3 Initialized");
-    this.dbType = "sqlite3";
-    this.reqMade = 0;
-  }
-
-  async run(query) {
-    var db = this.db;
-    var that = this;
-    this.reqMade++;
-    return new Promise(function (resolve, reject) {
-      db.all(query, function (err, resp) {
-        if (err) reject(err);
-        else resolve(resp);
-        if (that.loglevel > 3) console.log("Query ", query, " -> ", resp);
-      });
-    });
-  }
-
-  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) {
-      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},`;
-      vals = vals + `'${object[key]}',`;
-    }
-    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 ";
-    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);
-  }
-}
-
-module.exports = {
-  SQLiteDB,
-};
+const { MultiDbORM } = require("./multidb");
+var fs = require("fs");
+
+class SQLiteDB extends MultiDbORM {
+  sqlite3;
+  dataMap = {
+    string: "TEXT",
+    number: "REAL",
+    boolean: "BOOLEAN",
+  };
+  constructor(filepath) {
+    super();
+    var sqlite3 = require("sqlite3");
+    this.sqlite3 = sqlite3;
+    if (filepath == undefined) filepath = ":memory:";
+    else {
+      var currentPath = process.cwd();
+      if (!fs.existsSync(filepath)) {
+        filepath = currentPath + "/" + filepath;
+      }
+    }
+    this.db = new sqlite3.Database(filepath);
+    console.log("SQLite3 Initialized");
+    this.dbType = "sqlite3";
+    this.reqMade = 0;
+  }
+
+  async run(query) {
+    var db = this.db;
+    var that = this;
+    this.reqMade++;
+    return new Promise(function (resolve, reject) {
+      db.all(query, function (err, resp) {
+        if (err) reject(err);
+        else resolve(resp);
+        if (that.loglevel > 3) console.log("Query ", query, " -> ", resp);
+      });
+    });
+  }
+
+  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) {
+      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},`;
+      vals = vals + `'${object[key]}',`;
+    }
+    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 ";
+    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);
+  }
+}
+
+module.exports = {
+  SQLiteDB,
+};

package/index.js

@@ -1,23 +1,23 @@
-const {
-  MultiDBSafe,
-  FireStoreDB,
-  MongoDB,
-  SQLiteDB,
-  OracleDB,
-  MySQLDB,
-  HanaDB,
-  BigQueryDB,
-} = require("./databases");
-const { Sync } = require("./sync");
-
-module.exports = {
-  MultiDBSafe,
-  FireStoreDB,
-  MongoDB,
-  SQLiteDB,
-  OracleDB,
-  MySQLDB,
-  HanaDB,
-  Sync,
-  BigQueryDB,
-};
+const {
+  MultiDBSafe,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  OracleDB,
+  MySQLDB,
+  HanaDB,
+  BigQueryDB,
+} = require("./databases");
+const { Sync } = require("./sync");
+
+module.exports = {
+  MultiDBSafe,
+  FireStoreDB,
+  MongoDB,
+  SQLiteDB,
+  OracleDB,
+  MySQLDB,
+  HanaDB,
+  Sync,
+  BigQueryDB,
+};

package/migrate.sh

@@ -1,12 +1,12 @@
-#!/bin/bash 
-SRCDB=$1
-TARDB=$2
-DEDUPDB=$3
-
-echo "Source DB $SRCDB" 
-echo "Target DB $TARDB" 
-echo "Dedup DB $DEDUPDB" 
-
-node backup.js $SRCDB dump.json 
-
+#!/bin/bash 
+SRCDB=$1
+TARDB=$2
+DEDUPDB=$3
+
+echo "Source DB $SRCDB" 
+echo "Target DB $TARDB" 
+echo "Dedup DB $DEDUPDB" 
+
+node backup.js $SRCDB dump.json 
+
 node restore.js dump.json $TARDB $DEDUPDB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-db-orm",
-  "version": "3.0.12",
+  "version": "3.1.0",
   "description": "CRUD , Backup , Restore and Migration library for multiple databases",
   "main": "index.js",
   "dependencies": {

package/postinstall.js

@@ -1,9 +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 !!!
+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/restore.js

@@ -1,102 +1,102 @@
-
-const mongoose = require('mongoose');
-var fs = require('fs');
-async function log(arg) {
-    update(arg)
-}
-
-var maxC = 0;
-var curC = 1;
-async function processCollection(collectionName) {
-
-    try {
- 
-        var collData = data[collectionName];
-        var coll = db.collection(collectionName);
-        collData.forEach((cd) => {
-            cd._id = mongoose.Types.ObjectId(cd._id)
-        })
-        await coll.insertMany(collData)
-        var count = await coll.countDocuments() 
-        log(collectionName, "   =   ", count);
-        if(removeDups)
-         dups(collectionName)
-
-    } catch (er) {
-        log(er.message)
-        log("error in " + collectionName);
-    }
-    log('Processed '+collectionName+"("+(curC+"/"+maxC)+")");
-    if (curC++ < maxC) {
-        curC;   
-    }
-    else {
-        log("\n\nAll Data restore completed !!");
-        finish('Restore Complete !')
-    }
-
-};
-
-async function dups(collectionName) {
-    var coll = db.collection(collectionName);
-    await coll.aggregate(
-        { "$group": { "_id": "$name", "count": { "$sum": 1 } } },
-        { "$match": { "_id": { "$ne": null }, "count": { "$gt": 1 } } },
-        { "$project": { "name": "$_id", "_id": 0 } }
-    )
-        .toArray((err, results) => {
-            if (err) throw err;
-            log("===", results);
-
-        })
-}
-
-var dumpFile = process.argv[2];
-var targetDb = process.argv[3];
-var deDupDo = process.argv[4]; 
-var db;
-var data;
-var update=(msg)=>{
-    console.log(msg)
-}
-var finish=(msg)=>{
-    log(msg)
-    process.exit()
-}
-var removeDups=false;
-if (dumpFile && targetDb) {
-    data = JSON.parse(fs.readFileSync(dumpFile)); 
-    mongoose.Promise = global.Promise;
-
-    mongoose.connect(targetDb, {
-        useUnifiedTopology: true,
-        useNewUrlParser: true,
-        }).then(() => {
-        log("Successfully connected to the database");
-        readCollectionsFromDump(mongoose.connection.db,JSON.parse(fs.readFileSync(dumpFile)),deDupDo);
-    }).catch(err => {
-        log('Could not connect to the database. Exiting now...', err);
-        process.exit();
-    });
-}
-async function readCollectionsFromDump(connectedDB, dumpData,deDup) {
-
-
-    if(deDup==1){
-        removeDups=true;
-        log("Removing duplicates as well")
-    }
-    db = connectedDB;
-    data = (dumpData);
-
-    var v = Object.keys(dumpData)
-    log('Found '+v.length+' Collections to restore');
-   // log(v);
-    maxC = v.length; 
-    console.log(v.length) 
-    v.forEach(async function(coll){
-        await processCollection(coll)
-    });
-    
-
-}
+
+const mongoose = require('mongoose');
+var fs = require('fs');
+async function log(arg) {
+    update(arg)
+}
+
+var maxC = 0;
+var curC = 1;
+async function processCollection(collectionName) {
+
+    try {
+ 
+        var collData = data[collectionName];
+        var coll = db.collection(collectionName);
+        collData.forEach((cd) => {
+            cd._id = mongoose.Types.ObjectId(cd._id)
+        })
+        await coll.insertMany(collData)
+        var count = await coll.countDocuments() 
+        log(collectionName, "   =   ", count);
+        if(removeDups)
+         dups(collectionName)
+
+    } catch (er) {
+        log(er.message)
+        log("error in " + collectionName);
+    }
+    log('Processed '+collectionName+"("+(curC+"/"+maxC)+")");
+    if (curC++ < maxC) {
+        curC;   
+    }
+    else {
+        log("\n\nAll Data restore completed !!");
+        finish('Restore Complete !')
+    }
+
+};
+
+async function dups(collectionName) {
+    var coll = db.collection(collectionName);
+    await coll.aggregate(
+        { "$group": { "_id": "$name", "count": { "$sum": 1 } } },
+        { "$match": { "_id": { "$ne": null }, "count": { "$gt": 1 } } },
+        { "$project": { "name": "$_id", "_id": 0 } }
+    )
+        .toArray((err, results) => {
+            if (err) throw err;
+            log("===", results);
+
+        })
+}
+
+var dumpFile = process.argv[2];
+var targetDb = process.argv[3];
+var deDupDo = process.argv[4]; 
+var db;
+var data;
+var update=(msg)=>{
+    console.log(msg)
+}
+var finish=(msg)=>{
+    log(msg)
+    process.exit()
+}
+var removeDups=false;
+if (dumpFile && targetDb) {
+    data = JSON.parse(fs.readFileSync(dumpFile)); 
+    mongoose.Promise = global.Promise;
+
+    mongoose.connect(targetDb, {
+        useUnifiedTopology: true,
+        useNewUrlParser: true,
+        }).then(() => {
+        log("Successfully connected to the database");
+        readCollectionsFromDump(mongoose.connection.db,JSON.parse(fs.readFileSync(dumpFile)),deDupDo);
+    }).catch(err => {
+        log('Could not connect to the database. Exiting now...', err);
+        process.exit();
+    });
+}
+async function readCollectionsFromDump(connectedDB, dumpData,deDup) {
+
+
+    if(deDup==1){
+        removeDups=true;
+        log("Removing duplicates as well")
+    }
+    db = connectedDB;
+    data = (dumpData);
+
+    var v = Object.keys(dumpData)
+    log('Found '+v.length+' Collections to restore');
+   // log(v);
+    maxC = v.length; 
+    console.log(v.length) 
+    v.forEach(async function(coll){
+        await processCollection(coll)
+    });
+    
+
+}

package/sync.d.ts

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