molly-db 1.0.6 → 1.0.10

package/main.js

@@ -22,21 +22,20 @@ class molly_db{
             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_`,{
+                   `${__dirname}/module/_worker_.js`,{
                     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(); });
+            this.worker.on('exit',(err)=>{ console.log(err); reject() });
+            this.worker.on('error',(err)=>{ console.log(err); reject() });
+            this.worker.on('message',(msg)=>{ console.log(msg); response() });
         });
     }
 

package/module/_crypto_.js

@@ -28,19 +28,23 @@ const JsonFormatter = {
 /* --------------------------------------------------------------------------------------- */
 
 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();
+	[
+		['c','ç'],
+		['n','ñ'],
+		['e','é|è|ê|ë'],
+		['i','í|ì|î|ï'],
+		['u','ú|ù|û|ü'],
+		['o','ó|ò|ô|õ|ö'],
+		['a','á|à|ã|â|ä'],
+		['' ,/\s+|\W+/,]
+	].map(x=>{
+		const regex = new RegExp(x[1],'gi');
+		str = str.replace( regex,x[0] );
+	});	return str.toLowerCase();
+}
+
+output.hash = (data,nonce)=>{
+	return crypto.SHA256(Math.random+data+nonce).toString();
 }
 
 output.encrypt = ( _message,_password )=>{ 

package/module/_init_.js

@@ -43,7 +43,8 @@ function fillDB( _db, _table, _path ){
 
             const DB = db._init_.DB[i];
             const name = DB.name;
-    
+            delete db[name];
+
             db[name] = new Object();
     
             for( var j in DB.tables ){

package/module/_server_.js

@@ -1,13 +1,15 @@
 
-function text( _data ){
-    res.writeHead(200,{'contetn-type':'text/plain'});
-    res.end( _data );
-}
+const api = url.parse( req.url,true );
+let params = api.query;
+let body = undefined;
+let parse = api;
+
+/* --------------------------------------------------------------------------------------- */
 
 function error( _error ){
-    res.writeHead(200,{'contetn-type':'text/plain'});
-    res.end(`error: ${_error.message}`);
-    console.log(_error);
+    res.writeHead(404,{'contetn-type':'application/json'});
+    res.end(JSON.stringify([{ status:'error', message:_error }]));
+    console.log( _error,req.url );
 }
 
 function json( _data ){
@@ -19,11 +21,22 @@ function json( _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() }
+        try{
+            if( req.method == 'POST' ){
+                const data = new Array();
+                req.on('data',(chunk)=>{ data.push(chunk); });
+                req.on('close',()=>{ try{
+                    const buff = Buffer.concat(data).toString();
+                    const object = JSON.parse(buff);
+                    const date = Date.now();
+                        
+                    if( !object.hash )
+                        object.hash = crypto.hash( date,0 );
+                        
+                    response(JSON.stringify(object)); 
+                } catch(e) { response(false) } });
+            } else { response(true) }
+        } catch(e) { response(false) } 
     });
 } 
 
@@ -49,6 +62,38 @@ function encryptDB( _db,_table, _path ){
     });
 }
 
+function validate( _params ){
+    return new Promise((response,reject)=>{
+
+        let validator = false;
+
+        const vdb = (key)=>{ return db._init_.DB.some(x=>{ return x.name == key; }) }
+        const vtb = (key)=>{ return db._init_.DB.some(x=>{ return x.tables.join().match(key); }) }
+
+        validator = [
+            [ !_params.offset, '_params.offset = 0' ],
+            [ !_params.target, '_params.target = ""' ],
+            [ !_params.length, '_params.length = 100' ],
+        ].every(x=>{ if(x[0]) eval(x[1]); return true; });
+
+        validator = [
+            [!body, {status:'error',message:'invalid data'}],
+            [!_params?.db, {status:'error',message:'no db name added'}],
+            [!_params?.table, {status:'error',message:'no table name added'}]
+        ].some(x=>{ if(x[0]) reject(x[1]); return x[0];}); if(validator) return 0;
+
+        if( !(/table|db/gi).test(parse.pathname) ){
+            validator = [
+                [!vdb(_params?.db), {status:'error',message:`no db called ${_params.db} exist`}],
+                [!vtb(_params?.table), {status:'error',message:`no table called ${_params.table} exist`}]
+            ].some(x=>{ if(x[0]) reject(x[1]); return x[0];}); if(validator) return 0;
+        }
+
+        response(_params);
+
+    });
+}
+
 /* --------------------------------------------------------------------------------------- */
 
 function list( _params ){
@@ -83,118 +128,162 @@ function hash( _params ){
 /* --------------------------------------------------------------------------------------- */
 
 function shift( _params ){ 
-    const result = db[_params.db][_params.table].shift(); 
-    modifyDB( _params.db,_params.table ); return result;
+    const result = db[_params.db][_params.table].shift(); save( _params ); return result;
 }
 
 function pop( _params ){ 
-    const result = db[_params.db][_params.table].pop(); 
-    modifyDB( _params.db,_params.table ); return result; return result; 
+    const result = db[_params.db][_params.table].pop(); save( _params ); return result; 
 }
 
 /* --------------------------------------------------------------------------------------- */
 
 async function push( _params ){
 
-    const body = await getBody();
     db[_params.db][_params.table].push( body );
 
-    modifyDB( _params.db,_params.table );
-    return {
+    save( _params ); 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 {
+    save( _params ); 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 {
+    save( _params ); return [{
         database: _params.db,
         table: _params.table,
         status: 'unshifted'
-    };
+    }];
 }
 
 /* --------------------------------------------------------------------------------------- */
 
-function addDB( _params ){
-
-    const init = `${query.path}/_init_.json`;
+async function update( _params ){
 
-    db._init_.DB.push({
-        name: _params.db,
-        tables: []
+    const index = db[_params.db][_params.table].findIndex(x=>{ 
+        const regex = new RegExp(_params.target,'gi');
+        return regex.test(x);
     });
 
-    db[_params.db] = new Array(); 
-    fs.writeFileSync( init,JSON.stringify(db._init_) );
+    if( !(index<0) ) 
+        db[_params.db][_params.table].splice( index,1,body );
 
-    return {
+    save( _params ); return [{
         database: _params.db,
-        status: 'DB added'
-    };
-
+        table: _params.table,
+        status: 'udated'
+    }];
 }
 
-function removeDB( _params ){
+async function remove( _params ){
 
-    const init = `${query.path}/_init_.json`;
-    const i = db._init_.DB.findIndex(x=>{
-        return x.name == _params.db
-    }); 
+    const index = db[_params.db][_params.table].findIndex(x=>{ 
+        const regex = new RegExp(_params.target,'gi');
+        return regex.test(x);
+    });
 
-    db._init_.DB[i].tables.forEach(x=>{
-        const path = `${query.path}/${x}.json`;
-        fs.unlinkSync(path);
-    }); db._init_.DB.splice(i,1);
+    if( !(index<0) )
+        db[_params.db][_params.table].splice( index,1 );
 
-    db[_params.db] = new Array();
-    fs.writeFileSync( init,JSON.stringify(db._init_) );
+    save( _params ); return [{
+        database: _params.db,
+        table: _params.table,
+        status: 'removed'
+    }];
+}
 
-    return {
+async function save( _params ){
+
+    modifyDB( _params.db,_params.table );
+    return [{
         database: _params.db,
         table: _params.table,
-        status: 'DB deleted'
-    };
+        status: 'saved'
+    }];
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function addDB( _params ){
+    try{
+
+        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'
+        }];
+
+    } catch(e) {  }
 }
 
-function modifyDB( _name, _table ){
+function removeDB( _params ){
+    try{
 
-    const init = `${query.path}/_init_.json`;
-    const path = `${query.path}/${_table}.json`;
+        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'
+        }];
 
-    fs.writeFileSync( init,JSON.stringify(db._init_) );
+    } catch(e) {  }
+}
 
-    try {
-        const length = db[_name][_table].length;
-        if( length>0 ) encryptDB( _name, _table, path );
-        else fs.writeFileSync( path,'' );
-    } catch(e) { 
-        fs.unlinkSync( path ); 
-    }  
+function modifyDB( _name, _table ){
+    try{
 
+        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 ); 
+        }  
+
+    } catch(e) {  }
 }
 
 /* --------------------------------------------------------------------------------------- */
@@ -213,13 +302,12 @@ function addTable( _params ){
     }); db._init_.DB[i].tables.push(_params.table);
 
     db[_params.db][_params.table] = new Array();
-    modifyDB( _params.db,_params.table );
     
-    return {
+    return [{
         database: _params.db,
         table: _params.table,
         status: 'table added'
-    };
+    }];
 
 }
 
@@ -235,28 +323,42 @@ function removeTable( _params ){
 
     db._init_.DB[i].tables.splice(j,1);
     delete db[_params.db][_params.table];
-    modifyDB( _params.db,_params.table );
 
-    return {
+    return [{
         database: _params.db,
         table: _params.table,
         status: 'table removed'
-    };
+    }];
 
 }
 
 /* --------------------------------------------------------------------------------------- */
 
-(async()=>{
-    try{
+function refresh( _params ){
+    return new Promise((response,reject)=>{
+        _init_().then(()=>{ response([{status: 'done'}]) })
+        .catch((e)=>{ reject([{status:'error',message:e.message}]) });
+    });
+}
 
-        const api = url.parse( req.url,true );
-        const params = api.query;
+/* --------------------------------------------------------------------------------------- */
+
+(async ()=>{
+    try{
+        
+        body = await getBody();
+        params = await validate(params); 
 
         /* 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) )
+        else if( api.pathname == '/update' ) json( await update(params) )
+
+        /* Save Api */
+        else if( api.pathname == '/save' ) json( await save(params) )
+        else if( api.pathname == '/remove' ) json( await remove(params) )
+        else if( api.pathname == '/refresh' ) json( await refresh(params) )
 
         /* Remove Api */
         else if( api.pathname == '/pop' ) json( await pop(params) )
@@ -277,7 +379,7 @@ function removeTable( _params ){
 
         else error('Oops something went wrong');
 
-    } catch(e) { error(e); }
+    } catch(e) { error(e?.message||e); }
 })();
 
 /* --------------------------------------------------------------------------------------- */

package/module/_worker_.js

@@ -9,19 +9,22 @@ 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)=>{
+        try{
+            eval( fs.readFileSync(`${__dirname}/_init_.js`).toString() );
+        } catch(e){ console.log(e); }
+    });
 }
 
 /* --------------------------------------------------------------------------------------- */
 
-function _init_(){
-    return new Promise((response,reject)=>{
-        eval( fs.readFileSync(`${__dirname}/_init_.js`).toString() );
-    });
+function app(req,res){
+    try{
+        eval( fs.readFileSync(`${__dirname}/_server_.js`).toString() );
+    } catch(e) { console.log(e) }
 }
 
 /* --------------------------------------------------------------------------------------- */
@@ -29,14 +32,18 @@ function _init_(){
 (()=>{
     try{
         http.createServer( app ).listen( query.port,()=>{
-            console.log('molly-db is running, please wait');
+            console.log('molly-db cluster is running, please wait');
             _init_().then(()=>{
-                worker.parentPort.postMessage(
-                    `server started -> http://localhost:${query.port}`
-                );
+                worker.parentPort.postMessage({
+                    protocol: 'HTTP',
+                    status: 'started',
+                    workerID: process.pid,
+                    msg: 'molly-db is running',
+                    server: `http://localhost:${query.port}`,
+                });
             }).catch(e=>{ process.exit(1); });
         });
-    } catch(e) { process.exit(1); }
+    } catch(e) {}
 })();
 
 /* --------------------------------------------------------------------------------------- */

package/package.json

@@ -1,7 +1,7 @@
 {
   "license": "MIT",
   "main": "main.js",
-  "version": "1.0.6",
+  "version": "1.0.10",
   "name": "molly-db",
   "author": "bececrazy",
   "scripts": {