binhend 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binhend",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "",
   "main": "index.js",
   "author": "Nguyen Duc Binh",

package/src/api/HttpError.js

@@ -0,0 +1,10 @@
+
+class HttpError extends Error {
+    constructor(httpCode, message) {
+        super(message);
+        this.name = 'HttpError';
+        this.httpCode = httpCode;
+    }
+}
+
+module.exports = HttpError;

package/src/api/Router.js

@@ -0,0 +1,55 @@
+
+const { Module } = require('module');
+const { ServerResponse } = require('http');
+const { isFunction } = require('../utils/typeOf');
+const responseErrorByDefault = require('./responseErrorByDefault');
+const trycatch = require('./trycatch');
+const express = require('express');
+
+
+function Router(moduleInstance) {
+    var router = express.Router();
+
+    var output = { router };
+
+    for (var key in 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 (moduleInstance instanceof Module) {
+        moduleInstance.exports = router;
+    }
+
+    output.trycatch = trycatch;
+
+    return output;
+}
+
+function createErrorHandler(router, callback) {
+    if (callback.isAppliedTryCatch) return callback;
+
+    return async function(request, response, next) {
+        try {
+            return await callback.apply(router, arguments);
+        }
+        catch (error) {
+            if (arguments.length < 3 || !(response instanceof ServerResponse)) throw error;
+            responseErrorByDefault(error, response, next);
+        }
+    }
+}
+
+module.exports = Router;

package/src/api/index.js

@@ -0,0 +1,9 @@
+
+const { loadRouter, loadRoutes, mapRoutes } = require('./loader');
+const HttpError = require('./HttpError');
+const Router = require('./Router');
+const trycatch = require('./trycatch');
+
+module.exports = {
+    loadRouter, loadRoutes, mapRoutes, trycatch, Router, HttpError
+};

package/src/api/loader.js

@@ -0,0 +1,57 @@
+const { readdirSync, statSync } = require('fs');
+const { join, parse, resolve } = require('path');
+const { isUndefined } = require('../utils/typeOf');
+const { server } = require('../server');
+const express = require('express');
+const parseBasicAuthToken = require('../middleware/parseBasicAuthToken');
+
+
+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 = express.Router();
+            mapRoutes(childRouter, path);
+        }
+
+        router.use(`/${route}`, childRouter);
+        console.log('[BINHEND] Mapping routes from:', path);
+    });
+}
+
+function loadRouter(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(parseBasicAuthToken);
+
+    try {
+        mapRoutes(router, resolve(dirPath));
+    }
+    catch (error) {
+        console.error(`[BINHEND] Error mapping routes from: ${resolve(dirPath)}.\n` + error);
+        throw error;
+    }
+
+    return router;
+}
+
+function loadRoutes(dirPath) {
+    const router = loadRouter(dirPath);
+    server.use(router);
+}
+
+module.exports = { loadRouter, loadRoutes, mapRoutes };

package/src/api/responseErrorByDefault.js

@@ -0,0 +1,9 @@
+
+const HttpError = require('./HttpError');
+
+function responseErrorByDefault(error, response, next) {
+    if (!(error instanceof HttpError)) return next(error);
+    response.status(error.httpCode || 500).json({ error: error.message || 'Internal Server Error' });
+}
+
+module.exports = responseErrorByDefault;

package/src/api/trycatch.js

@@ -0,0 +1,21 @@
+
+const responseErrorByDefault = require('./responseErrorByDefault');
+
+function trycatch(callback) {
+    if (callback?.isAppliedTryCatch) return 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;
+}
+
+module.exports = trycatch;

package/src/binh.js

@@ -2,7 +2,7 @@
 const typeOf = require('./utils/typeOf');
 const security = require('./security');
 const { server } = require('./server');
-const { loadRoutes, mapRoutes, trycatch, HttpError, Router } = require('./api');
+const { loadRouter, loadRoutes, mapRoutes, trycatch, Router, HttpError } = require('./api');
 const { ConfigLoader } = require('./configuration');
 const { WebBuilder } = require('./web');
 const { binh } = require('./web/component.method');
@@ -14,7 +14,7 @@ module.exports = {
     typeOf,
     security,
     server,
-    loadRoutes, mapRoutes, trycatch, HttpError, Router,
+    loadRouter, loadRoutes, mapRoutes, trycatch, Router, HttpError,
     ConfigLoader,
     WebBuilder,
     binh,