npm - binhend - Versions diffs - 1.5.16 → 2.0.1 - Mend

binhend 1.5.16 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/bin/commands/new-service.js +20 -0
package/bin/commands/new-ui.js +21 -0
package/bin/index.js +4 -0
package/bin/templates/component/Service.js +0 -0
package/bin/templates/component/UI.js +8 -0
package/bin/templates/component/ui/Component.js +26 -0
package/bin/templates/component/ui/Service.js +7 -0
package/bin/templates/component/ui/Style.css +3 -0
package/bin/templates/component/ui/UI.js +17 -0
package/bin/templates/frontend/src/favicon.png +0 -0
package/bin/templates/frontend/src/index.html +5 -0
package/bin/templates/frontend/src/style.css +3 -0
package/package.json +3 -3
package/src/api.js +84 -58
package/src/binh.js +20 -60
package/src/configuration.js +29 -99
package/src/csd/controller.js +93 -0
package/src/csd/dao.js +17 -0
package/src/csd/index.js +15 -0
package/src/csd/service.js +58 -0
package/src/middleware/parseBasicAuthToken.js +11 -0
package/src/server.js +4 -50
package/src/utils/bromise.js +20 -0
package/src/utils/httpCodes.js +69 -0
package/src/utils/typeOf.js +78 -0
package/src/{component.build.js → web/component.build.js} +1 -0
package/src/{component.format.js → web/component.format.js} +1 -0
package/src/web/component.method.js +141 -0
package/src/web/index.js +46 -0
package/src/binh.server.app.js +0 -78
package/src/binh.server.config.js +0 -80
package/src/cors.js +0 -17
package/src/enum.httpCodes.js +0 -49
/package/src/{cryptography.js → security.js} +0 -0
/package/src/{binh.web.builder.js → web/binh.web.builder.js} +0 -0
/package/src/{code.js → web/code.js} +0 -0
/package/src/{component.file.js → web/component.file.js} +0 -0
/package/src/{component.js → web/component.js} +0 -0

package/bin/commands/new-service.js ADDED Viewed

@@ -0,0 +1,20 @@
+const path = require('path');
+const fs = require('fs');
+const cwdJoin = require('../utils/cwdJoin');
+module.exports = (args) => {
+    try {
+        var destinationPath = cwdJoin(args[0] || 'frontend'),
+        sourcePath = path.join(__dirname, '../templates/frontend');
+        console.log('[BINHEND][CLI] Generate front-end structure:', destinationPath);
+        fs.cpSync(sourcePath, destinationPath, {recursive: true});
+        // TODO logic adding excluded directories to .gitignore
+    }
+    catch (error) {
+        console.error('[BINHEND][CLI] Error generating front-end structure!');
+        throw error;
+    }
+};

package/bin/commands/new-ui.js ADDED Viewed

@@ -0,0 +1,21 @@
+const path = require('path');
+const fs = require('fs');
+const cwdJoin = require('../utils/cwdJoin');
+module.exports = (args) => {
+    try {
+        var itemName = args[0] || 'ui-component';
+        if (itemName.endsWith('.js')) {
+            // handle copying file
+            return;
+        }
+        // copy UI sample folder
+    }
+    catch (error) {
+        console.error('[BINHEND][CLI] Error generating front-end structure!');
+        throw error;
+    }
+};

package/bin/index.js CHANGED Viewed

@@ -8,6 +8,10 @@ const commandMap = {
     start: () => require('./commands/start-server'),
     build: () => require('./commands/build-project'),
     test: () => require('./commands/test-project'),
+    new: {
+        ui: () => require('./commands/new-ui'),
+        service: () => require('./commands/new-service'),
+    }
 };
 var command = commandMap,

package/bin/templates/component/Service.js ADDED Viewed

File without changes

package/bin/templates/component/UI.js ADDED Viewed

@@ -0,0 +1,8 @@
+tag('div');
+function ui() {
+    var content = div({ class: 'new-ui' });
+    return content;
+}

package/bin/templates/component/ui/Component.js ADDED Viewed

@@ -0,0 +1,26 @@
+require('./UI');
+require('./Service');
+css(
+    require('./Style.css')
+);
+function ui() {
+    Service(); // initialize service instance (singleton)
+    var component = UI(),
+    handleStateChanged = component.action('handleStateChanged'),
+    makeRequest = Service.instant('makeRequest');
+    component.listen('stateId', function(data) {
+        // ... transform data if need
+        handleStateChanged(data);
+    })
+    .when('request', function(data) {
+        // ... transform data if need
+        makeRequest(data);
+    });
+    return component;
+}

package/bin/templates/component/ui/Service.js ADDED Viewed

@@ -0,0 +1,7 @@
+function service({ state, http, sid, define, _this }) {
+    this.makeRequest = function(data) {
+        // use data to handle logic, call API, or change state
+        console.log('Service received data from UI:', data);
+    }
+}

package/bin/templates/component/ui/Style.css ADDED Viewed

@@ -0,0 +1,3 @@
+.new-ui {
+    color: red;
+}

package/bin/templates/component/ui/UI.js ADDED Viewed

@@ -0,0 +1,17 @@
+tag('div');
+function ui() {
+    var newUI = div({ class: 'new-ui' }),
+    requestService = newUI.action('request');
+    newUI.when('handleStateChanged', function(data) {
+        // use data to handle logic, e.g. render UI
+        console.log('UI received state data:', data);
+    })
+    .on('click', function(event) {
+        requestService(event.currentTarget.innerText);
+    });
+    return newUI('New UI');
+}

package/bin/templates/frontend/src/favicon.png ADDED Viewed

Binary file

package/bin/templates/frontend/src/index.html CHANGED Viewed

@@ -4,8 +4,13 @@
   <head>
     <title>Binhjs App</title>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" type="image/x-icon" href="/favicon.png">
+    <link href="/style.css" rel="stylesheet">
     <script src="https://binhjs.pages.dev/dist/binh.min.js"></script>
     <script src="/main.js"></script>
   </head>

package/bin/templates/frontend/src/style.css ADDED Viewed

@@ -0,0 +1,3 @@
+body {
+    margin: 0;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "binhend",
-  "version": "1.5.16",
+  "version": "2.0.1",
   "description": "",
   "main": "index.js",
   "author": "Nguyen Duc Binh",
@@ -21,7 +21,7 @@
     "uglifycss": "^0.0.29"
   },
   "engines": {
-    "node": ">=16.17.1",
-    "npm": ">=8.15.0"
+    "node": ">=20.18.0",
+    "npm": ">=10.8.2"
   }
 }

package/src/api.js CHANGED Viewed

@@ -1,78 +1,83 @@
 const { Module } = require('module');
-const { readdir, statSync } = require('fs');
-const { join, parse } = require('path');
+const { readdirSync, statSync } = require('fs');
+const { join, parse, resolve } = require('path');
+const { isUndefined, isFunction } = require('./utils/typeOf');
+const { ServerResponse } = require('http');
 const express = require('express');
+const { server } = require('./server');
+const parseBasicAuthToken = require('./middleware/parseBasicAuthToken');
-function mapAPIs(dirpath, router) {
-    readdir(dirpath, function(error, item_names) {
-        if (error) {
-            console.log('Error scanning items in directory:', dirpath, '. Error:', error);
-            return;
+function mapRoutes(router, dirpath) {
+    readdirSync(dirpath).forEach(function(direntName) {
+        var path = join(dirpath, direntName),
+            route = parse(direntName).name;
+        var stat = statSync(path);
+        var childRouter;
+        if (stat.isFile()) {
+            childRouter = require(path);
+        }
+        else if (stat.isDirectory()) {
+            childRouter = Router().router;
+            mapRoutes(childRouter, path);
         }
-        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);
-                }
-                else if (stat.isDirectory()) {
-                    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);
-            }
-        });
+        router.use(`/${route}`, childRouter);
+        console.log('[BINHEND] Mapping routes from:', path);
     });
 }
-function APIs(rootpath) {
-    if (rootpath == undefined) return;
+function loadRoutes(dirPath) {
+    if (isUndefined(dirPath)) {
+        console.error(`[BINHEND] Error missing directory path: ${dirPath}.\n`);
+        throw new Error('Require directory path to load routes.');
+    }
     const router = express.Router();
     router.use(express.urlencoded({ extended: false }));
     router.use(express.json());
-    router.use(parseAuthToken);
-    setTimeout(function() {
-        mapAPIs(rootpath, router);
-    });
-    return router;
-}
+    router.use(parseBasicAuthToken);
-function parseAuthToken(request, response, next) {
-    var authString = request.headers['authorization'];
-    if (typeof authString === 'string' && authString.startsWith('Bearer ')) {
-        request.token = authString.split('Bearer ')[1];
+    try {
+        mapRoutes(router, resolve(dirPath));
     }
-    next();
+    catch (error) {
+        console.error(`[BINHEND] Error mapping routes from: ${resolve(dirPath)}.\n` + error);
+        throw error;
+    }
+    server.use(router);
+    return router;
 }
-function Router(module) {
+function Router(moduleInstance) {
     var router = express.Router();
     var output = { router };
     for (var key in router) {
-        if (router[key] instanceof Function) {
-            output[key] = router[key].bind(router);
-        }
+        let method = router[key]; // use 'let' to not lose reference, 'var' will override 'method' reference in this function scope => error on run-time
+        if (!isFunction(method)) continue;
+        output[key] = function() {
+            let args = [];
+            Array.from(arguments).forEach((arg) => {
+                if (!isFunction(arg)) return args.push(arg);
+                args.push(createErrorHandler(router, arg));
+            });
+            return method.apply(router, args);
+        };
     }
-    if (module instanceof Module) {
-        module.exports = router;
+    if (moduleInstance instanceof Module) {
+        moduleInstance.exports = router;
     }
     output.trycatch = trycatch;
@@ -80,20 +85,40 @@ function Router(module) {
     return output;
 }
-function trycatch(callback, onerror) {
+function createErrorHandler(router, callback) {
+    if (callback.isAppliedTryCatch) return callback;
     return async function(request, response, next) {
         try {
-            return await callback(request, response, next);
+            return await callback.apply(router, arguments);
         }
         catch (error) {
-            if (onerror instanceof Function) return onerror(error);
-            var message = error instanceof HttpError && error.message || 'Internal Server Error';
-            response.status(error.httpCode || 500).json({ error: message });
-            if (onerror === true) console.error('\x1b[31m', error);
+            if (arguments.length < 3 || !(response instanceof ServerResponse)) throw error;
+            responseErrorByDefault(error, response, next);
         }
     }
 }
+function trycatch(callback) {
+    var trycatchCallback = async function(request, response, next) {
+        try {
+            return await callback(request, response, next);
+        }
+        catch (error) {
+            responseErrorByDefault(error, response, next);
+        }
+    };
+    trycatchCallback.isAppliedTryCatch = true;
+    return trycatchCallback;
+}
+function responseErrorByDefault(error, response, next) {
+    if (!(error instanceof HttpError)) return next(error);
+    response.status(error.httpCode || 500).json({ error: error.message || 'Internal Server Error' });
+}
 class HttpError extends Error {
     constructor(httpCode, message) {
         super(message);
@@ -103,5 +128,6 @@ class HttpError extends Error {
 }
 module.exports = {
-    APIs, Router, HttpError
+    loadRoutes, mapRoutes,
+    trycatch, HttpError, Router
 };

package/src/binh.js CHANGED Viewed

@@ -1,63 +1,23 @@
-const fs = require('fs');
-const path = require('path');
-const Crypto = require('./cryptography');
-const { HTTPS } = require('./https');
+const typeOf = require('./utils/typeOf');
+const security = require('./security');
+const { server } = require('./server');
+const { loadRoutes, mapRoutes, trycatch, HttpError, Router } = require('./api');
 const { ConfigLoader } = require('./configuration');
+const { WebBuilder } = require('./web');
+const { binh } = require('./web/component.method');
+const { HttpCodes } = require('./utils/httpCodes');
+const { HTTPS } = require('./https');
-const { ServerApp } = require('./binh.server.app');
-const { ServerConfig } = require('./binh.server.config');
-const { WebBuilder } = require('./binh.web.builder');
-function Binh() {
-    var rootpath = require.main.path;
-    this.id = function(id) {
-        binh.id = id == undefined ? Crypto.randomUUID() : JSON.stringify(id);
-        return this;
-    };
-    this.global = function(name, target) {
-        global[name] = target;
-        return this;
-    };
-    this.rootpath = function(path) {
-        rootpath = typeof path === 'string' ? path : require.main.path;
-        return this;
-    };
-    this.getRootpath = function() {
-        return rootpath;
-    };
-    this.remove = function(path, callbackError) {
-        try {
-            fs.rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 });
-        }
-        catch (error) {
-            callbackError(error);
-        }
-        return this;
-    };
-    function binh(modulePath) {
-        return modulePath == undefined ? module.exports : require(path.join(rootpath, modulePath));
-    };
-    binh.path = function(anyPath = '') {
-        return path.join(rootpath, anyPath);
-    };
-    ServerApp(binh, this, ServerConfig(binh, this));
-    WebBuilder(binh, this);
-    global.binh = binh;
-    global.config = binh.config;
-}
-const { HttpError } = require('./api');
-const { HttpCodes } = require('./enum.httpCodes');
-module.exports = { Binh, HTTPS, ConfigLoader, Crypto, HttpError, HttpCodes };
+module.exports = {
+    config: {},
+    typeOf,
+    security,
+    server,
+    loadRoutes, mapRoutes, trycatch, HttpError, Router,
+    ConfigLoader,
+    WebBuilder,
+    binh,
+    HttpCodes,
+    HTTPS
+};

package/src/configuration.js CHANGED Viewed

@@ -1,131 +1,68 @@
-'use strict';
+const fs = require('fs');
+const path = require('path');
+const { isEmptyArray, isArray, isObject } = require('./utils/typeOf');
-var fs = require('fs');
-function ConfigLoader(config_object) {
-    const configs = config_object || {};
+function ConfigLoader(configObject, { module } = {}) {
+    const configs = configObject || {};
+    const rootPath = module?.path || require.main.path;
-    var deferred = [];
-    this.getConfigs = function() {
+    this.getConfigs = () => {
         return configs;
     };
     function getConfigPosition(key) {
-        return key == undefined ? configs : (configs[key] = configs[key] || {});
-    };
-    this.filter = function(method, input, filters, key) {
-        if (!(filters instanceof Array) || !filters.length) return {};
-        if (method && method.fetch instanceof Function) {
-            var filtered = filter(method.fetch(input), filters);
-            return this.object(filtered, key);
-        }
-        if (method && method.is_promise === true) {
-            var _this = this;
-            var promise = new Promise(callback).then(function(loaded_config) {
-                var filtered = filter(loaded_config, filters);
-                _this.object(filtered, key);
-            });
-            deferred.push(promise);
-            return this;
-        }
-        return filter(input, filters);
+        return key == undefined ? configs : configs[key] || (configs[key] = {});
     };
-    this.object = function(object, key) {
+    this.object = (object, { key, filter: filters } = {}) => {
         try {
             var config = getConfigPosition(key);
-            Object.assign(config, JSON.parse(JSON.stringify({ ...object })));
+            var filtered = isArray(filters) ? filter(object, filters) : object;
+            Object.assign(config, filtered);
         }
         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);
-    };
-    this.promise = function(callback, key) {
-        var _this = this;
-        var promise = new Promise(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.cli = (options) => {
+        return this.object(cli(), options);
     };
-    this.target = function(config_object) {
-        return new ConfigLoader(config_object);
+    this.json = (filepath, options) => {
+        var filePath = path.resolve(rootPath, filepath);
+        return this.object(json(filePath), options);
     };
-    for (var key in this) {
-        var method = this[key];
-        if (method instanceof Function) {
-            this[key] = method.bind(this);
-        }
-    }
-    this.json.fetch = json;
-    this.cli.fetch = cli;
-    this.file.fetch = file;
-    this.object.fetch = function(object) { return object; };
-    this.promise.is_promise = true;
+    this.file = (filepath, options) => {
+        var filePath = path.resolve(rootPath, filepath);
+        return this.object(file(filePath, options?.encoding), options);
+    };
 }
-function filter(object, filters) {
-    if (!(object instanceof Object) || !(filters instanceof Array)) return {};
+function filter(object, filterKeys) {
+    if (!isObject(object) || isEmptyArray(filterKeys)) return {};
-    var filtered = {}, length = filters.length;
+    var filtered = {};
-    for (var i = 0; i < length; i++) {
-        var field = filters[i];
+    filterKeys.forEach((field) => {
         if (object.hasOwnProperty(field)) {
             filtered[field] = object[field];
         }
-    }
+    });
     return filtered;
 };
-function json(filepath) {
+function json(path) {
     try {
-        return require.main.require(filepath);
+        return require.main.require(path);
     }
     catch(e) {
-        return failed(e, filepath);
+        return failed(e, path);
     }
 }
@@ -180,17 +117,10 @@ function parseKeyValue(string) {
     return { key, value, success: true };
 }
-function config(config_object) {
-    return new ConfigLoader(config_object);
-}
 function failed(error, source) {
     console.log(`[BINHEND] Failed loading config from: ${source}`);
     console.log('[BINHEND] Details:', error);
     return {};
 };
-module.exports = {
-    ConfigLoader, config,
-    json, cli, file
-};
+module.exports = { ConfigLoader };