molly-db 1.0.3 → 1.0.6

package/main.js

@@ -1,6 +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)*/ }
+/* --------------------------------------------------------------------------------------- */
 
-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,283 @@
+
+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);
+    });
+    return result.map(x=>JSON.parse(x)).slice(
+        _params.offset, Number(_params.offset)+Number(_params.length)
+    );
+}
+
+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);
+    });
+    return result.map(x=>JSON.parse(x)).slice(
+        _params.offset, Number(_params.offset)+Number(_params.length)
+    );
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+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{
+        http.createServer( app ).listen( query.port,()=>{
+            console.log('molly-db is running, please wait');
+            _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.3",
+  "version": "1.0.6",
   "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"
+  ]
 }

package/module/localDB.js

@@ -1,241 +0,0 @@
-const readline = require('./readline');
-const fs = require('fs');
-
-//TODO: Optimization FUnctions -------------------------------------------------------------------//
-
-const _default = { offset: 0, length: 100 };
-const init = function( _table,_config,_self ){
-	return {
-		_tbl: createNewTable( `${_self.path}/${_table}.json` ),
-		_tmp: `${_self.path}/${_table}_tmp.json`,
-		_path: `${_self.path}/${_table}.json`,
-		_cfg: config(_config),
-	}
-};
-
-const createNewTable = function( _path ){
-	if( !fs.existsSync( _path ) ) fs.writeFileSync( _path,"" );
-	const table = fs.createReadStream( _path );
-	return table; 
-}
-
-const createNewHash = function( _object ){
-	_object['_stamp'] = Date.now();
-	const _base = JSON.stringify( _object );
-	if( !_object.hash )
-		_object.hash = crypto.SHA256( _base ).toString();
-	return _object;
-}
-
-function config(_config){
-    Object.keys(_config).map((x)=>{
-        _default[x] = _config[x];
-    }); return _default;
-}
-
-//TODO: localDB Class ----------------------------------------------------------------------------//
-
-class localDB {
-
-	default = { offset: 0, length: 100 }
-
-	constructor( _object ){
-		if( _object.pass ){
-			this.password = _object.pass;
-		} 	this.path = _object.path;
-	}
-
-	// TODO: Searching functions --------------------------------------------------- //
-	list( _table, _config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = init( _table,_config,this );
-			let data = await readline.list( this,_tbl,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	find( _table, _target, _config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = init( _table,_config,this );
-			let data = await readline.find( this,_tbl,_target,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	match( _table,_match,_config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = init( _table,_config,this );
-			let data = await readline.match( this,_tbl,_match );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	hash( _table, _hash ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = init( _table,null,this );
-			let data = await readline.hash( this,_tbl,_hash,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	// TODO: Saving functions ------------------------------------------------- //
-	push( _table, ..._object ){
-		return new Promise( (response,reject)=>{ try{
-			
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-
-			_itr.on( 'line',( line )=>{ writable.write(`${line}\n`); });
-
-			_itr.on( 'close',()=>{
-				_object.flat().forEach( item=>{
-					item = createNewHash( item );
-					const encryptedData = this.encrypt( JSON.stringify( item ) );
-					writable.write( `${encryptedData}\n` );
-				}); writable.end();
-			});
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e); }
-	}); }
-
-	unshift( _table, ..._object ){
-		return new Promise( (response,reject)=>{ try{
-			
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-			
-			_itr.on( 'line',( line )=>{ 
-				if( _i == 0 ){
-					_object.flat().forEach( item=>{
-						item = createNewHash( item );
-						const encryptedData = this.encrypt( JSON.stringify( item ) );
-						writable.write( `${encryptedData}\n` );
-					});
-				} 	writable.write( `${line}\n` ); 
-			_i++;});
-			
-			_itr.on( 'close',()=>{ writable.end(); });
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e) }
-	}); }
-
-	place( _table, _line, ..._object ){
-		return new Promise( (response,reject)=>{ try{
-
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-			
-			_itr.on( 'line',( line )=>{ 
-				if( _i == _line ){
-					_object.flat().forEach( item=>{
-						item = createNewHash( item );
-						const encryptedData = this.encrypt( JSON.stringify( item ) );
-						writable.write( `${encryptedData}\n` );
-					});
-				} 	writable.write( `${line}\n` ); 
-			_i++;});
-			
-			_itr.on( 'close',()=>{ writable.end(); });
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e) }
-	}); }
-
-	update( _table, _hash, ..._object ){
-		return new Promise( (response,reject)=>{ try{
-
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-
-			_itr.on( 'line',( encryptedLine )=>{ try{
-				const line = this.decrypt( encryptedLine );
-				const data = JSON.parse( line );
-				if( data.hash == _hash ){
-					_object.flat().forEach( item=>{
-					item = createNewHash( item );
-						const encryptedData = this.encrypt( JSON.stringify( item ) );
-						writable.write( `${encryptedData}\n` );
-					});
-				} else
-					writable.write( `${encryptedLine}\n` ); 
-			} catch(e) { reject(`the db can be decripted: ${e}`) }
-			});
-			
-			_itr.on( 'close',()=>{ writable.end(); });
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e) }
-	}); }
-
-	// TODO: Removing functions //
-	remove( _table, _hash ){
-		return new Promise( (response,reject)=>{ try{
-
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-			
-			_itr.on( 'line',( encryptedLine )=>{
-				const line = this.decrypt( encryptedLine );
-				const data = JSON.parse( line );
-				if( data.hash != _hash ) 
-					writable.write( `${encryptedLine}\n` ); 
-			});
-			
-			_itr.on( 'close',()=>{ writable.end(); });
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e) }
-	}); }
-
-	removeTable( _table ){
-		return new Promise( (response,reject)=>{
-			const _path = `${this.path}/${_table}`;
-			fs.unlink( _path,( err,data )=>{
-				if(err) reject( err );
-				res({ table: _table });
-			});
-		})
-	}
-
-	shift( _table ){
-		return new Promise( (response,reject)=>{ try{
-
-			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
-			const writable = fs.createWriteStream( _tmp );
-
-			_itr.on( 'line',( line )=>{ if( _i != 0 ) writable.write( `${line}\n` ); _i++;});
-
-			_itr.on( 'close',()=>{ writable.end(); });
-
-			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res({
-				table: _table,
-			}); });
-
-		} catch(e) { reject(e) }
-	}); }
-
-}
-
-//TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = localDB;

package/module/readline.js

@@ -1,208 +0,0 @@
-const crypto = require('crypto-js');
-const {Buffer} = require('buffer'); 
-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;
- 	}
-
-};
-
-/* -------------------------------------------------------------------------------------------------------- */
-
-function 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();
-}
-
-function encrypt( _message,_password ){ 
-    try{if( _password )
-        return crypto.AES.encrypt( _message,_password,{
-            format: JsonFormatter
-        }).toString(); return _message;
-    } catch(e) { return _message; }
-}
-
-function decrypt( _message,_password ){ 
-    try{if( _password )
-        return crypto.AES.decrypt( _message,_password,{
-                format: JsonFormatter
-            }).toString( crypto.enc.Utf8 );
-        return _message;
-    } catch(e) { return _message; }
-}
-
-function processData( _chunk ){
-    for( var i=_chunk.length; i--; ){
-        if( _chunk[i]==10 || _chunk[i]==13 )
-            return [
-                _chunk.slice(0,i),
-                _chunk.slice(i),
-            ];
-    } return [ null, _chunk ];
-}
-
-/* -------------------------------------------------------------------------------------------------------- */
-
-function dbDecrypt( _list,_self ){ return _list.map((x)=>{ return decrypt(x,_self?.password) }); }
-
-function dbEncrypt( _list,_self ){ return _list.map((x)=>{ return encrypt(x,_self?.password) }); }
-
-/* -------------------------------------------------------------------------------------------------------- */
-
-output.readLine = ( _self,_stream,_config,_data )=>{
-    return new Promise((response,reject)=>{
-        
-        let offset = 0;
-        const db = new Array();
-        let prcd = new Array();
-        let data = new Buffer(0);
-    
-        _stream.on('data',async(chunk)=>{
-            
-            data = Buffer.concat([ data,chunk ]);
-            prcd = processData( data );
-            data = prcd[1];
-    
-            if( prcd[0] ){
-
-                const encrypted = prcd[0].toString().split('\n');
-                const decrypted = dbDecrypt(encrypted,_self);
-
-                const done = await _data( db,decrypted,_config );
-                offset += done.length; 
-        
-                if( db.length >= _config.length ) 
-                    _stream.destroy(); 
-                else if ( offset > _config.offset && db.length != 0 )
-                    db.push( ...done );
-                else if ( offset > _config.offset && db.length == 0 )
-                    db.push( ...done.slice( offset - done.length - _config.offset - 1 ) );
-                
-            }
-    
-        });
-    
-        _stream.on('close',async()=>{ response( db.slice( 0,_config.length ) ); });
-
-    });
-}
-
-output.list = ( _self,_stream,_config )=>{
-   
-    const onData = ( db,data,_config )=>{ 
-        return new Promise((response,reject)=>{
-            try{ 
-                const index = data.findIndex((x)=>x=='');
-                data.splice( index,1 );
-            } catch(e) {} response(data);
-        });
-    }
-
-    return new Promise((response,reject)=>{
-        response( output.readLine( _self,_stream,_config,onData ));
-    });
-
-}
-
-output.match = ( _self,_stream,_target,_config )=>{
-
-    const onData = ( db,data,_config )=>{
-        return new Promise((response,reject)=>{
-            const done = new Array();
-            data.map(x=>{ 
-                try{
-                    if( (new RegExp(slugify(_target),'gi')).test(slugify(x)) )
-                    done.push(x);
-                } catch(e) {} }); 
-            response(done);
-        });
-    }
-
-    return new Promise((response,reject)=>{
-        response(output.readLine( _self,_stream,_config,onData ));
-    });
-    
-}
-
-output.find = ( _self,_stream,_target,_config )=>{
-
-    const onData = ( db,data,_config )=>{
-        return new Promise((response,reject)=>{
-            const done = new Array();
-            data.map(x=>{ 
-                try{
-                    const data = JSON.parse(x);
-                    const cond = Object.keys(_target)
-                    .every(y=>{
-                        return (_target[y]).test(data[y]); 
-                    }); if( cond ) done.push(x);
-                } catch(e) {}
-            }); response(done);
-        });
-    }
-
-    return new Promise((response,reject)=>{
-        response(output.readLine( _self,_stream,_config,onData ));
-    });
-    
-}
-
-output.hash = ( _self,_stream,_target )=>{
-
-    const onData = ( db,data,_config )=>{
-        return new Promise((response,reject)=>{
-            data.some((x)=>{ 
-                try{
-                    const y = JSON.parse(x);
-                    if( y.hash == _target )
-                        response([x]);
-                } catch(e) {} 
-            });
-        });
-    }
-
-    const _config = { offset:0, length:1 };
-    return new Promise((response,reject)=>{
-        response(output.readLine( _self,_stream,_config,onData ));
-    });
-    
-}
-
-output.stream = ( _self,_stream,_config,_onData )=>{
-    return new Promise((response,reject)=>{
-        response(output.readLine( _self,_stream,_config,_onData ));
-    });
-}
-
-/* -------------------------------------------------------------------------------------------------------- */
-
-module.exports = output;

package/module/streamDB.js

@@ -1,80 +0,0 @@
-const readline = require('./readline');
-const fetch = require('axios');
-const fs = require('fs');
-
-//TODO: Optimization FUnctions -------------------------------------------------------------------//
-
-const _default = { offset: 0, length: 100 };
-
-const init = function( _table,_config,_self ){
-	return new Promise( (response,reject)=>{
-		const path = `${_self.path}/${_table}.json`;
-		fetch.get(path,{responseType:'stream'}).then(({data})=>{
-			response({
-				_cfg: config(_config),
-				_path: null,
-				_tmp: null,
-				_tbl: data,
-			});
-		});
-	});
-};
-
-function config(_config){
-	if( !_config ) return _default;
-    Object.keys(_config).map((x)=>{
-        _default[x] = _config[x];
-    }); return _default;
-}
-
-//TODO: localDB Class ----------------------------------------------------------------------------//
-
-class streamDB{
-
-	constructor( _object ){
-		if( _object.pass ){
-			this.password = _object.pass;
-		} 	this.path = _object.path;
-	}
-	
-	// TODO: Searching functions --------------------------------------------------- //
-	list( _table, _config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = await init( _table,_config,this );
-			let data = await readline.list( this,_tbl,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	find( _table, _target, _config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = await init( _table,_config,this );
-			let data = await readline.find( this,_tbl,_target,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	match( _table,_match,_config ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = await init( _table,_config,this );
-			let data = await readline.match( this,_tbl,_match,_cfg );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-	hash( _table, _hash ){
-		return new Promise( async(response,reject)=>{ try{
-			const { _cfg,_tbl,_tmp,_path } = await init( _table,null,this );
-			let data = await readline.hash( this,_tbl,_hash );
-				data = data.map(x=>{ return JSON.parse(x) });
-			response({ data:data, table:_table });
-		} catch(e) { reject(e); }}); 
-	}
-
-}
-
-//TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = streamDB;