multi-db-orm 1.3.0 → 1.3.1

package/engines/sqlitedb.js

@@ -1,173 +1,173 @@
-const { MultiDbORM } = require("./multidb");
-var fs = require('fs')
-
-class SQLiteDB extends MultiDbORM {
-
-    sqlite3
-    dataMap = {
-        "string": "TEXT",
-        "number": "REAL"
-    }
-    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"
+    }
+    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,10 +1,10 @@
-const { MultiDBSafe,FireStoreDB,MongoDB,SQLiteDB } = require("./databases");
-const { Sync } = require("./sync");
-
-module.exports = {
-    MultiDBSafe,
-    FireStoreDB,
-    MongoDB,
-    SQLiteDB,
-    Sync
+const { MultiDBSafe,FireStoreDB,MongoDB,SQLiteDB } = require("./databases");
+const { Sync } = require("./sync");
+
+module.exports = {
+    MultiDBSafe,
+    FireStoreDB,
+    MongoDB,
+    SQLiteDB,
+    Sync
 }

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,44 +1,44 @@
-{
-  "name": "multi-db-orm",
-  "version": "1.3.0",
-  "description": "CRUD , Backup , Restore and Migration library for multiple databases",
-  "main": "index.js",
-  "dependencies": {
-    "firebase-admin": "^9.3.0",
-    "fs": "0.0.1-security",
-    "mongodb": "^3.6.3",
-    "node-firestore-import-export": "^1.1.0",
-    "sqlite3": "^5.0.0"
-  },
-  "devDependencies": {},
-  "scripts": {
-    "test": "node test/test.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shiveshnavin/multi-db-orm.git"
-  },
-  "keywords": [
-    "database",
-    "backup",
-    "restore",
-    "db",
-    "backup",
-    "db",
-    "restore",
-    "mongodb",
-    "firestore",
-    "backup",
-    "mongodb",
-    "restore",
-    "mongodb",
-    "sql",
-    "mysql"
-  ],
-  "author": "Shivesh Navin",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/shiveshnavin/multi-db-orm/issues"
-  },
-  "homepage": "https://github.com/shiveshnavin/multi-db-orm#readme"
-}
+{
+  "name": "multi-db-orm",
+  "version": "1.3.1",
+  "description": "CRUD , Backup , Restore and Migration library for multiple databases",
+  "main": "index.js",
+  "dependencies": {
+    "firebase-admin": "^9.3.0",
+    "fs": "0.0.1-security",
+    "mongodb": "^3.6.3",
+    "node-firestore-import-export": "^1.1.0",
+    "sqlite3": "^5.0.0"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shiveshnavin/multi-db-orm.git"
+  },
+  "keywords": [
+    "database",
+    "backup",
+    "restore",
+    "db",
+    "backup",
+    "db",
+    "restore",
+    "mongodb",
+    "firestore",
+    "backup",
+    "mongodb",
+    "restore",
+    "mongodb",
+    "sql",
+    "mysql"
+  ],
+  "author": "Shivesh Navin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shiveshnavin/multi-db-orm/issues"
+  },
+  "homepage": "https://github.com/shiveshnavin/multi-db-orm#readme"
+}