molly-db 1.0.1 → 1.0.4

package/main.js

@@ -1,7 +1,6 @@
 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)*/ }
 

package/module/localDB.js

@@ -78,11 +78,11 @@ class localDB{
 	events = new Object()
 	default = { offset: 0, length: 100 }
 
-	constructor( _path, _password ){
-		if( _password ){
-			this.password = _password;
+	constructor( object ){
+		if( object.pass ){
+			this.password = object.pass;
 			this.encrypted = true;
-		} 	this.path = _path;
+		} 	this.path = object.path;
 	}
 
 	// TODO: Encription & Decription DATA //
@@ -127,27 +127,7 @@ class localDB{
 		} 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 ){
+	find( _table, _target, _config ){
 		return new Promise( async(res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
@@ -166,9 +146,7 @@ class localDB{
 					}
 
 					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 ) ){
+					if( ( every ) ){
 						const cns = lineConstrain( _i, _cfg );
 						if( cns == 0 ) _res.push( data );
 						else if( cns == 1 ) _itr.close(); 
@@ -209,7 +187,7 @@ class localDB{
 		} catch(e) { rej( e ); } }); 
 	}
 
-	findByHash( _table, _hash ){
+	hash( _table, _hash ){
 		return new Promise( (res,rej)=>{ try{
 			
 			let { _i,_cfg,_itr,_res,_tmp,_path } = init( _table,null,this );
@@ -434,4 +412,4 @@ class localDB{
 }
 
 //TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = localDB;
+module.exports = localDB;

package/module/readline.js

@@ -0,0 +1,208 @@
+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

@@ -69,11 +69,11 @@ class streamDB{
 	events = new Object()
 	default = { offset: 0, length: 100 }
 
-	constructor( _path, _password ){
-		if( _password ){
-			this.password = _password;
+	constructor( object ){
+		if( object.pass ){
+			this.password = object.pass;
 			this.encrypted = true;
-		} 	this.path = _path;
+		} 	this.path = object.path;
 	}
 	
 	decrypt( _message,_password=this.password,_encrypted=this.encrypted ){ 
@@ -110,27 +110,7 @@ class streamDB{
 		} 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 ){
+	find( _table, _target, _config ){
 		return new Promise( async(res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res } = await init( _table,_config,this );
@@ -149,9 +129,8 @@ class streamDB{
 					}
 
 					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 ) ){
+					if( every ){
 						const cns = lineConstrain( _i, _cfg );
 						if( cns == 0 ) _res.push( data );
 						else if( cns == 1 ) _itr.close(); 
@@ -192,7 +171,7 @@ class streamDB{
 		} catch(e) { rej( e ); } }); 
 	}
 
-	findByHash( _table, _hash ){
+	hash( _table, _hash ){
 		return new Promise( async(res,rej)=>{ try{
 
 			let { _i,_cfg,_itr,_res } = await init( _table,null,this );
@@ -218,4 +197,4 @@ class streamDB{
 }
 
 //TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = streamDB;
+module.exports = streamDB;

package/module/webDB.js

@@ -150,24 +150,6 @@ class createWebDB{
 		} 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.every( ( 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++; });
-
-			if( this.events.close ) this.events.close( _itr );
-
-		} catch(e) { rej( e ); } }); 
-	}
-
 	find( _table, _target, _logic='AND', _config ){ 
 		return new Promise( (res,rej)=>{ try{
 			
@@ -392,4 +374,4 @@ class createWebDB{
 }
 
 // TODO: export --------------------------------------------------------------------------------------//
-module.exports = createWebDB;
+module.exports = createWebDB;

package/package.json

@@ -1,12 +1,12 @@
 {
   "license": "MIT",
   "main": "main.js",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "name": "molly-db",
   "author": "bececrazy",
   "scripts": { "start": "node main" },
   "repository": "https://github.com/EDBC-REPO-NPM/Molly-db",
-  "dependencies": { "axios": "^0.27.2", "readline": "^1.3.0", "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",
+  "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" ]
 }

package/module/mongoDB.js

@@ -1,224 +0,0 @@
-const mongodb = require('mongodb').MongoClient;
-const crypto = require('crypto-js');
-
-//TODO: mongoDB Class ----------------------------------------------------------------------------//
-class mongoDB{
-
-	default = { offset: 0, length: 100, sort:{} }
-
-	constructor( _name,_URL ){
-		this.name = _name;
-		this.path = _URL;
-	}
-
-	// TODO: Searching functions //
-	list( _table, _config ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				if( !_config ) _config = this.default;
-
-				db.db(this.name).collection(_table)
-				.find({})
-				.sort(_config.sort)
-				.skip( _config.offset )
-             	.limit( _config.length )
-				.toArray((err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data
-					});
-				});
-
-			});
-		});
-	}
-
-	match( _table, _target, _index, _config ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				if( !_config ) _config = this.default;
-
-				db.db(this.name).collection(_table)
-				.find({ $text: { $search:_target } })
-				.sort(_config.sort)
-				.skip( _config.offset )
-             	.limit( _config.length )
-				.toArray((err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data
-					});
-				});
-
-			});
-		});
-	}
-
-	find( _table, _object, _config ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				if( !_config ) _config = this.default;
-
-				db.db(this.name).collection(_table)
-				.find( _object )
-				.sort(_config.sort)
-				.skip( _config.offset )
-             	.limit( _config.length )
-				.toArray((err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-	findByHash( _table, _hash, _config ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				if( !_config ) _config = this.default;
-
-				db.db(this.name).collection(_table)
-				.createIndex( _index )
-				.find( {hash:_hash} )
-				.sort(_config.sort)
-				.skip( _config.offset )
-             	.limit( _config.length )
-				.toArray((err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-	createNewHash( _object ){
-		try{
-			return _object.map( (item)=>{
-				item['_stamp'] = Date.now();
-				const _base = JSON.stringify( item );
-				if( !item.hash )
-					item.hash = crypto.SHA256( _base ).toString();
-				return item;
-			});
-		} catch(e) {
-			_object['_stamp'] = Date.now();
-			const _base = JSON.stringify( _object );
-			if( !_object.hash )
-				_object.hash = crypto.SHA256( _base ).toString();
-			return _object;
-		}
-		
-	}
-
-	// TODO: Saving functions //
-
-	push( _table, ..._object ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				_object = this.createNewHash( _object.flat() );
-				db.db(this.name).collection(_table)
-				.insertMany( _object.flat(),(err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-	update( _table, _hash, _object ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				_object = this.createNewHash( _object );
-				db.db(this.name).collection(_table)
-				.updateOne({ hash:_hash },{$set:_object},(err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-	// TODO: Removing functions //
-	remove( _table, _hash ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				db.db(this.name).collection(_table)
-				.deleteOne({ hash:_hash },(err,data)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-	addTable( _table ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-				if (err) rej( err );
-				db.db(this.name).createCollection(_table);
-				res({
-					table: _table,
-					data: data,
-				});
-			});
-		});
-	}
-
-	removeTable( _table ){
-		return new Promise( (res,rej)=>{
-			mongodb.connect(this.path, (err, db)=>{ 
-
-				if (err) rej( err );
-				db.db(this.name).collection(_table)
-				.drop((err, delOK)=>{
-					if (err) rej( err );
-					db.close(); res({
-						table: _table,
-						data: data,
-					});
-				});
-
-			});
-		});
-	}
-
-}
-
-//TODO: localDB Class ----------------------------------------------------------------------------//
-module.exports = mongoDB;