molly-db 1.0.4 → 1.0.5

package/main.js

@@ -1,7 +1,47 @@
-const output = new Object();
+const worker = require('worker_threads');
+const fetch = require('axios');
+const url = require('url');
+const fs = require('fs');
 
-try{ output.streamDB = require('./module/streamDB'); } catch(e) { /*console.log(e)*/ }
-try{ output.localDB = require('./module/localDB'); } catch(e) { /*console.log(e)*/ }
-try{ output.webDB = require('./module/webDB'); } catch(e) { /*console.log(e)*/ }
+/* --------------------------------------------------------------------------------------- */
 
-module.exports = output;
+function config( _config ) {
+    const _default = { offset:0, length:100 };
+    if( !_config ) return _default;
+    Object.keys(_config).map(x=>{
+        _default[x] = _config[x];
+    });
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+class molly_db{
+
+    constructor( opt ){
+        return new Promise((response,reject)=>{
+            if( opt.pass )
+                this.pass = opt.pass;
+                this.port = opt.port || 27017;
+                this.type = opt.type || 'local';
+                this.path = opt.path.replace(/^\./,process.cwd());
+            
+            if( this.worker ) return console.log(`server is running`);
+
+            this.worker = new worker.Worker(
+                   `${__dirname}/module/_worker_`,{
+                    env: worker.SHARE_ENV,
+                    workerData: this
+                }
+            );
+
+            this.worker.on('exit',(err)=>{ });
+            this.worker.on('error',(err)=>{ });
+            this.worker.on('message',(msg)=>{ console.log(msg); response(); });
+        });
+    }
+
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+module.exports = molly_db;

package/module/_crypto_.js

@@ -0,0 +1,65 @@
+
+const crypto = require('crypto-js');
+const output = new Object();
+
+/* -------------------------------------------------------------------------------------------------------- */
+
+const JsonFormatter = {
+
+	'stringify': function(cipherParams) {
+    	var jsonObj = { ct: cipherParams.ciphertext.toString(crypto.enc.Base64) };
+    	if (cipherParams.salt) jsonObj.s = cipherParams.salt.toString();
+	    if (cipherParams.iv) jsonObj.iv = cipherParams.iv.toString(); 
+	    return new Buffer.from(JSON.stringify(jsonObj)).toString('base64');
+  	},
+
+  	'parse': function(jsonStr) {
+    	var jsonObj = JSON.parse( new Buffer.from(jsonStr,'base64').toString());
+    	var cipherParams = crypto.lib.CipherParams.create({
+     	 	ciphertext: crypto.enc.Base64.parse(jsonObj.ct)
+    	});
+    	if (jsonObj.iv) cipherParams.iv = crypto.enc.Hex.parse(jsonObj.iv);
+    	if (jsonObj.s) cipherParams.salt = crypto.enc.Hex.parse(jsonObj.s);
+    	return cipherParams;
+ 	}
+
+};
+
+/* --------------------------------------------------------------------------------------- */
+
+output.slugify = (str)=>{ 
+	const map = {
+		'c' : 'ç',
+		'n' : 'ñ',
+		'e' : 'é|è|ê|ë',
+		'i' : 'í|ì|î|ï',
+		'u' : 'ú|ù|û|ü',
+		'o' : 'ó|ò|ô|õ|ö',
+		'a' : 'á|à|ã|â|ä',
+		''  : /\s+|\W+/,
+	};	
+	for (var pattern in map) { 
+		str=str.replace( new RegExp(map[pattern],'gi' ), pattern); 
+	}	return str.toLowerCase();
+}
+
+output.encrypt = ( _message,_password )=>{ 
+    try{if( _password )
+        return crypto.AES.encrypt( _message,_password,{
+            format: JsonFormatter
+        }).toString(); return _message;
+    } catch(e) { return _message; }
+}
+
+output.decrypt = ( _message,_password )=>{ 
+    try{if( _password )
+        return crypto.AES.decrypt( _message,_password,{
+                format: JsonFormatter
+            }).toString( crypto.enc.Utf8 );
+        return _message;
+    } catch(e) { return _message; }
+}
+
+/* -------------------------------------------------------------------------------------------------------- */
+
+module.exports = output;

package/module/_init_.js

@@ -0,0 +1,68 @@
+
+function fillDB( _db, _table, _path ){
+    return new Promise(async(response,reject)=>{
+
+        let _itr = undefined;
+
+        if( (/^http/).test(_path) ){
+            const stream = await fetch.get(_path,{responseType:'stream'});
+            _itr = readline.createInterface({
+                input: stream.data
+            });
+        
+        } else    
+            _itr = readline.createInterface({
+                input: fs.createReadStream(_path)
+            });
+
+        _itr.on('close',()=>{ response() });
+        _itr.on('line',(line)=>{
+            db[_db][_table].push(crypto.decrypt( line,query.pass ));
+        });
+        
+    });
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+(async()=>{
+    try {
+
+        const path = `${query.path}/_init_.json`;
+
+        if( (/^http/).test(query.path) ){
+            const stream = await fetch.get(path);
+            db._init_ = stream.data;
+        } else{ 
+            db._buff_ = fs.readFileSync( path );
+            db._init_ = JSON.parse( db._buff_ );
+        }
+
+        db._path_ = query.path;
+        for( var i in db._init_.DB ){
+
+            const DB = db._init_.DB[i];
+            const name = DB.name;
+    
+            db[name] = new Object();
+    
+            for( var j in DB.tables ){
+                const table = DB.tables[j];
+                const path = `${db._path_}/${table}.json`;
+                db[name][table] = new Array();
+                await fillDB( name,table,path );
+            }
+    
+        }
+
+    } catch(e) {
+
+        const path = `${query.path}/_init_.json`;
+        db._buff_ = fs.readFileSync( path );
+        db._path_ = query.path;
+        db._init_ = { DB:[] }
+
+        fs.writeFileSync( path,db._init_ );
+
+    }   response();
+})();

package/module/_server_.js

@@ -0,0 +1,281 @@
+
+function text( _data ){
+    res.writeHead(200,{'contetn-type':'text/plain'});
+    res.end( _data );
+}
+
+function error( _error ){
+    res.writeHead(200,{'contetn-type':'text/plain'});
+    res.end(`error: ${_error.message}`);
+    console.log(_error);
+}
+
+function json( _data ){
+    res.writeHead(200,{'content-type':'application/json'});
+    res.end(JSON.stringify(_data));
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function getBody(){
+    return new Promise((response,reject)=>{
+        if( req.method == 'POST' ){
+            const data = new Array();
+            req.on('data',(chunk)=>{ data.push(chunk); });
+            req.on('close',()=>{ response( Buffer.concat(data).toString() ); });
+        } else { reject() }
+    });
+} 
+
+function encryptDB( _db,_table, _path ){
+    return new Promise((response,reject)=>{
+        const writable = fs.createWriteStream( _path+'_tmp' );
+        for( var i in db[_db][_table] ){
+    
+            const data = db[_db][_table][i];
+            const ecrp = crypto.encrypt( data,query.pass );
+    
+            writable.write(`${ecrp}\n`);
+        }   writable.end();
+    
+        writable.on('close',()=>{ 
+            fs.renameSync( _path+'_tmp', _path ); 
+            response('done');
+        });
+    
+        writable.on('error',(e)=>{ 
+            reject(e);
+        });
+    });
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function list( _params ){
+    return db[_params.db][_params.table].slice(
+        _params.offset, Number(_params.offset)+Number(_params.length)
+    ).map(x=>JSON.parse(x));
+}
+
+function match( _params ){
+    const result = new Array();
+    db[_params.db][_params.table].map((x)=>{
+        const regex = new RegExp(crypto.slugify(_params.target),'gi');
+        const target = crypto.slugify(x);
+        if( regex.test(target) ) result.push(x);
+    }).slice(
+        _params.offset, Number(_params.offset)+Number(_params.length)
+    );  return result.map(x=>JSON.parse(x));
+}
+
+function hash( _params ){
+    const result = new Array();
+    db[_params.db][_params.table].map((x)=>{
+        const regex = new RegExp(_params.target,'gi');
+        if( regex.test(x) ) result.push(x);
+    }).slice(
+        _params.offset, Number(_params.offset)+Number(_params.length)
+    );  return result.map(x=>JSON.parse(x));
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function shift( _params ){ 
+    const result = db[_params.db][_params.table].shift(); 
+    modifyDB( _params.db,_params.table ); return result;
+}
+
+function pop( _params ){ 
+    const result = db[_params.db][_params.table].pop(); 
+    modifyDB( _params.db,_params.table ); return result; return result; 
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function push( _params ){
+
+    const body = await getBody();
+    db[_params.db][_params.table].push( body );
+
+    modifyDB( _params.db,_params.table );
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'pushed'
+    };
+
+}
+
+async function splice( _params ){
+
+    const body = await getBody();
+    db[_params.db][_params.table].splice(
+        _params.offset,_params.length,body
+    );
+
+    modifyDB( _params.db,_params.table );
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'spliced'
+    };
+}
+
+async function unshift( _params ){
+
+    const body = await getBody();
+    db[_params.db][_params.table].unshift( body );
+
+    modifyDB( _params.db,_params.table );
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'unshifted'
+    };
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function addDB( _params ){
+
+    const init = `${query.path}/_init_.json`;
+
+    db._init_.DB.push({
+        name: _params.db,
+        tables: []
+    });
+
+    db[_params.db] = new Array(); 
+    fs.writeFileSync( init,JSON.stringify(db._init_) );
+
+    return {
+        database: _params.db,
+        status: 'DB added'
+    };
+
+}
+
+function removeDB( _params ){
+
+    const init = `${query.path}/_init_.json`;
+    const i = db._init_.DB.findIndex(x=>{
+        return x.name == _params.db
+    }); 
+
+    db._init_.DB[i].tables.forEach(x=>{
+        const path = `${query.path}/${x}.json`;
+        fs.unlinkSync(path);
+    }); db._init_.DB.splice(i,1);
+
+    db[_params.db] = new Array();
+    fs.writeFileSync( init,JSON.stringify(db._init_) );
+
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'DB deleted'
+    };
+    
+}
+
+function modifyDB( _name, _table ){
+
+    const init = `${query.path}/_init_.json`;
+    const path = `${query.path}/${_table}.json`;
+
+    fs.writeFileSync( init,JSON.stringify(db._init_) );
+
+    try {
+        const length = db[_name][_table].length;
+        if( length>0 ) encryptDB( _name, _table, path );
+        else fs.writeFileSync( path,'' );
+    } catch(e) { 
+        fs.unlinkSync( path ); 
+    }  
+
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function addTable( _params ){
+
+    if( db[_params.db][_params.table] )
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'table exist'
+    };
+
+    const i = db._init_.DB.findIndex(x=>{
+        return x.name == _params.db;
+    }); db._init_.DB[i].tables.push(_params.table);
+
+    db[_params.db][_params.table] = new Array();
+    modifyDB( _params.db,_params.table );
+    
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'table added'
+    };
+
+}
+
+function removeTable( _params ){
+
+    const i = db._init_.DB.findIndex(x=>{
+        return x.name == _params.db;
+    }); 
+    
+    const j = db._init_.DB[i].tables.findIndex(x=>{
+        return x == _params.table;
+    });
+
+    db._init_.DB[i].tables.splice(j,1);
+    delete db[_params.db][_params.table];
+    modifyDB( _params.db,_params.table );
+
+    return {
+        database: _params.db,
+        table: _params.table,
+        status: 'table removed'
+    };
+
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+(async()=>{
+    try{
+
+        const api = url.parse( req.url,true );
+        const params = api.query;
+
+        /* Find Api */
+        if( api.pathname == '/list' ) json( await list(params) )
+        else if( api.pathname == '/hash' ) json( await hash(params) )
+        else if( api.pathname == '/match' ) json( await match(params) )
+
+        /* Remove Api */
+        else if( api.pathname == '/pop' ) json( await pop(params) )
+        else if( api.pathname == '/shift' ) json( await shift(params) )
+
+        /* Modify Api */
+        else if( api.pathname == '/push' ) json( await push(params) )
+        else if( api.pathname == '/splice' ) json( await splice(params) )
+        else if( api.pathname == '/unshift' ) json( await unshift(params) )
+
+        /* Modify Table Api */
+        else if( api.pathname == '/addDB' ) json( await addDB(params) )
+        else if( api.pathname == '/removeDB' ) json( await removeDB(params) )
+
+        /* Modify Table Api */
+        else if( api.pathname == '/addTable' ) json( await addTable(params) )
+        else if( api.pathname == '/removeTable' ) json( await removeTable(params) )
+
+        else error('Oops something went wrong');
+
+    } catch(e) { error(e); }
+})();
+
+/* --------------------------------------------------------------------------------------- */

package/module/_worker_.js

@@ -0,0 +1,42 @@
+const worker = require('worker_threads');
+const readline = require('readline');
+const crypto = require('./_crypto_');
+const {Buffer} = require('buffer'); 
+const fetch = require('axios');
+const http = require('http');
+const url = require('url');
+const fs = require('fs');
+
+const query = worker.workerData;
+const db = new Object();
+
+/* --------------------------------------------------------------------------------------- */
+
+function app(req,res){
+    eval( fs.readFileSync(`${__dirname}/_server_.js`).toString() );
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function _init_(){
+    return new Promise((response,reject)=>{
+        eval( fs.readFileSync(`${__dirname}/_init_.js`).toString() );
+    });
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+(()=>{
+    try{
+        console.log('molly-db is running, please wait');
+        http.createServer( app ).listen( query.port,()=>{
+            _init_().then(()=>{
+                worker.parentPort.postMessage(
+                    `server started -> http://localhost:${query.port}`
+                );
+            }).catch(e=>{ process.exit(1); });
+        });
+    } catch(e) { process.exit(1); }
+})();
+
+/* --------------------------------------------------------------------------------------- */

package/package.json

@@ -1,12 +1,29 @@
 {
   "license": "MIT",
   "main": "main.js",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "name": "molly-db",
   "author": "bececrazy",
-  "scripts": { "start": "node main" },
+  "scripts": {
+    "start": "node main"
+  },
   "repository": "https://github.com/EDBC-REPO-NPM/Molly-db",
-  "dependencies": { "axios": "^0.27.2", "crypto-js": "^4.1.1", "fs": "^0.0.1-security" },
+  "dependencies": {
+    "axios": "^0.27.2",
+    "crypto-js": "^4.1.1",
+    "fs": "^0.0.1-security"
+  },
   "description": "Molly-db is a free and open source library for nodejs that allow you create a lightweight encrypted database using Json files",
-  "keywords": [ "json", "storage", "database", "datastorage", "web-database", "json-database", "encrypted-data", "web-local-storage", "encrypted-database", "web-encrypted-database" ]
+  "keywords": [
+    "json",
+    "storage",
+    "database",
+    "datastorage",
+    "web-database",
+    "json-database",
+    "encrypted-data",
+    "web-local-storage",
+    "encrypted-database",
+    "web-encrypted-database"
+  ]
 }