molly-db 1.3.0 → 1.3.2

package/module/worker_handler.js

@@ -0,0 +1,47 @@
+/*--────────────────────────────────────────────────────────────────────────────────────────────--*/
+
+const memory = require('./memory_handler');
+const worker = require('worker_threads');
+const init = require('./init_handler');
+const {Buffer} = require('buffer');
+const utils = require('./utils');
+const path = require('path');
+
+/*--────────────────────────────────────────────────────────────────────────────────────────────--*/
+
+function Error(error){ console.log(`worker error: ${error}`); }
+function Exit(code){ console.log(`worker exit code: ${code}`); }
+
+/*--────────────────────────────────────────────────────────────────────────────────────────────--*/
+
+function saveTimeout(data,db){
+    setTimeout(() => {
+        if( db._update_ ){
+            db._update_ = false;
+            utils.saveAll(data,db);
+        }
+    }, data.time * 3600 * 1000 );
+}
+
+/*--────────────────────────────────────────────────────────────────────────────────────────────--*/
+
+module.exports = (args)=>{
+    init( args ).then((db)=>{ saveTimeout( args, db );
+        const dir = path.join(__dirname,'server_worker.js');
+        const srv = new worker.Worker(dir,{ workerData: args });
+        srv.on('error',Error); srv.on('exit',Exit); srv.on('message',(msg)=>{
+            const empty = '{ "status":"404", "message":"empty data" }';
+            const error = '{ "status":"404", "message":"error data" }';
+            try {
+                const raw = Buffer.from(msg).toString(); 
+                memory(args,JSON.parse(raw),db).then(x=>{ 
+                    const out = JSON.stringify(x); srv.postMessage(out||empty);
+                }).catch(e=>{
+                    const out = JSON.stringify(e); srv.postMessage(out||empty);
+                })
+            } catch(e) { console.log(e); srv.postMessage(error) }
+        });
+    }).catch((e)=>{ console.log(e) });
+}
+
+/*--────────────────────────────────────────────────────────────────────────────────────────────--*/

package/package.json

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

@@ -1,21 +0,0 @@
-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/module/_api_.js

@@ -1,212 +0,0 @@
-/* --------------------------------------------------------------------------------------- */
-
-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{
-        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);
-    } catch(e) { return parseError(e) }
-}
-
-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(){
-    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 { status: 'DB Saved' };
-    } catch(e) { console.log(e); return parseError(e) }
-}

package/module/_app_.js

@@ -1,187 +0,0 @@
-
-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();
-        if( api.pathname == '/saveAll' ) 
-            return json( await saveAll() );
-            params = await validate(params);
-
-        /* Find Api */
-        switch( api.pathname ){
-
-            case '/pop':        return json( await pop(params) );
-            case '/shift':      return json( await shift(params) );
-
-            case '/list':       return json( await list(params) );
-            case '/hash':       return json( await hash(params) );
-            case '/match':      return json( await match(params) );
-            case '/update':     return json( await update(params) );
-
-            case '/push':       return json( await push(params) );
-            case '/slice':      return json( await splice(params) );
-            case 'unshift':     return json( await unshift(params) );
-
-            case '/save':       return json( await save(params) );
-            case '/remove':     return json( await remove(params) );
-            case '/refresh':    return json( await refresh(params) );
-
-            case '/index':      return json( await indexOf(params) );
-            case '/length':     return json( await lengthOf(params) );
-
-            case '/addDB':      return json( await addDB(params) );
-            case '/removeDB':   return json( await removeDB(params) );
-            case '/addTable':   return json( await addTable(params) );
-            case '/removeTable':return json( await removeTable(params) );
-
-            default:            return error(parseError('Oops something went wrong'));
-
-        }
-
-    } catch(e) { error(parseError(e)); }
-})();
-
-/* --------------------------------------------------------------------------------------- */

package/module/_crypto_.js

@@ -1,158 +0,0 @@
-const crypto = require('crypto-js');
-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;
- 	}
-
-};
-
-/* --------------------------------------------------------------------------------------- */
-
-output.slugify = (str)=>{ 
-	[
-		['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 )=>{ 
-    try{if( _password )
-        return crypto.AES.encrypt( _message,_password,{
-            format: JsonFormatter
-        }).toString(); return _message;
-    } catch(e) { return _message; }
-}
-
-output.decrypt = ( _message,_password )=>{ 
-    try{if( _password )
-        return crypto.AES.decrypt( _message,_password,{
-                format: JsonFormatter
-            }).toString( crypto.enc.Utf8 );
-        return _message;
-    } catch(e) { return _message; }
-}
-
-/* -------------------------------------------------------------------------------------------------------- */
-
-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;