molly-db 1.0.27 → 1.0.30

package/main.js

@@ -19,6 +19,8 @@ class molly_db{
         this.pass = opt.pass; this.port = opt.port || 27017;
         this.path = opt.path.replace( /^\./,process.cwd() );
         this.threads = opt.threads || 1;
+        this.import = opt.import || '';
+        this.time = opt.saveTime || .5;
         return require(`${__dirname}/module/_worker_.js`)(this);
     }
 }

package/module/_api_.js

@@ -0,0 +1,214 @@
+/* --------------------------------------------------------------------------------------- */
+
+function list( _params ){
+    try{return parseData( db[_params.db][_params.table].slice(
+            _params.offset, Number(_params.offset)+Number(_params.length)
+        ).map(x=>JSON.parse(x)));
+    } catch(e) { return parseError(e) }
+}
+
+function match( _params ){
+    try{
+
+    } catch(e) {
+        const result = new Array();
+        db[_params.db][_params.table].map((x)=>{
+            const reg = crypto.slugify(_params.target);
+            const regex = new RegExp(reg,'gi');
+            const target = crypto.slugify(x);
+            if( regex.test(target) ) result.push(x);
+        });
+        return parseData( result.map(x=>JSON.parse(x)).slice(
+            _params.offset, Number(_params.offset)+Number(_params.length)
+        ), result.length);
+    }
+}
+
+function hash( _params ){
+    try{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 parseData( result.map(x=>JSON.parse(x)).slice(
+            _params.offset, Number(_params.offset)+Number(_params.length)
+        ), result.length);
+    } catch(e) { return parseError(e) }
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function unshift( _params ){ db._update_ = true;
+    return parseData(db[_params.db][_params.table].unshift(...body)) 
+}
+
+async function push( _params ){ db._update_ = true;
+    return parseData(db[_params.db][_params.table].push(...body)) 
+}
+
+async function shift( _params ){ db._update_ = true;
+    return parseData(db[_params.db][_params.table].shift()) 
+}
+
+async function pop( _params ){ db._update_ = true;
+    return parseData(db[_params.db][_params.table].pop()) 
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function update( _params ){
+    try{db._update_ = true;
+        for( var i in db[_params.db][_params.table] ){
+            
+            const regex = new RegExp(_params.target,'gi');
+            if( regex.test(db[_params.db][_params.table][i]) )
+                return db[_params.db][_params.table].splice(i,1,...body);
+
+        }
+    } catch(e) { return parseError(e) }
+}
+
+async function remove( _params ){
+    try{db._update_ = true;
+        for( var i in db[_params.db][_params.table] ){
+            
+            const regex = new RegExp(_params.target,'gi');
+            if( regex.test(db[_params.db][_params.table][i]) )
+                return db[_params.db][_params.table].splice(i,1);
+
+        }
+    } catch(e) { return parseError(e) }
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function addTable( _params ){
+    try{db._update_ = true;
+        
+        if( db[_params.db][_params.table] ) return {
+            status: 'table already exist',
+            database: _params.db,
+            table: _params.table,
+        };
+    
+        for( var i in db._init_.DB ){
+            if( db._init_.DB[i].name == _params.db ){
+                db[_params.db][_params.table] = new Array();
+                db._init_.DB[i].tables.push(_params.table);
+                break;
+            }
+        }
+        
+        /*await save( _params )*/ return [{
+            status: 'table added',
+            database: _params.db,
+            table: _params.table,
+        }];
+
+    } catch(e) { return parseError(e) }
+}
+
+async function removeTable( _params ){
+    try{db._update_ = true;
+
+        if( !db[_params.db][_params.table] ) return {
+            status: 'table does not exist',
+            database: _params.db,
+            table: _params.table,
+        };
+    
+        for( var i in db._init_.DB ){
+            if( db._init_.DB[i].name == _params.db ){
+                delete db[_params.db][_params.table];
+                db._init_.DB[i].tables.splice(j,1);
+                break;
+            }
+        }
+    
+        /*await save( _params )*/ return [{
+            status: 'table removed',
+            database: _params.db,
+            table: _params.table,
+        }];
+
+    } catch(e) { return parseError(e) }
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function addDB( _params ){
+    try{db._update_ = true;
+
+        if( db[_params.db] ) return {
+            status: 'DB already exist',
+            database: _params.db,
+            table: _params.table,
+        };
+        
+        db._init_.DB.push({ 
+            tables: [], name: _params.db,
+        }); db[_params.db] = new Array();
+    
+        /*await save( _params )*/ return [{
+            database: _params.db,
+            status: 'DB added'
+        }];
+
+    } catch(e) { return parseError(e) }
+}
+
+async function removeDB( _params ){
+    try{
+
+        if( !db[_params.db] ) return {
+            status: 'DB does not exist',
+            database: _params.db,
+            table: _params.table,
+        };
+
+        for( var i in db._init_.DB ){
+            if( db._init_.DB.name == _params.db ){
+                db._init_.DB[i].tables.map(x=>{
+                    const path = `${query.path}/${x}.json`;
+                    fs.unlinkSync(path);
+                }); db._init_.DB.splice(i,1);
+                delete db[_params.db];
+                break;
+            }
+        }
+    
+        /*await save( _params )*/ return [{
+            database: _params.db,
+            table: _params.table,
+            status: 'DB deleted'
+        }];
+
+    } catch(e) { return parseError(e) }
+}
+
+async 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) ) fs.writeFileSync(path,'');
+            else await encryptDB( _name, _table, path );
+        } catch(e) { fs.unlinkSync( path ); }
+
+    } catch(e) { return parseError(e) }
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+async function saveAll( _params ){
+    try{for( var i in db['_init_'] ){ for( var j in db['_init_'][i] ){
+        const {name,tables} = db['_init_'][i][j];
+        for( var k in tables ) 
+            await modifyDB(name,tables[k])
+    }}  return parseData([]);
+    } catch(e) { return parseError(e) }
+}

package/module/_app_.js

@@ -0,0 +1,188 @@
+
+const api = url.parse( req.url,true );
+const query = process.mollyDB;
+let params = api.query;
+let body = undefined;
+let parse = api;
+
+/* --------------------------------------------------------------------------------------- */
+
+function error( _error ){
+    res.writeHead(404,{'contetn-type':'application/json'});
+    res.end(JSON.stringify([{ status:'error', message:_error }]));
+    console.log( _error,req.url );
+}
+
+function json( _data ){
+    res.writeHead(200,{'content-type':'application/json'});
+    res.end(JSON.stringify(_data));
+}
+
+function parseData( _data, _length ){
+    const length = _length||db[params.db][params.table].length;
+    const pagination = Math.ceil(length/_data.length)||1;
+    return {
+        pagination: pagination,  
+        database: params.db,
+        table: params.table,
+        length: length,
+        status: 'OK',
+        data: _data,
+    }
+}
+
+function parseError( _e ){
+    return {
+        data: _e.message||_e,
+        database: params.db,
+        table: params.table,
+        status: 'error',
+    }
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+function bodyParser( _data ){
+    try{
+        const date = Date.now(); _data = JSON.parse(_data);
+        const result = _data.length ? _data : [_data];
+        return result.map(x=>{ if( !x?.hash )
+            x.hash = crypto.hash( date,Math.random() );
+            return JSON.stringify(x);
+        });
+    } catch(e) { return false }
+}
+
+function getBody(){
+    return new Promise((response,reject)=>{
+        try{
+            if( req.method == 'POST' || (/push|unshift|splice|update/).test(api.pathname) ){
+                const data = new Array();
+                req.on('data',(chunk)=>{ data.push(chunk); });
+                req.on('close',()=>{ try{
+                    const buff = Buffer.concat(data);   
+                    response( bodyParser(buff) ); 
+                } catch(e) { response(false) } });
+            } else { response(true) }
+        } catch(e) { response(false) } 
+    });
+} 
+
+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 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|all/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 refresh( _params ){
+    return new Promise((response,reject)=>{
+        _init_().then(()=>{ response([{status: 'done'}]) })
+        .catch((e)=>{ reject([{status:'error',message:e.message}]) });
+    });
+}
+
+async function save( _params ){
+    await modifyDB( _params.db,_params.table );
+    return [{
+        database: _params.db,
+        table: _params.table,
+        status: 'saved'
+    }];
+}
+
+/* --------------------------------------------------------------------------------------- */
+
+(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) )
+
+        else if( api.pathname == '/index' ) json( await indexOf(params) )
+        else if( api.pathname == '/length' ) json( await lengthOf(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) )
+        else if( api.pathname == '/saveAll' ) json( await saveAll(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(parseError('Oops something went wrong'));
+
+    } catch(e) { error(parseError(e)); }
+})();
+
+/* --------------------------------------------------------------------------------------- */

package/module/_crypto_.js

@@ -1,4 +1,3 @@
-
 const crypto = require('crypto-js');
 const output = new Object();
 
@@ -36,7 +35,7 @@ output.slugify = (str)=>{
 		['u','ú|ù|û|ü'],
 		['o','ó|ò|ô|õ|ö'],
 		['a','á|à|ã|â|ä'],
-		['' ,/\s+|\W+/,]
+		['' ,/\s+|\W+| /,]
 	].map(x=>{
 		const regex = new RegExp(x[1],'gi');
 		str = str.replace( regex,x[0] );
@@ -66,4 +65,94 @@ output.decrypt = ( _message,_password )=>{
 
 /* -------------------------------------------------------------------------------------------------------- */
 
+class State {
+
+    state = new Object(); 
+    events = new Array();
+    update = new Array();
+    active = true;
+
+    constructor( state ){
+        for( var i in state ){
+            this.state[i] = state[i];
+        }
+    }
+
+    set( state ){ let newState;
+        
+        const oldState = new Object();
+        const keys = Object.keys(this.state);
+        keys.map(x=>{ oldState[x]=this.state[x] });
+
+        if( typeof state == 'function' ){
+            newState = state( this.state ); const validator = [
+                [!newState,'state is empty, please set a return state'],
+                [typeof newState != 'object','state is not an object, please return a valid Object'],
+            ];  if( validator.some(x=>{ if(x[0]) console.log(x[1]); return x[0] }) ) return 0;
+        } else if( !state || typeof state != 'object' ) { 
+            return console.log('state is not an object, please return a valid Object') 
+        } else { newState = state; } 
+
+        this.active = this.shouldUpdate(null,[this.state,newState]); 
+        for( var i in newState ){ this.state[i] = newState[i];
+            this.callback( i, oldState[i], newState[i] );
+        }
+
+    }
+
+    get( item ){ return this.state[item] }
+
+    shouldUpdate( callback,attr ){
+        if( callback && typeof callback == 'function' )
+            return this.update.push(callback);
+        else if( callback && callback != 'function' )
+            return console.log('callback should be a function');
+        if( this.update.length == 0 ) return true;
+        return this.update.some( x=>x(...attr) );
+    }
+
+    forceUpdate( item ){
+        for( var i in this.events ){
+            const field = this.events[i][0]
+            this.events[i][1](
+                this.state[field],
+                this.state[field]
+            );
+        }
+    }
+
+    callback( item, prev, act ){
+        if( !this.active ) return 0; 
+        for( var i in this.events ){
+            if( this.events[i][0] == item )
+                this.events[i][1]( prev,act );
+        }
+    }
+
+    observeField( field,callback ){
+        const id = this.eventID();
+        const event = [field,callback,id];
+        this.events.push(event); return id;
+    }
+
+    unObserveField( eventID ){
+        for( var i in this.events ){
+            if( this.events[i][2] == eventID ){
+                this.events.splice(i,1);
+                return true;
+            }
+        }   return false;
+    }
+
+    eventID(){
+        return crypto.SHA256(`
+			${Math.random()}
+			${Date.now()}
+		`).toString();
+    }
+
+};	output.state = State;
+
+/* -------------------------------------------------------------------------------------------------------- */
+
 module.exports = output;

package/module/_init_.js

@@ -17,7 +17,7 @@ function fillDB( _db, _table, _path ){
         else { console.log(`error reading ${_path}`); return response(); }     
 
         _itr.on('line',(line)=>{
-            db[_db][_table].push(crypto.decrypt( line,query.pass ));
+            db[_db][_table].push(crypto.decrypt( line,process.mollyDB.pass ));
         }); _itr.on('close',()=>{ response() });
         
     });
@@ -28,9 +28,10 @@ function fillDB( _db, _table, _path ){
 (()=>{ return new Promise(async(response,reject)=>{
     try {
 
-        const path = `${query.path}/_init_.json`;
+        const path = `${process.mollyDB.path}/_init_.json`;
+        db._update_ = true;
 
-        if( (/^http/).test(query.path) ){
+        if( (/^http/).test(process.mollyDB.path) ){
             const stream = await fetch(path);
             db._init_ = stream.data;
         } else{ 
@@ -38,7 +39,7 @@ function fillDB( _db, _table, _path ){
             db._init_ = JSON.parse( db._buff_ );
         }
 
-        db._path_ = query.path;
+        db._path_ = process.mollyDB.path;
         for( var i in db._init_.DB ){
 
             const DB = db._init_.DB[i];
@@ -58,8 +59,8 @@ function fillDB( _db, _table, _path ){
     } catch(e) {
 
         db._init_ = { DB:[] };
-        db._path_ = query.path;
-        const path = `${query.path}/_init_.json`;
+        db._path_ = process.mollyDB.path;
+        const path = `${process.mollyDB.path}/_init_.json`;
         fs.writeFileSync( path,JSON.stringify(db._init_) );
 
     }   response();

package/module/_worker_.js

@@ -11,41 +11,52 @@ const fs = require('fs');
 /* --------------------------------------------------------------------------------------- */
 
 const db = new Object();
-let query;
+const api_script = fs.readFileSync(`${__dirname}/_api_.js`).toString();
+const app_script = fs.readFileSync(`${__dirname}/_app_.js`).toString();
+const init_script = fs.readFileSync(`${__dirname}/_init_.js`).toString();
+//const importDB_script = fs.readFileSync(`${__dirname}/_importDB.js`).toString();
 
 /* --------------------------------------------------------------------------------------- */
 
-function _init_(){
-    try{ return eval( fs.readFileSync(`${__dirname}/_init_.js`).toString() );
-    } catch(e){ console.log(e); }
-}
+async function _init_(){ await eval(`try{ ${init_script} }catch(e){console.log(e)}`) }
+async function _importDB_(){ await eval(`try{ ${importDB_script} }catch(e){console.log(e)}`) }
+async function app(req,res){ await eval(`try{ ${api_script} \n ${app_script} }catch(e){console.log(e)}`) }
 
 /* --------------------------------------------------------------------------------------- */
-
-function app(req,res){
-    try{ eval( fs.readFileSync(`${__dirname}/_server_.js`).toString() );
-    } catch(e) { console.log(e) }
+function saveTimeout(){
+    time = process.mollyDB.time * 3600000;
+    setTimeout(() => {
+        if( db._update_ == true ){
+            const api = url.format({
+                path: '/saveAll?db=&table=',
+                port: process.mollyDB.port,
+                host: 'http://127.0.0.1',
+            }); fetch(api).then().catch();
+            db._update_ = false;
+        }
+    }, time);
 }
-
 /* --------------------------------------------------------------------------------------- */
 
-module.exports = (args)=>{ query = args;
+module.exports = (args)=>{ process.mollyDB = args;
     return new Promise((response,reject)=>{
 
-        if ( cluster.isPrimary ) { for ( let i=query.threads; i--; ) { 
-            const worker = cluster.fork();
-            worker.on('message', (msg)=>{ console.log(msg); response(); });
-            cluster.on('exit', (worker, code, signal) => { cluster.fork();
-                console.log(`worker ${worker.process.pid} died`);
-            });  worker.on('exit', (msg)=>{ reject(msg); });
-        }} else { 
-            http.createServer( app ).listen( query.port,()=>{
+        if( cluster.isPrimary ) 
+            for ( let i=args.threads; i--; ){ const worker = cluster.fork();
+                worker.on('message', (msg)=>{ console.log(msg); response(); });
+                cluster.on('exit', (worker, code, signal) => { cluster.fork();
+                    console.log(`worker ${worker.process.pid} died`);
+                }); worker.on('exit', (msg)=>{ reject(msg); });
+            }
+
+        else 
+            http.createServer( app ).listen( process.mollyDB.port,()=>{
                 _init_().then(()=>{ process.send({
-                    workerID: process.pid, port: query.port,
-                    protocol: 'HTTP', status: 'started',
-                })}).catch(e=>{ console.log(e); });
+                        protocol: 'HTTP', status: 'started',
+                        workerID: process.pid, port: process.mollyDB.port,
+                    }); saveTimeout();
+                }).catch(e=>{ console.log(e) });
             }); 
-        }
 
     });
 }

package/package.json

@@ -1,18 +1,12 @@
 {
   "license": "MIT",
   "main": "main.js",
-  "version": "1.0.27",
   "name": "molly-db",
+  "version": "1.0.30",
   "author": "bececrazy",
-  "scripts": {
-    "start": "node main"
-  },
+  "scripts": { "start": "node main" },
   "repository": "https://github.com/EDBC-REPO-NPM/Molly-db",
-  "dependencies": {
-    "crypto-js": "^4.1.1",
-    "fs": "^0.0.1-security",
-    "molly-fetch": "^1.0.16"
-  },
+  "dependencies": { "crypto-js": "^4.1.1", "molly-fetch": "^1.0.16" },
   "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",

package/module/_server_.js

@@ -1,382 +0,0 @@
-
-const api = url.parse( req.url,true );
-let params = api.query;
-let body = undefined;
-let parse = api;
-
-/* --------------------------------------------------------------------------------------- */
-
-function error( _error ){
-    res.writeHead(404,{'contetn-type':'application/json'});
-    res.end(JSON.stringify([{ status:'error', message:_error }]));
-    console.log( _error,req.url );
-}
-
-function json( _data ){
-    res.writeHead(200,{'content-type':'application/json'});
-    res.end(JSON.stringify(_data));
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-function bodyParser( _data ){
-
-    const date = Date.now(); _data = JSON.parse(_data);
-    const result = _data.length ? _data : [_data];
-
-    return result.map(x=>{ if( !x?.hash )
-        x.hash = crypto.hash( date,Math.random() );
-        return JSON.stringify(x);
-    });
-
-}
-
-function getBody(){
-    return new Promise((response,reject)=>{
-        try{
-            if( req.method == 'POST' || (/push|unshift|splice|update/).test(api.pathname) ){
-                const data = new Array();
-                req.on('data',(chunk)=>{ data.push(chunk); });
-                req.on('close',()=>{ try{
-                    const buff = Buffer.concat(data);   
-                    response( bodyParser(buff) ); 
-                } catch(e) { response(false) } });
-            } else { response(true) }
-        } catch(e) { response(false) } 
-    });
-} 
-
-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 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 ){
-    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)
-    );
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-async function shift( _params ){ 
-    const result = db[_params.db][_params.table].shift(); await save( _params ); return result;
-}
-
-async function pop( _params ){ 
-    const result = db[_params.db][_params.table].pop(); await save( _params ); return result; 
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-function lengthOf( _params ){ return db[_params.db][_params.table].length; }
-function indexOf( _params ){ 
-    return db[_params.db][_params.table].indexOf(x=>{
-        const regex = new RegExp(_params.target,'gi');
-        return regex.test(x);
-    });
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-async function unshift( _params ){
-
-    db[_params.db][_params.table].unshift( ...body );
-
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'unshifted'
-    }];
-}
-
-async function push( _params ){
-
-    db[_params.db][_params.table].push( ...body );
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'pushed'
-    }];
-
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-async function update( _params ){
-
-    const index = db[_params.db][_params.table].findIndex(x=>{ 
-        const regex = new RegExp(_params.target,'gi');
-        return regex.test(x);
-    });
-
-    if( !(index<0) ) 
-        db[_params.db][_params.table].splice( index,1,...body );
-
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'udated'
-    }];
-}
-
-async function remove( _params ){
-
-    const index = db[_params.db][_params.table].findIndex(x=>{ 
-        const regex = new RegExp(_params.target,'gi');
-        return regex.test(x);
-    });
-
-    if( !(index<0) )
-        db[_params.db][_params.table].splice( index,1 );
-
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'removed'
-    }];
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-async function addDB( _params ){
-    try{
-
-        db._init_.DB.push({
-            tables: [],
-            name: _params.db,
-        }); db[_params.db] = new Array(); 
-    
-        await save( _params ); return [{
-            database: _params.db,
-            status: 'DB added'
-        }];
-
-    } catch(e) {  }
-}
-
-async function removeDB( _params ){
-    try{
-
-        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();
-    
-        await save( _params ); return [{
-            database: _params.db,
-            table: _params.table,
-            status: 'DB deleted'
-        }];
-
-    } catch(e) {  }
-}
-
-async 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 ) 
-                await encryptDB( _name, _table, path );
-            else 
-                fs.writeFileSync( path,'' );
-        } catch(e) { 
-            fs.unlinkSync( path ); 
-        }  
-
-    } catch(e) {  }
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-async 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();
-    
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'table added'
-    }];
-
-}
-
-async 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];
-
-    await save( _params ); return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'table removed'
-    }];
-
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-function refresh( _params ){
-    return new Promise((response,reject)=>{
-        _init_().then(()=>{ response([{status: 'done'}]) })
-        .catch((e)=>{ reject([{status:'error',message:e.message}]) });
-    });
-}
-
-async function save( _params ){
-    await modifyDB( _params.db,_params.table );
-    return [{
-        database: _params.db,
-        table: _params.table,
-        status: 'saved'
-    }];
-}
-
-/* --------------------------------------------------------------------------------------- */
-
-(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) )
-
-        else if( api.pathname == '/index' ) json( await indexOf(params) )
-        else if( api.pathname == '/lengt' ) json( await lengthOf(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) )
-        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?.message||e); }
-})();
-
-/* --------------------------------------------------------------------------------------- */