molly-db 1.0.3 → 1.0.4

package/main.js

@@ -2,5 +2,6 @@ const output = new Object();
 
 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;

package/module/localDB.js

@@ -1,22 +1,65 @@
-const readline = require('./readline');
+const readline = require('readline');
+const crypto = require('crypto-js');
 const fs = require('fs');
 
+//TODO: Function ---------------------------------------------------------------------------------//
+function slugify(str){ 
+	const map = {
+		'o' : 'ó|ò|ô|õ|ö|Ó|Ò|Ô|Õ|Ö',
+		'a' : 'á|à|ã|â|ä|À|Á|Ã|Â|Ä',
+	   	'e' : 'é|è|ê|ë|É|È|Ê|Ë',
+	   	'i' : 'í|ì|î|ï|Í|Ì|Î|Ï',
+	   	'u' : 'ú|ù|û|ü|Ú|Ù|Û|Ü',
+		'c' : 'ç|Ç','n':'ñ|Ñ',
+		''  : /\s+|\W+/,
+	};	
+	for (var pattern in map) { 
+		str=str.replace( new RegExp(map[pattern],'gi' ), pattern); 
+	}	return str.toLowerCase();
+}
+
+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(JSON.stringify(jsonObj)).toString('base64');
+  	},
+
+  	'parse': function(jsonStr) {
+    	var jsonObj = JSON.parse( new Buffer(jsonStr,'base64').toString('UTF-8'));
+    	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;
+ 	}
+};
+
 //TODO: Optimization FUnctions -------------------------------------------------------------------//
 
-const _default = { offset: 0, length: 100 };
 const init = function( _table,_config,_self ){
 	return {
-		_tbl: createNewTable( `${_self.path}/${_table}.json` ),
+		_itr: readline.createInterface( createNewTable( `${_self.path}/${_table}.json` ) ),
+		_cfg: !_config ? _self.default : _config,
 		_tmp: `${_self.path}/${_table}_tmp.json`,
 		_path: `${_self.path}/${_table}.json`,
-		_cfg: config(_config),
+		_res: new Array(),
+		_i: 0,
 	}
 };
 
+const lineConstrain = function( _i,_config ){
+	if( _i >= parseInt(_config.length)+parseInt(_config.offset) ) return 1;
+	else if ( _i < parseInt(_config.offset) ) return -1
+	else return 0;
+}
+
 const createNewTable = function( _path ){
 	if( !fs.existsSync( _path ) ) fs.writeFileSync( _path,"" );
 	const table = fs.createReadStream( _path );
-	return table; 
+	return { debug: false, input: table }; 
 }
 
 const createNewHash = function( _object ){
@@ -27,64 +70,195 @@ const createNewHash = function( _object ){
 	return _object;
 }
 
-function config(_config){
-    Object.keys(_config).map((x)=>{
-        _default[x] = _config[x];
-    }); return _default;
-}
-
 //TODO: localDB Class ----------------------------------------------------------------------------//
 
-class localDB {
+class localDB{
 
+	encrypted = false
+	events = new Object()
 	default = { offset: 0, length: 100 }
 
-	constructor( _object ){
-		if( _object.pass ){
-			this.password = _object.pass;
-		} 	this.path = _object.path;
+	constructor( object ){
+		if( object.pass ){
+			this.password = object.pass;
+			this.encrypted = true;
+		} 	this.path = object.path;
 	}
 
-	// TODO: Searching functions --------------------------------------------------- //
+	// TODO: Encription & Decription DATA //
+	encrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
+		try{
+			if( _encrypted )
+			return crypto.AES.encrypt( _message,_password,{
+				format: JsonFormatter
+			}).toString(); return _message;
+		} catch(e) { return _message; }
+	}
+	
+	decrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
+		try{
+			if( _encrypted )
+			return crypto.AES.decrypt( _message,_password,{
+					format: JsonFormatter
+				}).toString(  crypto.enc.Utf8 );
+			return _message;
+		} catch(e) { return _message; }
+	}
+
+	// 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); }}); 
+		return new Promise( (res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const line = this.decrypt( encryptedLine );
+				const cns = lineConstrain( _i, _cfg );
+				if( cns == 0 ) { _res.push( JSON.parse( line ) );
+				} else if( cns == 1 ) _itr.close(); 
+			} catch(e) { rej(`the db can be decripted: ${e}`) }
+			_i++; });
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					const keys = Object.keys( _target );
+					const data = JSON.parse( line );
+
+					const regex = ( x )=>{
+						const target = slugify(_target[x].toString());
+						const info = slugify(data[x].toString());
+						const regex = new RegExp(target,'gi');
+						return regex.test(info);
+					}
+
+					const every = keys.every( (x)=>{return regex(x)} );
+					if( ( every ) ){
+						const cns = lineConstrain( _i, _cfg );
+						if( cns == 0 ) _res.push( data );
+						else if( cns == 1 ) _itr.close(); 
+					_i++;}
+
+				} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const regex = new RegExp(slugify(_match),'gi');
+				const line = this.decrypt( encryptedLine );
+				if( regex.test(slugify(line)) ){
+					const cns = lineConstrain( _i, _cfg );
+					if( cns == 0 ) _res.push( JSON.parse( line ) );
+					else if( cns == 1 ) _itr.close(); 
+				_i++;}
+			} catch(e) { rej(`the db can be decripted: ${e}`) }	
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const line = this.decrypt( encryptedLine );
+				const data = JSON.parse( line );
+				if( data.hash == _hash ){
+					_res.push( data );
+					_itr.close();
+				}
+			} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	// TODO: Saving functions //
+	encryptTable( _table,_password ){
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			const writable = fs.createWriteStream( _tmp );
+
+			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res(); });
+
+			_itr.on( 'line',( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					const encryptedData = this.encrypt( line,_password,true );
+					writable.write( `${encryptedData}\n` );
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ writable.end(); res({
+				table: _table,
+			}); });
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	decryptTable( _table ){
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			const writable = fs.createWriteStream( _tmp );
+
+			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); res(); });
+			_itr.on( 'line',( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					writable.write( `${line}\n` );
+
+				} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ writable.end(); res({
+				table: _table,
+			}); });
+
+		} catch(e) { rej( e ); } }); 
 	}
 
-	// TODO: Saving functions ------------------------------------------------- //
+	// TODO: Saving functions //
 	push( _table, ..._object ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 			
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -103,11 +277,11 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e); }
+		} catch(e) { rej(e); }
 	}); }
 
 	unshift( _table, ..._object ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 			
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -128,11 +302,11 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e) }
+		} catch(e) { rej(e) }
 	}); }
 
 	place( _table, _line, ..._object ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -153,11 +327,11 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e) }
+		} catch(e) { rej(e) }
 	}); }
 
 	update( _table, _hash, ..._object ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -173,7 +347,7 @@ class localDB {
 					});
 				} else
 					writable.write( `${encryptedLine}\n` ); 
-			} catch(e) { reject(`the db can be decripted: ${e}`) }
+			} catch(e) { rej(`the db can be decripted: ${e}`) }
 			});
 			
 			_itr.on( 'close',()=>{ writable.end(); });
@@ -182,12 +356,12 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e) }
+		} catch(e) { rej(e) }
 	}); }
 
 	// TODO: Removing functions //
 	remove( _table, _hash ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -205,21 +379,21 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e) }
+		} catch(e) { rej(e) }
 	}); }
 
 	removeTable( _table ){
-		return new Promise( (response,reject)=>{
+		return new Promise( (res,rej)=>{
 			const _path = `${this.path}/${_table}`;
 			fs.unlink( _path,( err,data )=>{
-				if(err) reject( err );
+				if(err) rej( err );
 				res({ table: _table });
 			});
 		})
 	}
 
 	shift( _table ){
-		return new Promise( (response,reject)=>{ try{
+		return new Promise( (res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
 			const writable = fs.createWriteStream( _tmp );
@@ -232,10 +406,10 @@ class localDB {
 				table: _table,
 			}); });
 
-		} catch(e) { reject(e) }
+		} catch(e) { rej(e) }
 	}); }
 
 }
 
 //TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = localDB;
+module.exports = localDB;

package/module/streamDB.js

@@ -1,77 +1,197 @@
-const readline = require('./readline');
-const fetch = require('axios');
+
+const readline = require('readline');
+const crypto = require('crypto-js');
+const axios = require('axios');
 const fs = require('fs');
 
-//TODO: Optimization FUnctions -------------------------------------------------------------------//
+//TODO: Function ---------------------------------------------------------------------------------//
+function slugify(str) { 
+	const map = {
+		'o' : 'ó|ò|ô|õ|ö|Ó|Ò|Ô|Õ|Ö',
+		'a' : 'á|à|ã|â|ä|À|Á|Ã|Â|Ä',
+	   	'e' : 'é|è|ê|ë|É|È|Ê|Ë',
+	   	'i' : 'í|ì|î|ï|Í|Ì|Î|Ï',
+	   	'u' : 'ú|ù|û|ü|Ú|Ù|Û|Ü',
+		'c' : 'ç|Ç','n':'ñ|Ñ',
+		''  : /\s+|\W+/,
+	};	
+	for (var pattern in map) { 
+		str=str.replace( new RegExp(map[pattern],'gi' ), pattern); 
+	}	return str.toLowerCase();
+}
 
-const _default = { offset: 0, length: 100 };
+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(JSON.stringify(jsonObj)).toString('base64');
+  	},
+
+  	'parse': function(jsonStr) {
+    	var jsonObj = JSON.parse( new Buffer(jsonStr,'base64').toString('UTF-8'));
+    	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;
+ 	}
+};
+
+//TODO: Optimization FUnctions -------------------------------------------------------------------//
 
 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,
+	return new Promise( (res,rej)=>{
+		axios.get(`${_self.path}/${_table}.json`,{responseType:'stream'})
+		.then( ({data})=>{
+			res({
+				_itr: readline.createInterface({ input: data }),
+				_cfg: !_config ? _self.default : _config,
+				_res: new Array(),
+				_i: 0,
 			});
-		});
+		}) .catch( e=>rej() );
 	});
 };
 
-function config(_config){
-	if( !_config ) return _default;
-    Object.keys(_config).map((x)=>{
-        _default[x] = _config[x];
-    }); return _default;
+const lineConstrain = function( _i,_config ){
+	if( _i >= parseInt(_config.length)+parseInt(_config.offset) ) return 1;
+	else if ( _i < parseInt(_config.offset) ) return -1
+	else return 0;
 }
 
 //TODO: localDB Class ----------------------------------------------------------------------------//
 
 class streamDB{
 
-	constructor( _object ){
-		if( _object.pass ){
-			this.password = _object.pass;
-		} 	this.path = _object.path;
+	encrypted = false
+	events = new Object()
+	default = { offset: 0, length: 100 }
+
+	constructor( object ){
+		if( object.pass ){
+			this.password = object.pass;
+			this.encrypted = true;
+		} 	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); }}); 
+	decrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
+		try{
+			if( _encrypted )
+			return crypto.AES.decrypt( _message,_password,{
+					format: JsonFormatter
+				}).toString(  crypto.enc.Utf8 );
+			return _message;
+		} catch(e) {
+			return _message;
+		}
 	}
 
+	// TODO: Searching functions //
+	list( _table, _config ){
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const line = this.decrypt( encryptedLine );
+				const cns = lineConstrain( _i, _cfg );
+				if( cns == 0 ) { _res.push( JSON.parse( line ) );
+				} else if( cns == 1 ) _itr.close(); 
+			} catch(e) { rej(`the db can be decripted: ${e}`) }
+			_i++; });
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					const keys = Object.keys( _target );
+					const data = JSON.parse( line );
+
+					const regex = ( x )=>{
+						const target = slugify(_target[x].toString());
+						const info = slugify(data[x].toString());
+						const regex = new RegExp(target,'gi');
+						return regex.test(info);
+					}
+
+					const every = keys.every( (x)=>{return regex(x)} );
+
+					if( every ){
+						const cns = lineConstrain( _i, _cfg );
+						if( cns == 0 ) _res.push( data );
+						else if( cns == 1 ) _itr.close(); 
+					_i++;}
+
+				} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const regex = new RegExp(slugify(_match),'gi');
+				const line = this.decrypt( encryptedLine );
+				if( regex.test(slugify(line)) ){
+					const cns = lineConstrain( _i, _cfg );
+					if( cns == 0 ) _res.push( JSON.parse( line ) );
+					else if( cns == 1 ) _itr.close(); 
+				_i++;}
+			} catch(e) { rej(`the db can be decripted: ${e}`) }	
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( 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); }}); 
+		return new Promise( async(res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res } = await init( _table,null,this );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+				const line = this.decrypt( encryptedLine );
+				const data = JSON.parse( line );
+				if( data.hash == _hash ){
+					_res.push( data );
+					_itr.close();
+				}
+			} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+
+			_itr.on( 'close',()=>{ res({
+				table:_table,
+				data:_res,
+			}); });
+
+		} catch(e) { rej( e ); } }); 
 	}
 
 }

package/module/webDB.js

@@ -0,0 +1,377 @@
+const crypto = require('crypto-js');
+
+//TODO: Function ---------------------------------------------------------------------------------//
+
+const store = {
+	set: function(key,data){ localStorage.setItem(key,data); },
+	key: function(index){ return localStorage.key(index); },
+	get: function(key){ return localStorage.getItem(key); },
+	clear: function(){ localStorage.clear(); },
+	length: localStorage.length,
+}
+
+function slugify(str) { 
+	const map = {
+		'o' : 'ó|ò|ô|õ|ö|Ó|Ò|Ô|Õ|Ö',
+		'a' : 'á|à|ã|â|ä|À|Á|Ã|Â|Ä',
+	   	'e' : 'é|è|ê|ë|É|È|Ê|Ë',
+	   	'i' : 'í|ì|î|ï|Í|Ì|Î|Ï',
+	   	'u' : 'ú|ù|û|ü|Ú|Ù|Û|Ü',
+		'c' : 'ç|Ç','n':'ñ|Ñ',
+		''  : /\s+|\W+/,
+	};	
+	for (var pattern in map) { 
+		str=str.replace( new RegExp(map[pattern],'gi' ), pattern); 
+	}	return str.toLowerCase();
+}
+
+//TODO: Function ---------------------------------------------------------------------------------//
+
+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 btoa( JSON.stringify(jsonObj) );
+  	},
+
+  	'parse': function(jsonStr) {
+    	var jsonObj = JSON.parse( atob(jsonStr) );
+    	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;
+ 	}
+};
+
+//TODO: Function ---------------------------------------------------------------------------------//
+
+const init = function( _table,_config,_self ){
+	return {
+		_cfg: !_config ? _self.default : _config,
+		_itr: _createNewTable_( _table ),
+		_res: new Array(),
+		_i: 0,
+	}
+};
+
+const _lineConstrain_ = function( _i,_config ){
+	if( _i >= parseInt(_config.length)+parseInt(_config.offset) ) return 1;
+	else if ( _i < parseInt(_config.offset) ) return -1
+	else return 0;
+}
+
+const _createNewTable_ = function( _path ){
+	const content = store.get( _path )
+	if( content == null ) return new Array();
+	return content.split('\n'); 
+}
+
+const _createNewHash_ = function( _object ){
+	_object['_stamp'] = Date.now();
+	const _base = JSON.stringify( _object );
+	if( !_object.hash )
+		_object.hash = crypto.SHA256( _base ).toString();
+	return _object;
+}
+
+
+//TODO: localDB Class ----------------------------------------------------------------------------//
+
+class createWebDB{
+
+	constructor( _password ){
+		this.encrypted = false
+		this.events = new Object()
+		this.default = { offset: 0, length: 100 }
+		if( !crypto ) return console.log(' please import libs.crypto ');
+		if( _password ){
+			this.password = _password;
+			this.encrypted = true;
+		}
+	}
+
+	//TODO: clear all LocalStorage //
+	removeTable( _table ){ 
+		store.set( _table, null ); 
+		delete localStorage[ _table ];
+	}
+
+	//TODO: clear all LocalStorage //
+	removeTable( _table ){ 
+		store.set( _table, null ); 
+		delete localStorage[ _table ];
+	}
+
+	clearDB(){ store.clear(); }
+
+	// TODO: Encription & Decription DATA //
+	encrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
+		try{
+			if( this.encrypted )
+				return crypto.AES.encrypt( _message,this.password,{
+					format: JsonFormatter
+				}).toString( crypto.enc.Utf8 );
+			return _message;
+		} catch(e) { return _message; }
+	}
+	
+	decrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
+		try{
+			if( this.encrypted )
+				return crypto.AES.decrypt( _message,this.password,{
+					format: JsonFormatter
+				}).toString( crypto.enc.Utf8 );
+			return _message;
+		} catch(e) { return _message; }
+	}
+
+	// TODO: Searching functions //
+	list( _table, _config ){ 
+		return new Promise( (res,rej)=>{ try{
+
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,_config,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				const cns = _lineConstrain_( _i, _cfg );
+				const data = JSON.parse( line );
+
+				if( cns == 0 ) _res.push( data );
+				else if( cns == 1 ) return false;
+
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+
+			_i++; return true; }); res({data:_res,table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	find( _table, _target, _logic='AND', _config ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,_config,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				const keys = Object.keys( _target );
+				const data = JSON.parse( line );
+
+				const regex = ( x )=>{
+					const target = slugify(_target[x].toString());
+					const data = slugify(data[x].toString());
+					const regex = new RegExp(target,'gi');
+					return regex.test(data);
+				}
+
+				const every = keys.every( (x)=>{return regex(x)} );
+				const some = keys.some( (x)=>{return regex(x)} );
+
+				if( ( (/AND/gi).test(_logic) && every ) || ( (/OR/gi).test(_logic) && some ) ){
+					const cns = _lineConstrain_(_i, _cfg );
+					if( cns == 0 ) _res.push( data );
+					else if( cns == 1 ) return false;
+				_i++;}
+
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+
+			return true; }); res({data:_res,table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	match( _table, _match, _config ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,_config,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				if( slugify(line).search( slugify(_match) ) >= 0 ){
+					const cns = _lineConstrain_(_i, _cfg );
+					const data = JSON.parse( line );
+					if( cns == 0 ) _res.push( data );
+					else if( cns == 1 ) return false;
+				i++;}
+				
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+			return true; }); res({data:_res,table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	findByHash( _table, _hash ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				const data = JSON.parse( line );
+
+				if( data.hash == _hash ){
+					_res.push( data );
+					return false;
+				}
+
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+			_i++; return true; }); res({data:_res,table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	// TODO: Saving functions //
+	push( _table, ..._object ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+
+			_object.flat().forEach( item=>{
+				item = _createNewHash_( item );
+				const data = JSON.stringify(item);
+				_itr.push( this.encrypt( data ) );
+			}); store.set( _table,_itr.join('\n') ); res({table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	unshift( _table, ..._object ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			
+			_object.flat().forEach( item=>{
+				item = _createNewHash_( item );
+				const data = JSON.stringify(item);
+				_itr.unshift( this.encrypt(data) );
+			}); store.set( _table,_itr.join('\n') ); res({table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	place( _table, _line, ..._object ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			
+			_object.flat().forEach( item=>{
+				item = _createNewHash_( item );
+				const data = JSON.stringify(item);
+				_itr.splice( _line,0,this.encrypt(data) );
+			}); store.set( _table,_itr.join('\n') ); res({table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	update( _table, _hash, ..._object ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				const data = JSON.parse( line );
+
+				if( data.hash == _hash ){
+
+					_object.flat().forEach( item=>{
+						item = _createNewHash_( item );
+						const data = JSON.stringify(item);
+						_itr.splice( _i,1,this.encrypt(data) );
+					}); return false;
+				}
+
+				_i++;} catch(e) { rej(`the db can be decripted ${e}`) }
+			return true; }); store.set( _table,_itr.join('\n') ); res({table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	// TODO: Removing functions //
+	remove( _table, _hash ){ 
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+
+			_itr.every( ( encryptedLine )=>{ try{
+
+				const line = this.decrypt( encryptedLine );
+				const data = JSON.parse( line );
+
+				if( data.hash == _hash ){
+					_object = _createNewHash_( _object );
+					_itr.splice( _i,0 );
+					return false;
+				}
+
+				_i++;} catch(e) { rej(`the db can be decripted ${e}`) }
+			return true; }); store.set( _table,_itr.join('\n') ); res({table:_table});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	shif( _table ){ 
+		return new Promise( (res,rej)=>{ try{
+			const _itr = _createNewTable_( _table );
+			_itr.shif(); store.set( _table,_itr.join('\n') ); res({table:_table});
+		} catch(e) { rej( e ); } }); 
+	}
+
+	pop( _table ){ 
+		return new Promise( (res,rej)=>{ try{
+			const _itr = _createNewTable_( _table );
+			_itr.pop(); store.set( _table,_itr.join('\n') ); res({table:_table});
+		} catch(e) { rej( e ); } }); 
+	}
+
+	// TODO: Saving functions //
+	encryptTable( _table,_password ){
+		return new Promise( (res,rej)=>{ try{
+				
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			const writable = fs.createWriteStream( _tmp );
+			let db = new String();
+
+			_itr.every( ( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					const encryptedData = this.encrypt( line,_password,true );
+					db += `${encryptedData}\n`;
+				} catch(e) { rej(`the db can be decripted ${e}`) }
+			});
+
+			store.set(_table,db); res({ table:_table });
+	
+		} catch(e) { rej( e ); } }); 
+	}
+	
+	decryptTable( _table ){
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			const writable = fs.createWriteStream( _tmp );
+			let db = new String();
+
+			_itr.on( 'line',( encryptedLine )=>{ 
+				try{
+					const line = this.decrypt( encryptedLine );
+					db += `${line}\n`;
+				} catch(e) { rej(`the db can be decripted: ${e}`) }
+			});
+	
+			store.set(_table,db); res({ table:_table });
+	
+		} catch(e) { rej( e ); } }); 
+	}
+
+}
+
+// TODO: export --------------------------------------------------------------------------------------//
+module.exports = createWebDB;

package/package.json

@@ -1,7 +1,7 @@
 {
   "license": "MIT",
   "main": "main.js",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "name": "molly-db",
   "author": "bececrazy",
   "scripts": { "start": "node main" },