binhend 2.1.14 → 2.1.16

package/demo.js

@@ -0,0 +1,45 @@
+
+const { HttpCodes, ConfigLoader, WebBuilder, HttpError, validation } = require('./index');
+
+// HttpCodes.ACCEPTED;
+
+// new ConfigLoader({}).cli;
+
+// const builder = new WebBuilder('src', { output: 'build/bundle' });
+
+// builder.bundle();
+
+// throw new HttpError(HttpCodes.BAD_REQUEST, '[BINHEND][VALIDATION] Must be a string.');
+// throw new HttpError(HttpCodes.BAD_REQUEST, '[BINHEND][VALIDATION] MUST BE A STRING.');
+// var typeName = `array`;
+// throw new HttpError(HttpCodes.BAD_REQUEST, `Invalid input: value not passed custom validator.`);
+// throw new HttpError(HttpCodes.BAD_REQUEST, `Invalid input: unknown reason.`);
+// throw new HttpError(HttpCodes.BAD_REQUEST, `Invalid input: value must be type of \`${typeName}\`.`);
+// throw new HttpError(HttpCodes.BAD_REQUEST, `Invalid input: Field "title" must be type of \`${typeName}\`.`);
+
+// validation.String('a', {});
+
+validation.String('a');
+// validation.String(null);
+// validation.String(1, { name: 'myNum', message: 'Require string for this field' });
+
+// validation.Validator('this is me', (input) => {
+//     if (!input.startsWith('It')) validation.throwError(`"title" must start with 'it' or 'It'`)
+//     return input.length < 5;
+// }, { message: '"title" must not exceed max length of 5' })
+
+
+validation.NotNull(1);
+// validation.NotNullish(null, { required: true, default: null });
+// validation.String(null, { required: true, default: 1 });
+
+validation.DateLike('2022-10-29a', { default: new Date().getTime() });
+validation.Date(new Date());
+
+function Abc(a) {
+    this.a = a;
+}
+
+console.log(JSON.stringify(new Abc(123)));
+
+validation.Object(new Abc(123));

package/index.js

@@ -6,4 +6,48 @@
 
 'use strict';
 
-module.exports = require('./src/binh');
+/** SERVER - Backend */
+const { server } = require('./src/server');
+const { ConfigLoader, config } = require('./src/configuration');
+const { HTTPS } = require('./src/https');
+
+const HttpError = require('./src/api/HttpError');
+const HttpCodes = require('./src/api/HttpCodes');
+
+const Router = require('./src/api/Router');
+const { routes, loadRoutes, buildRoutes, mapRoutes } = require('./src/api/routes');
+const trycatch = require('./src/api/trycatch');
+
+const cors = require('./src/middleware/cors');
+
+const createCSD = require('./src/csd');
+const security = require('./src/security');
+const types = require('./src/utils/types');
+const validation = require('./src/utils/validation');
+const Bromise = require('./src/utils/Bromise.js');
+
+/** CLIENT - Frontend */
+const { WebBuilder } = require('./src/web');
+const { binh } = require('./src/web/component.method');
+
+// Run scripts
+require('./src/supportRequireAliasPath');
+
+module.exports = {
+    server,
+    ConfigLoader, config,
+    HTTPS,
+    HttpError,
+    HttpCodes,
+    Router,
+    routes, buildRoutes, loadRoutes, mapRoutes,
+    trycatch,
+    cors,
+    createCSD,
+    security,
+    types,
+    validation,
+    Bromise,
+    WebBuilder,
+    binh
+};

package/jsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "node",
+        "target": "ES2017",
+        "checkJs": true,
+        "allowJs": true,
+        "noEmit": true,
+
+        "baseUrl": "./src",
+        "paths": {
+            "@/*": [
+                "./*"
+            ],
+            "@test/*": [
+                "../test/*"
+            ]
+        }
+    }
+}

package/package.json

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

package/src/{utils/httpCodes.js → api/HttpCodes.js}

@@ -1,4 +1,4 @@
-const HttpCodes = {
+module.exports =  {
     CONTINUE: 100,
     SWITCHING_PROTOCOLS: 101,
     PROCESSING: 102,
@@ -63,7 +63,3 @@ const HttpCodes = {
     NOT_EXTENDED: 510,
     NETWORK_AUTHENTICATION_REQUIRED: 511,
 };
-
-module.exports = {
-    HttpCodes
-};

package/src/api/Router.js

@@ -1,6 +1,6 @@
 
 const { ServerResponse } = require('http');
-const { isFunction } = require('../utils/typeOf');
+const { isFunction } = require('../utils/types');
 const responseErrorByDefault = require('./responseErrorByDefault');
 const trycatch = require('./trycatch');
 const express = require('express');
@@ -35,6 +35,11 @@ function Router(moduleInstance) {
     return output;
 }
 
+/**
+ * @param {any} router
+ * @param {Function & { isAppliedTryCatch?: boolean }} callback
+ * @returns {Function}
+ */
 function createErrorHandler(router, callback) {
     if (callback.isAppliedTryCatch) return callback;
 

package/src/api/routes.js

@@ -0,0 +1,83 @@
+const { readdir, stat } = require('fs/promises');
+const { join, parse, resolve } = require('path');
+const { isUndefined } = require('../utils/types');
+const { server } = require('../server');
+const cors = require('../middleware/cors');
+const express = require('express');
+const parseBasicAuthToken = require('../middleware/parseBasicAuthToken');
+
+/**
+ * Maps routes recursively from a directory
+ * @param {express.Router} router - Express router
+ * @param {string} dirpath - Directory path to scan
+ */
+async function mapRoutes(router, dirpath) {
+    try {
+        const files = await readdir(dirpath);
+        
+        for (const direntName of files) {
+            const path = join(dirpath, direntName);
+            const route = parse(direntName).name;
+            const stats = await stat(path);
+            let childRouter;
+            
+            if (stats.isFile()) {
+                childRouter = require(path);
+            } else if (stats.isDirectory()) {
+                childRouter = express.Router();
+                await mapRoutes(childRouter, path);
+            }
+            
+            router.use(`/${route}`, childRouter);
+            console.log('[BINHEND] Mapping routes from:', path);
+        }
+    } catch (error) {
+        console.error(`[BINHEND] Error in mapping routes for directory: ${dirpath}`, error);
+        throw error;
+    }
+}
+
+/**
+ * Loads router with routes from the specified directory
+ * @param {string} dirPath - Directory path to load routes from
+ * @returns {Promise<express.Router>} router - Configured Express router
+ */
+async function buildRoutes(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 {
+        await mapRoutes(router, resolve(dirPath));
+    } catch (error) {
+        console.error(`[BINHEND] Error mapping routes from: ${resolve(dirPath)}.\n` + error);
+        throw error;
+    }
+    
+    return router;
+}
+
+/**
+ * Loads routes into the server with CORS options
+ * @param {string} dirPath - Directory path to load routes from
+ * @param {Object} corsOptions - CORS configuration options
+ */
+async function loadRoutes(dirPath, corsOptions) {
+    server.use(cors(corsOptions));
+    const router = await buildRoutes(dirPath);
+    server.use(router);
+}
+
+const routes = {
+    load: loadRoutes,
+    build: buildRoutes,
+    map: mapRoutes
+};
+
+module.exports = { routes, loadRoutes, buildRoutes, mapRoutes };

package/src/configuration.js

@@ -1,8 +1,8 @@
 const fs = require('fs');
 const path = require('path');
-const { isEmptyArray, isArray, isObject } = require('./utils/typeOf');
-
+const { isEmptyArray, isArray, isObject } = require('./utils/types');
 
+// @ts-ignore
 function ConfigLoader(configObject, { module } = {}) {
     const configs = configObject || {};
     const rootPath = module?.path || require.main.path;
@@ -15,6 +15,7 @@ function ConfigLoader(configObject, { module } = {}) {
         return key == undefined ? configs : configs[key] || (configs[key] = {});
     };
 
+    // @ts-ignore
     this.object = (object, { key, filter: filters } = {}) => {
         try {
             var config = getConfigPosition(key);
@@ -74,7 +75,9 @@ function file(path, encoding) {
     encoding = encoding || 'utf8';
     try {
         var source = fs.readFileSync(path, { encoding });
+        // @ts-ignore
         source = source.replace(/\r\n?/mg, '\n');
+        // @ts-ignore
         var lines = source.split('\n');
 
         return processKeyValueStrings(lines);

package/src/csd/controller.js

@@ -1,6 +1,9 @@
-const { trycatch, HttpError } = require('../api');
-const { isEmptyObject, isString } = require('../utils/typeOf');
-const { OK, CREATED, BAD_REQUEST } = require('../utils/httpCodes').HttpCodes;
+
+const { isEmptyObject, isString } = require('../utils/types');
+const trycatch = require('../api/trycatch');
+const HttpError = require('../api/HttpError');
+
+const { OK, CREATED, BAD_REQUEST } = require('../api/HttpCodes');
 
 const
 ERROR_MISSING_ID = 'Missing required parameter: id',

package/src/https.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const https = require('https');
 

package/src/{cors.js → middleware/cors.js}

@@ -1,5 +1,5 @@
 
-const { isArray, mustArray, mustNumber } = require('./utils/typeOf');
+const { isArray, mustArray, mustNumber } = require('../utils/types');
 
 const defaultOptions = {
     origins: [],

package/src/middleware/parseBasicAuthToken.js

@@ -1,4 +1,4 @@
-const { isString } = require('../utils/typeOf');
+const { isString } = require('../utils/types');
 
 module.exports = (request, response, next) => {
     var authString = request.headers['authorization'];

package/src/security.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const crypto = require('crypto');
 const algorithm = 'aes-256-cbc';

package/src/{alias.js → supportRequireAliasPath.js}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const path = require('path');
 const DefaultModule = require('module');
@@ -37,7 +38,6 @@ for (const alias in paths) {
 const originalResolveFilename = Module._resolveFilename;
 
 Module._resolveFilename = function (request, parent, isMain, options) {
-    // console.log(request, parent, isMain, options);
     for (const alias in aliasMap) {
         if (!request.startsWith(alias)) continue;
         // Loop through the array of resolved paths for this alias

package/src/utils/Bromise.js

@@ -0,0 +1,18 @@
+
+function Bromise() {
+    var resolve, reject, promise = new Promise((res, rej) => (resolve = res) && (reject = rej));
+
+    this.promise = promise;
+
+    this.resolve = (value) => {
+        resolve(value);
+        return promise;
+    };
+
+    this.reject = (error) => {
+        reject(error);
+        return promise;
+    };
+}
+
+module.exports = Bromise;

package/src/utils/{typeOf.js → types.js}

@@ -45,6 +45,15 @@ function mustNumber(input, defaultValue) {
     return isNumber(input) ? input : isNumber(defaultValue) ? defaultValue : 0;
 }
 
+function isDate(input) {
+    return typeOf(input) === 'Date' && !isNaN(input.getTime());
+}
+
+function isDateLike(value) {
+    const date = new Date(value);
+    return !isNaN(date.getTime());
+}
+
 function isBigInt(input) {
     return typeof input === 'bigint';
 }
@@ -69,7 +78,11 @@ function isNullOrUndefined(input) {
     return isNull(input) || isUndefined(input);
 }
 
-module.exports = Object.assign(typeOf, {
+function isNullish(input) {
+    return input == null;
+}
+
+module.exports = {
     typeOf,
     isObject,
     isEmptyObject,
@@ -80,6 +93,7 @@ module.exports = Object.assign(typeOf, {
     isNull,
     isUndefined,
     isNullOrUndefined,
+    isNullish,
     isBoolean,
     isNumber,
     mustNumber,
@@ -87,5 +101,7 @@ module.exports = Object.assign(typeOf, {
     isEmptyString,
     mustString,
     isSymbol,
-    isBigInt
-});
+    isBigInt,
+    isDate,
+    isDateLike
+};

package/src/utils/validation.js

@@ -0,0 +1,233 @@
+const HttpError = require('../api/HttpError');
+const HttpCodes = require('../api/HttpCodes');
+const types = require('./types');
+
+/**
+ * @typedef {Object} Options
+ * @property {string=} message - Any custom error message
+ * @property {string=} type - Expected type name of value, e.g. string, number, array, etc.
+ * @property {string=} name - The variable/property name holding value
+ * @property {boolean=} required - The variable/property name holding value
+ * @property {*=} default - The variable/property name holding value
+ */
+
+/**
+ * Throw error by default for invalid input.
+ * A `HttpError` is thrown for `router` sending response to client.
+ *
+ * @param {string=} message - Optional error message.
+ * @throws {HttpError}
+ */
+function throwError(message) {
+    message = types.isString(message) ? message : `unknown reason`;
+    throw new HttpError(HttpCodes.BAD_REQUEST, `Invalid input: ${message}.`);
+}
+
+/**
+ * Throw a type error with formatted message.
+ * 
+ * @param {string=} typeName - The expected type name
+ * @param {string=} variableName - The name of the variable/property
+ * @throws {HttpError}
+ */
+function throwTypeError(typeName, variableName) {
+    typeName = types.isString(typeName) ? typeName : '?';
+    variableName = types.isString(variableName) ? `"${variableName}"` : `value`;
+    throwError(`${variableName} must be type of \`${typeName}\``);
+}
+
+/**
+ * Throw a validator error with formatted message.
+ * 
+ * @param {string=} variableName - The name of the variable/property
+ * @throws {HttpError}
+ */
+function throwValidatorError(variableName) {
+    variableName = types.isString(variableName) ? `"${variableName}"` : `value`;
+    throwError(`${variableName} not passed custom validator`);
+}
+
+/**
+ * Validate an input being string
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {string} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function String(input, options = {}) {
+    return Validator(input, types.isString, { ...options, type: 'string' });
+}
+
+/**
+ * Validate an input being number
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {number} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Number(input, options = {}) {
+    return Validator(input, types.isNumber, { ...options, type: 'number' });
+}
+
+/**
+ * Validate an input being boolean
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {boolean} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Boolean(input, options = {}) {
+    return Validator(input, types.isBoolean, { ...options, type: 'boolean' });
+}
+
+/**
+ * Validate an input being an array
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {Array} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Array(input, options = {}) {
+    return Validator(input, types.isArray, { ...options, type: 'array' });
+}
+
+/**
+ * Validate an input being an object (non-array)
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {Object} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Object(input, options = {}) {
+    return Validator(input, types.isObject, { ...options, type: 'object' });
+}
+
+/**
+ * Validate an input being a function
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {Function} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Function(input, options = {}) {
+    return Validator(input, types.isFunction, { ...options, type: 'function' });
+}
+
+/**
+ * Validate an input being a date
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {Date} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Date(input, options = {}) {
+    return Validator(input, types.isDate, { ...options, type: 'date' });
+}
+
+/**
+ * Validate an input being a date format
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function DateLike(input, options = {}) {
+    return Validator(input, types.isDateLike, { ...options, type: 'date-like' });
+}
+
+/**
+ * Validate an input being defined (not undefined)
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Defined(input, options = {}) {
+    return Validator(input, (input) => !types.isUndefined(input), { ...options, type: 'defined' });
+}
+
+/**
+ * Validate an input not being null (but accept undefined)
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function NotNull(input, options = {}) {
+    return Validator(input, (input) => !types.isNull(input), { ...options, type: 'not null', required: true });
+}
+
+/**
+ * Validate an input not being null or undefined
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function NotNullish(input, options = {}) {
+    return Validator(input, (input) => !types.isNullish(input), { ...options, type: 'not nullish', required: true });
+}
+
+/**
+ * Generic validator that accepts a validation function
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Function} validate - Validation function that returns boolean
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Validator(input, validate, options = {}) {
+    if (validate(input)) {
+        return input;
+    }
+
+    // use default value (options.default - must also be valid) if has, when input is invalid
+    if (options.hasOwnProperty('default') && validate(options.default)) {
+        return options.default;
+    }
+
+    // allow null or undefined by default, set `options.required=true` for not allowing
+    if (!options.required && types.isNullish(input)) {
+        return input;
+    }
+
+    var { message, type, name } = options;
+
+    if (message) {
+        throwError(message);
+    }
+    else if (type) {
+        throwTypeError(type, name);
+    }
+    else {
+        throwValidatorError(name)
+    }
+}
+
+module.exports = {
+    String,
+    Number,
+    Boolean,
+    Array,
+    Object,
+    Function,
+    Date,
+    DateLike,
+    Defined,
+    NotNull,
+    NotNullish,
+    Validator,
+    throwError
+};

package/src/web/component.build.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const path = require('path');
 const { scanNestedFiles, cloneFileIfNew, writeToFileIfNew, makeFullDirPath } = require('./component.file');

package/src/web/component.file.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const { readdir, statSync, existsSync, copyFile, writeFile, writeFileSync, readFileSync, mkdirSync, rm } = require('fs');
 const { join, dirname } = require('path');

package/src/web/component.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 
 const { readdir, statSync, writeFile, existsSync, mkdirSync, copyFile, readFileSync } = require('fs');
 const { join, dirname, parse } = require('path');

package/src/web/component.method.js

@@ -1,9 +1,10 @@
+// @ts-nocheck
 
 const path = require('path');
 const fs = require('fs');
 const UglifyCSS = require('uglifycss');
 const Component = require('./component');
-const { isString } = require('../utils/typeOf');
+const { isString } = require('../utils/types');
 
 const binh = {};
 

package/src/web/index.js

@@ -1,6 +1,7 @@
+// @ts-nocheck
 
 const path = require('path');
-const { isEmptyString, isString, mustString } = require('../utils/typeOf');
+const { isEmptyString, isString, mustString } = require('../utils/types');
 const ComponentFormat = require('./component.format');
 const ComponentBuild = require('./component.build');
 const Component = require('./component');

package/bin/templates/component/UI.js

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

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

@@ -1,26 +0,0 @@
-
-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

@@ -1,7 +0,0 @@
-
-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

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

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

@@ -1,17 +0,0 @@
-
-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/src/api/index.js

@@ -1,9 +0,0 @@
-
-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

@@ -1,59 +0,0 @@
-const { readdirSync, statSync } = require('fs');
-const { join, parse, resolve } = require('path');
-const { isUndefined } = require('../utils/typeOf');
-const { server } = require('../server');
-const cors = require('../cors');
-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, corsOptions) {
-    server.use(cors(corsOptions));
-    const router = loadRouter(dirPath);
-    server.use(router);
-}
-
-module.exports = { loadRouter, loadRoutes, mapRoutes };

package/src/binh.js

@@ -1,29 +0,0 @@
-
-const typeOf = require('./utils/typeOf');
-const security = require('./security');
-const createCSD = require('./csd');
-const cors = require('./cors');
-const { server } = require('./server');
-const { loadRouter, loadRoutes, mapRoutes, trycatch, Router, HttpError } = require('./api');
-const { ConfigLoader, config } = require('./configuration');
-const { WebBuilder } = require('./web');
-const { binh } = require('./web/component.method');
-const { HttpCodes } = require('./utils/httpCodes');
-const { HTTPS } = require('./https');
-
-// Run scripts
-require('./alias');
-
-module.exports = {
-    typeOf,
-    security,
-    createCSD,
-    cors,
-    server,
-    loadRouter, loadRoutes, mapRoutes, trycatch, Router, HttpError,
-    ConfigLoader, config,
-    WebBuilder,
-    binh,
-    HttpCodes,
-    HTTPS
-};

package/src/utils/bromise.js

@@ -1,20 +0,0 @@
-
-function Bromise() {
-    var resolve, reject, promise = new Promise((res, rej) => (resolve = res) && (reject = rej));
-
-    return {
-        promise,
-        resolve: (value) => {
-            resolve(value);
-            return promise;
-        },
-        reject: (error) => {
-            reject(error);
-            return promise;
-        }
-    };
-}
-
-module.exports = {
-    Bromise
-};