binhend 1.0.0

package/README.md

@@ -0,0 +1 @@
+# binhend

package/example/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Binh } = require('../src/binh');
+
+new Binh()
+    .id()
+    .rootpath(__dirname)
+    .config(function(loader) {
+        loader.object({ PORT: 1400 });
+    })
+    .api('routes')
+    .cluster.fork(-100)
+    .port(binh.config('PORT'))
+    .start(function(server, configs) {
+        console.log('### START >>> configs:', configs);
+    });

package/example/routes/test/index.js

@@ -0,0 +1,15 @@
+const { router, get, post } = binh().Router();
+
+get('/', function(req, res) {
+    res.json({ path:'/', dir: __dirname, file: __filename });
+});
+
+get('/sub', function(req, res) {
+    res.json({ path:'/sub', dir: __dirname, file: __filename });
+});
+
+get('/goo', function(req, res) {
+    res.json({ path:'/goo', dir: __dirname, file: __filename });
+});
+
+module.exports = router;

package/example/routes/test/some.js

@@ -0,0 +1,11 @@
+const { router, get, post } = binh().Router();
+
+get('/', function(req, res) {
+    res.json({ path:'/', dir: __dirname, file: __filename });
+});
+
+get('/sub', function(req, res) {
+    res.json({ path:'/sub', dir: __dirname, file: __filename });
+});
+
+module.exports = router;

package/example/routes/testa.js

@@ -0,0 +1,15 @@
+const { router, get, post } = binh().Router();
+
+get('/', function(req, res) {
+    res.json({ path:'/', dir: __dirname, file: __filename });
+});
+
+get('/sub', function(req, res) {
+    res.json({ path:'/sub', dir: __dirname, file: __filename });
+});
+
+get('/gaa', function(req, res) {
+    res.json({ path:'/gaa', dir: __dirname, file: __filename });
+});
+
+module.exports = router;

package/index.js

@@ -0,0 +1,9 @@
+/*
+ * anodejs
+ * Copyright(c) 2023 Nguyen Duc Binh
+ * 
+ */
+
+'use strict';
+
+module.exports = require('./src/binh');

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "binhend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "author": "Nguyen Duc Binh",
+  "license": "UNLICENSED",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "example": "node example"
+  },
+  "dependencies": {
+    "express": "^4.17.1"
+  },
+  "devDependencies": {
+  },
+  "engines": {
+    "node": ">= 16.17.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,74 @@
+const { readdir, statSync } = require('fs');
+const { join, parse } = require('path');
+// const { Router } = require('./router');
+const express = require('express');
+
+function mapAPIs(dirpath, router) {
+    readdir(dirpath, function(error, item_names) {
+        if (error) {
+            console.log('Error scanning items in directory:', dirpath, '. Error:', error);
+            return;
+        }
+
+        item_names.forEach(function(item) {
+            var path = join(dirpath, item),
+                route = parse(item).name;
+
+            try {
+                var stat = statSync(path);
+                var child_router;
+                
+                if (stat.isFile()) {
+                    child_router = require(path);
+                }
+
+                if (stat.isDirectory()) {
+                    try {
+                        child_router = require(path);
+                    }
+                    catch (error) {
+                        child_router = Router().router;
+                    }
+
+                    mapAPIs(path, child_router);
+                }
+
+                router.use(`/${route}`, child_router);
+                console.log('[NODE] Mapping Restful APIs from:', path);
+            }
+            catch (error) {
+                console.log('Error check status of file path:', path, '. Error:', error);
+            }
+        });
+    });
+}
+
+function APIs(rootpath) {
+    const router = express.Router();
+    router.use(express.urlencoded({ extended: false }));
+    router.use(express.json());
+
+    rootpath = rootpath || join(__dirname, 'routes');
+
+    mapAPIs(rootpath, router);
+    
+    return router;
+}
+
+function Router() {
+    var router = express.Router();
+
+    var output = { router };
+
+    for (var key in router) {
+        if (router[key] instanceof Function) {
+            output[key] = router[key].bind(router);
+        }
+    }
+
+    return output;
+}
+
+module.exports = {
+    APIs, Router
+};

package/src/binh.js

@@ -0,0 +1,115 @@
+const crypto = require('crypto');
+const cluster = require('cluster');
+const os = require('os');
+
+const { ConfigLoader } = require('./configuration');
+const { HTTPS } = require('./https');
+const { Server } = require('./server');
+const { APIs, Router } = require('./api');
+
+const Crypto = require('./cryptography');
+
+const maxcpus = os.cpus().length;
+
+function generateId() {
+    crypto.randomUUID({ disableEntropyCache: true });
+}
+
+function Binh() {
+    var _this = this,
+        forkcount = 0,
+        rootpath = '';
+
+    var binh = function(module_path) {
+        return module_path == undefined ? module.exports : require(`${rootpath}/${module_path}`);
+    };
+
+    var config = {}, loadConfigs = null, configloader = new ConfigLoader(config);
+
+    binh.config = function(key) {
+        return typeof key === 'string' ? config[key] : config;
+    };
+
+    binh.config.reload = function() {
+        return new Promise(function(resolve) {
+            if (loadConfigs instanceof Function) {
+                var loader = new ConfigLoader(config);
+                loadConfigs(loader);
+                loader.done(resolve);
+            }
+            else resolve(config);
+        });
+    };
+
+    binh.config.loader = function() {
+        return new ConfigLoader(config);
+    };
+
+    global.binh = binh;
+
+    this.rootpath = function(path) {
+        rootpath = typeof path === 'string' ? path : '';
+        return this;
+    };
+
+    this.id = function(id) {
+        binh.id = id == undefined ? generateId() : JSON.stringify(id);
+        return this;
+    }
+
+    this.config = function(callback) {
+        if (callback instanceof Function) {
+            loadConfigs = callback;
+            callback(configloader);
+        }
+        return this;
+    }
+
+    this.cluster = {
+        fork: function(number) {
+            forkcount = Math.max(0, number >= 0 ? number : maxcpus + number);
+            return _this;
+        },
+        max: function() {
+            forkcount = maxcpus;
+            return _this;
+        }
+    };
+
+    this.api = function(api_path) {
+        this.api.value = new APIs(`${rootpath}/${api_path}`);
+        return this;
+    };
+
+    this.port = function(port) {
+        this.port.value = port;
+        return this;
+    };
+
+    this.start = function(callback) {
+        if (forkcount > 0 && cluster.isMaster) {
+            for (var i = 0; i < forkcount; i++) {
+                cluster.fork(); 
+            }
+        }
+        else {
+            launch(callback);
+        }
+    };
+
+    function launch(callback) {
+        configloader.done(function(configs) {
+            var server = new Server({
+                port: _this.port.value,
+                api: _this.api.value
+            });
+
+            if (callback instanceof Function) {
+                callback(server, configs);
+            }
+        });
+    }
+
+}
+
+module.exports = { Binh, HTTPS, ConfigLoader, Crypto, Router };

package/src/configuration.js

@@ -0,0 +1,145 @@
+'use strict';
+
+var fs = require('fs');
+
+function ConfigLoader(config_object) {
+    const configs = config_object || {};
+
+    this.getConfigs = function() {
+        return configs;
+    };
+
+    function getConfigPosition(key) {
+        return key == undefined ? configs : (configs[key] = configs[key] || {});
+    };
+
+    this.object = function(object, key) {
+        try {
+            var config = getConfigPosition(key);
+            Object.assign(config, JSON.parse(JSON.stringify(object)));
+        }
+        catch(e) {
+            return failed(e, object);
+        }
+        return this;
+    };
+
+    this.json = function(filepath, key) {
+        return this.object(json(filepath), key);
+    };
+
+    this.cli = function(key) {
+        return this.object(cli(), key);
+    };
+
+    this.file = function(path, encoding, key) {
+        return this.object(file(path, encoding), key);
+    };
+
+    var deferred = [];
+
+    this.loadAsync = function(callback, key) {
+        var _this = this;
+        var promise = loadAsync(callback).then(function(loaded_config) {
+            _this.object(loaded_config, key);
+        });
+        deferred.push(promise);
+        return this;
+    };
+
+    this.done = function(callback) {
+        var _this = this;
+
+        setTimeout(function() {
+            Promise.all(deferred).then(function() {
+                deferred = [];
+                callback(_this.getConfigs());
+            });
+        });
+
+        return this;
+    };
+
+    this.target = function(config_object) {
+        return new ConfigLoader(config_object);
+    };
+}
+
+function json(filepath) {
+    try {
+        return require.main.require(filepath);
+    }
+    catch(e) {
+        return failed(e, filepath);
+    }
+}
+
+function cli() {
+    return processKeyValueStrings(process.argv);
+}
+
+function file(path, encoding) {
+    encoding = encoding || 'utf8';
+    try {
+        var source = fs.readFileSync(path, { encoding });
+        source = source.replace(/\r\n?/mg, '\n');
+        var lines = source.split('\n');
+
+        return processKeyValueStrings(lines);
+    }
+    catch(e) {
+        return failed(e, path);
+    }
+}
+
+function processKeyValueStrings(strings) {
+    var output = {};
+
+    if (strings == undefined || !strings.length) {
+        return output;
+    }
+
+    var regex_is_comment = /^#/;
+
+    strings.forEach(function(string) {
+        if (regex_is_comment.test(string.trim())) return;
+
+        var parsed = parseKeyValue(string);
+        if (parsed.success) {
+            output[parsed.key] = parsed.value;
+        }
+    });
+
+    return output;
+}
+
+function parseKeyValue(string) {
+    var delimiter = '=';
+
+    var parts = string.split(delimiter);
+    if (parts.length < 2) return { success: false };
+
+    var key = parts[0];
+    var value = parts.splice(1).join(delimiter);
+
+    return { key, value, success: true };
+}
+
+function loadAsync(callback) {
+    return new Promise(callback);
+}
+
+function config(config_object) {
+    return new ConfigLoader(config_object);
+}
+
+function failed(error, source) {
+    console.log(`Failed loading config from: ${source}`);
+    console.log('Details:', error);
+    return {};
+};
+
+module.exports = {
+    ConfigLoader, config,
+    json, cli, file, loadAsync
+};

package/src/cryptography.js

@@ -0,0 +1,49 @@
+
+const crypto = require('crypto');
+const algorithm = 'aes-256-cbc';
+const lenght_iv = 16;
+const lenght_key = 32;
+
+function generateSecurityKey() {
+    return crypto.randomBytes(lenght_key).toString('hex');
+}
+
+function generateInitialVector() {
+    return crypto.randomBytes(lenght_iv).toString('hex');
+}
+
+function encrypt(text, key, iv) {
+    key = Buffer.from(key, 'hex');
+    iv = Buffer.from(iv, 'hex');
+    var cipher = crypto.createCipheriv(algorithm, key, iv);
+    var encrypted = cipher.update(text, 'utf-8', 'hex');
+    encrypted += cipher.final('hex');
+    return encrypted;
+}
+
+function decrypt(encrypted, key, iv) {
+    key = Buffer.from(key, 'hex');
+    iv = Buffer.from(iv, 'hex');
+    var decipher = crypto.createDecipheriv(algorithm, key, iv);
+    var decrypted = decipher.update(encrypted, 'hex', 'utf-8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+
+function hash(text, encoding = 'hex', length = 256) {
+    return new Promise(function(resolve, reject) {
+        var salt = crypto.randomBytes(32).toString('hex'),
+            options = { N: 16, r: 8, p: 1 };
+
+        crypto.scrypt(text, salt, length, options, (err, derivedKey) => {
+            if (err) return reject(err);
+            resolve(derivedKey.toString(encoding));
+        });
+    });
+}
+
+module.exports = {
+    encrypt, decrypt, hash,
+    generateSecurityKey,
+    generateInitialVector
+};

package/src/https.js

@@ -0,0 +1,93 @@
+
+const https = require('https');
+
+function HTTPS(url) {
+    this.url = url;
+    this.parameters = [];
+};
+
+var prototype = HTTPS.prototype;
+
+prototype.get = function(callback) {
+    return this.request('GET', callback);
+}
+
+prototype.post = function(callback) {
+    return this.request('POST', callback);
+}
+
+prototype.request = function(method, callback) {
+
+    var URL = this.url + this.parameters.join('/') + (this.queries || '');
+
+    var options = {
+        method,
+        headers: this.headers
+    };
+
+    var req = https.request(URL, options, function(res) {
+        res.setEncoding('utf8');
+
+        var data = '';
+
+        res.on('data', (chunk) => {
+            data += chunk;
+        });
+
+        res.on('end', () => {
+            var response;
+            
+            try {
+                response = JSON.parse(data);
+            }
+            catch(error) {
+                response = data;
+            }
+
+            if (callback instanceof Function) {
+                callback(response);
+            }
+        });
+    });
+
+    req.on("error", (err) => {
+        console.log("HTTPS request encounters error:" + err.message);
+    });
+
+    if (this.payload) {
+        req.write(JSON.stringify(this.payload));
+    }
+
+    req.end();
+
+    return this;
+}
+
+prototype.header = function(map) {
+    this.headers = map;
+    return this;
+}
+
+prototype.body = function(map) {
+    this.payload = JSON.stringify(map);
+    return this;
+}
+
+prototype.parameter = function(array) {
+    if (array instanceof Array) {
+        var last_char = this.url[this.url.length - 1];
+        this.parameters = (last_char === '/' ? [] : ['']).concat(array);
+    }
+    return this;
+}
+
+prototype.query = function(map) {
+    var query_string = '';
+    for (var key in map) {
+        query_string += key + '=' + map[key] + '&';
+    }
+    this.queries = '?' + query_string;
+    return this;
+}
+
+module.exports = { HTTPS };

package/src/server.js

@@ -0,0 +1,18 @@
+const express = require('express');
+
+function Server(options) {
+    const server = express();
+    const PORT = options.port || 1300;
+    
+    if (options.api) {
+        server.use(options.api);
+    }
+    
+    server.listen(PORT, function() {
+        console.log(`[NODE] Server is listening on http://localhost:${PORT}/`);
+    });
+
+    return server;
+}
+
+module.exports = { Server };

package/test/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "palindrome",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "istanbul cover node_modules/mocha/bin/_mocha"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "istanbul": "^0.4.4",
+    "mocha": "^3.0.1"
+  }
+}