molly-db 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Enmanuel D Becerra C
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+# LWDB : lightweight Database
+
+lw-db is a free and open source library for nodejs that allow you create a lightweight encrypted database using Json files
+
+# Usage
+
+### init lwdb on nodeJS
+```
+
+const lwdb = require('lwdb');
+
+ldb = new lwdb.createLocalDB( '/PATH/TO/DATA/BASE' ); // for non encrypted data
+
+// or
+
+ldb = new lwdb.createLocalDB( '/PATH/TO/DATA/BASE', 'PASSWORD' ); // for encrypted data
+	
+```
+
+### init lwdb on Browser
+```
+
+<script type="text/javascript" src="https://molly-js.github.io/MollyJS-Libs/molly.js" ></script>
+
+<script type="text/javascript">
+	require( libs.crypto, libs.lwdb )
+	.then( ()=>{
+		ldb = new lwdb.createWebDB( 'PASSWORD' );
+	} )
+</script>
+	
+```
+
+### get an item list from a table
+```
+let table = 'tableName' //NOTE: if table doesn't exist lwdb generates a new one
+
+let config = { offset:0, length:10 }
+
+ldb.list( table,config )
+.then( (response)=>{
+	console.log( response );
+})
+```
+
+### fing from a target object
+```
+let table = 'test';
+
+let target = {
+	name:'Peter'
+}
+
+let logic = 'AND' or 'OR'
+
+let config = { // optional
+	offset:0, length:10
+}
+
+ldb.find( table,target,logic,config )
+.then( (response)=>{
+	console.log( response );
+});
+
+```
+
+### find by matching
+```
+let table = 'test';
+
+let match = 'peter'
+
+let config = { // optional
+	offset:0, length:10
+}
+
+ldb.match( table,match,config )
+.then( (response)=>{
+	console.log( response );
+});
+
+```
+
+### find by hash
+```
+let table = 'test';
+
+let hash = 'SHA256_TEST'
+
+let config = { // optional
+	offset:0, length:10
+}
+
+ldb.findByHash( table,hash,config )
+.then( (response)=>{
+	console.log( response );
+});
+
+```
+
+### push a new item at the end
+```
+let table = 'test';
+
+let object = {
+	name:'Peter',
+	S: 'Male',
+	age: 23,
+}
+
+ldb.push(table,object)
+.then( ()=>{ /* once finish */ });
+
+```
+
+### push a new item at the beginning
+```
+let table = 'test';
+
+let object = {
+	name:'Peter',
+	S: 'Male',
+	age: 23,
+}
+
+ldb.unshift(table,object)
+.then( ()=>{ /* once finish */ });
+
+```
+
+### place a new item in the middle
+```
+let table = 'test';
+
+let line = 5; //if exist
+
+let object = {
+	name:'Peter',
+	S: 'Male',
+	age: 23,
+}
+
+ldb.place(table,line,object)
+.then( ()=>{ /* once finish */ });
+
+```
+
+### replace an item
+```
+let table = 'test';
+
+let hash = 'SHA256_TEST'
+
+let object = {
+	name:'Peter',
+	S: 'Male',
+	age: 23,
+}
+
+ldb.replace(table,hash,object)
+.then( ()=>{ /* once finish */ });
+
+```
+
+### remove an item
+```
+let table = 'test';
+
+let hash = 'SHA256_TEST'
+
+ldb.remove(table,hash)
+.then( ()=>{ /* once finish */ });
+
+```
+
+### remove the last item
+```
+let table = 'test';
+
+ldb.pop(table)
+.then( ()=>{ /* once finish */ });
+```
+
+### remove the first item
+```
+let table = 'test';
+
+ldb.shift(table)
+.then( ()=>{ /* once finish */ });
+```
+
+### remove a table
+```
+let table = 'test';
+
+ldb.removeTable(table)
+.then( ()=>{ /* once finish */ });
+
+```

package/main.js

@@ -0,0 +1,8 @@
+const output = new Object();
+
+try{ output.streamDB = require('./module/streamDB'); } catch(e) { /*console.log(e)*/ }
+try{ output.mongoDB = require('./module/mongoDB'); } 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

@@ -0,0 +1,437 @@
+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 init = function( _table,_config,_self ){
+	return {
+		_itr: readline.createInterface( createNewTable( `${_self.path}/${_table}.json` ) ),
+		_cfg: !_config ? _self.default : _config,
+		_tmp: `${_self.path}/${_table}_tmp.json`,
+		_path: `${_self.path}/${_table}.json`,
+		_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 { debug: false, input: 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;
+}
+
+//TODO: localDB Class ----------------------------------------------------------------------------//
+
+class localDB{
+
+	encrypted = false
+	events = new Object()
+	default = { offset: 0, length: 100 }
+
+	constructor( _path, _password ){
+		if( _password ){
+			this.password = _password;
+			this.encrypted = true;
+		} 	this.path = _path;
+	}
+
+	// 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( (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 ); } }); 
+	}
+
+	on( _event, _callback ){ this.events[_event] = _callback; }
+	loop( _table ){
+		return new Promise( (res,rej)=>{ try{
+			
+			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
+			if( this.events.start ) this.events.start( _itr );
+
+			_itr.on( 'line',( encryptedLine )=>{ try{
+					const line = this.decrypt( encryptedLine );
+					if( this.events.data ) this.events.data( line,_i,_itr );
+				} catch(e) { rej(`the db can be decripted: ${e}`) }
+			_i++; });
+
+			_itr.on( 'close',()=>{ 
+				if( this.events.close ) this.events.close( _itr );
+			});
+
+		} catch(e) { rej( e ); } }); 
+	}
+
+	find( _table, _target, _logic='AND', _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 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)} );
+					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 ) _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(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 ); } }); 
+	}
+
+	findByHash( _table, _hash ){
+		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 //
+	push( _table, ..._object ){
+		return new Promise( (res,rej)=>{ 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) { rej(e); }
+	}); }
+
+	unshift( _table, ..._object ){
+		return new Promise( (res,rej)=>{ 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) { rej(e) }
+	}); }
+
+	place( _table, _line, ..._object ){
+		return new Promise( (res,rej)=>{ 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) { rej(e) }
+	}); }
+
+	update( _table, _hash, ..._object ){
+		return new Promise( (res,rej)=>{ 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) { rej(`the db can be decripted: ${e}`) }
+			});
+			
+			_itr.on( 'close',()=>{ writable.end(); });
+
+			writable.on( 'finish',()=>{ fs.renameSync( _tmp, _path ); 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 );
+			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) { rej(e) }
+	}); }
+
+	removeTable( _table ){
+		return new Promise( (res,rej)=>{
+			const _path = `${this.path}/${_table}`;
+			fs.unlink( _path,( err,data )=>{
+				if(err) rej( err );
+				res({ table: _table });
+			});
+		})
+	}
+
+	shift( _table ){
+		return new Promise( (res,rej)=>{ 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) { rej(e) }
+	}); }
+
+}
+
+//TODO: localDB Class ----------------------------------------------------------------------------//
+module.exports = localDB;