binhend 2.2.2 → 2.2.3

package/index.js

@@ -6,6 +6,51 @@
 
 'use strict';
 
+const { server, routes, Router } = require('./packages/core');
+
+const { Bromise, HttpCodes, HttpError } = require('./packages/utils');
+
+const { cors, trycatch } = require('./packages/middlewares');
+
+const { HTTPS } = require('./packages/https');
+
+const { config, ConfigLoader } = require('./packages/config');
+
+const { WebBuild, binh } = require('./packages/web');
+
+const { create: CSD, Controller: CinCSD, Service: SinCSD, DAO: DinCSD } = require('./packages/csd');
+
+const { crypto } = require('./packages/crypto');
+
+const types = require('./packages/types');
+
+const validation = require('./packages/validation');
+
+// Run scripts
+require('./packages/module-alias'); // for format: require('@/any/path')
+
 module.exports = {
-    ...require('@binhend/core'),
+    server, routes, Router,
+
+    Bromise, HttpCodes, HttpError,
+
+    cors, trycatch,
+
+    config, ConfigLoader,
+
+    HTTPS,
+
+    CSD, CinCSD, SinCSD, DinCSD, // only CSD is for usage, others for exposing methods (via IDE auto-suggestion)
+
+    crypto,
+
+    types,
+    validation,
+
+    WebBuild, binh
 };
+
+
+// module.exports = {
+//     ...require('@binhend/core'),
+// };

package/package.json

@@ -1,31 +1,29 @@
 {
-  "name": "binhend",
-  "version": "2.2.2",
-  "description": "",
-  "main": "index.js",
-  "author": "Nguyen Duc Binh",
-  "license": "MIT",
-  "bin": {
-    "binhend": "./bin/index.js"
-  },
-  "workspaces": [
-    "packages/*",
-    "test"
-  ],
-  "scripts": {
-    "test": "npm run test --workspace=test",
-    "test:coverage": "npm run test:coverage --workspace=test",
-    "test:jest": "jest --config=test/jest.config.js",
-
-    "example-api": "node example_api PORT=5555",
-    "example-webcomp": "node example_webcomp",
-    "example-web2": "node example_web2"
-  },
-  "dependencies": {
-    "@binhend/core": "^1.0.3"
-  },
-  "engines": {
-    "node": ">=20.18.0",
-    "npm": ">=10.8.2"
-  }
+    "name": "binhend",
+    "version": "2.2.3",
+    "description": "",
+    "main": "index.js",
+    "author": "Nguyen Duc Binh",
+    "license": "MIT",
+    "bin": {
+        "binhend": "./bin/index.js"
+    },
+    "workspaces": [
+        "packages/*",
+        "test"
+    ],
+    "scripts": {
+        "test": "npm run test --workspace=test",
+        "test:coverage": "npm run test:coverage --workspace=test",
+        "test:jest": "jest --config=test/jest.config.js",
+        "example-api": "node example_api PORT=5555",
+        "example-webcomp": "node example_webcomp",
+        "example-web2": "node example_web2"
+    },
+    "dependencies": {
+    },
+    "engines": {
+        "node": ">=20.18.0",
+        "npm": ">=10.8.2"
+    }
 }

package/packages/config/index.js

@@ -0,0 +1,145 @@
+
+const fs = require('fs');
+const path = require('path');
+const { isEmptyArray, isArray, isObject, mustString, isNullish, isString } = require('@binhend/types');
+
+// @ts-ignore
+function ConfigLoader(configObject, { rootPath } = {}) {
+    const configs = configObject || {};
+
+    rootPath = mustString(rootPath) || require.main.path;
+
+    function getConfigPosition(key) {
+        return key == undefined ? configs : configs[key] || (configs[key] = {});
+    };
+
+    // @ts-ignore
+    this.object = (object, { key, filter: filters, overwrite, use } = {}) => {
+        let config = getConfigPosition(key);
+        let filtered = isArray(filters) ? filter(object, filters) : object;
+
+        remap(object, use);
+        assign(config, filtered, overwrite);
+
+        return this;
+    };
+
+    this.cli = (options) => {
+        return this.object(cli(), options);
+    };
+
+    this.file = (filepath, options) => {
+        let filePath = path.resolve(rootPath, filepath);
+        return this.object(file(filePath, options?.encoding), options);
+    };
+}
+
+ConfigLoader.cli = cli;
+ConfigLoader.file = file;
+ConfigLoader.require = require.main.require;
+
+function filter(object, filterKeys) {
+    if (!isObject(object) || isEmptyArray(filterKeys)) return {};
+
+    var filtered = {};
+
+    filterKeys.forEach((field) => {
+        if (object.hasOwnProperty(field)) {
+            filtered[field] = object[field];
+        }
+    });
+
+    return filtered;
+};
+
+function assign(config, filtered, overwrite) {
+    if (overwrite !== false) {
+        Object.assign(config, filtered);
+    }
+    else for (var key in filtered) {
+        if (isNullish(config[key])) {
+            config[key] = filtered[key];
+        }
+    }
+    return config;
+};
+
+function remap(object, use) {
+    if (!isString(use)) return object;
+
+    for (var key in object) {
+        const value = object[key];
+        const hasValue = isObject(value) && value.hasOwnProperty(use);
+        if (hasValue) object[key] = value[use];
+        // else if value is not an object or has no "env" key, then the desired value is itself => no new assignment
+    }
+
+    return object;
+};
+
+function cli() {
+    return processKeyValueStrings(process.argv);
+}
+
+function file(filepath, encoding) {
+    encoding = encoding || 'utf8';
+
+    try {
+        var fileExtension = path.parse(filepath).ext;
+
+        switch (fileExtension) {
+            case '.js':
+            case '.json':
+                return ConfigLoader.require(filepath);
+
+            default:
+                var source = fs.readFileSync(filepath, { encoding });
+                // @ts-ignore
+                source = source.replace(/\r\n?/mg, '\n');
+                // @ts-ignore
+                var lines = source.split('\n');
+
+                return processKeyValueStrings(lines);
+        }
+    }
+    catch (error) {
+        console.log(`[BINHEND] Failed loading config from: ${filepath}`);
+        console.log('[BINHEND] Details:', error);
+        return {};
+    }
+}
+
+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 };
+}
+
+module.exports = { ConfigLoader, config: {} };

package/packages/config/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "@binhend/config",
+    "version": "1.0.1",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/types": "^1.0.0"
+    }
+}

package/{src2 → packages/config/src}/configuration.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { isEmptyArray, isArray, isObject, mustString, isNullish, isString } = require('./utils/types');
+const { isEmptyArray, isArray, isObject, mustString, isNullish, isString } = require('@binhend/types');
 
 // @ts-ignore
 function ConfigLoader(configObject, { rootPath } = {}) {

package/packages/core/index.js

@@ -0,0 +1,33 @@
+
+const utils = require('@binhend/utils');
+const middlewares = require('@binhend/middlewares');
+const { config, ConfigLoader } = require('@binhend/config');
+const { WebBuild, binh } = require('@binhend/web');
+
+// Run scripts
+require('@binhend/module-alias'); // for format: require('@/any/path')
+
+module.exports = {
+    server: require('./src/server'),
+    Router: require('./src/Router'),
+    routes: require('./src/routes').routes,
+
+    cors: middlewares.cors,
+    trycatch: middlewares.trycatch,
+
+    config, ConfigLoader,
+
+    HTTPS: require('@binhend/https').HTTPS,
+    HttpError: utils.HttpError,
+    HttpCodes: utils.HttpCodes,
+    Bromise: utils.Bromise,
+
+    CSD: require('@binhend/csd'),
+
+    crypto: require('@binhend/crypto'),
+
+    types: require('@binhend/types'),
+    validation: require('@binhend/validation'),
+
+    WebBuild, binh
+};

package/packages/core/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@binhend/core",
+    "version": "1.0.3",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "express": "^4.17.1",
+
+        "@binhend/config": "^1.0.0",
+        "@binhend/https": "^1.0.0",
+        "@binhend/utils": "^1.0.1",
+        "@binhend/middlewares": "^1.0.1",
+        "@binhend/csd": "^1.0.2",
+        "@binhend/crypto": "^1.0.0",
+        "@binhend/types": "^1.0.0",
+        "@binhend/validation": "^1.0.0",
+        "@binhend/web": "^1.0.0",
+
+        "@binhend/module-alias": "^1.0.0"
+    }
+}

package/{src2/api → packages/core/src}/Router.js

@@ -1,8 +1,8 @@
 
 const { ServerResponse } = require('http');
-const { isFunction } = require('../utils/types');
-const responseErrorByDefault = require('./responseErrorByDefault');
-const trycatch = require('./trycatch');
+const { isFunction } = require('@binhend/types');
+const { defaultErrorRepsonse } = require('@binhend/utils');
+const { trycatch } = require('@binhend/middlewares');
 const express = require('express');
 
 
@@ -16,7 +16,7 @@ function Router(moduleInstance) {
 
         if (!isFunction(method)) continue;
 
-        output[key] = function() {
+        output[key] = function () {
             let args = [];
 
             Array.from(arguments).forEach((arg) => {
@@ -43,13 +43,13 @@ function Router(moduleInstance) {
 function createErrorHandler(router, callback) {
     if (callback.isAppliedTryCatch) return callback;
 
-    return async function(request, response, next) {
+    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);
+            defaultErrorRepsonse(error, response, next);
         }
     }
 }

package/{src2/api → packages/core/src}/routes.js

@@ -1,11 +1,9 @@
 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 { isUndefined } = require('@binhend/types');
+const { cors, parseCookies, parseBasicAuthToken } = require('@binhend/middlewares');
+const server = require('./server');
 const express = require('express');
-const parseBasicAuthToken = require('../middleware/parseBasicAuthToken');
-const parseCookies = require('../middleware/parseCookies');
 
 /**
  * Maps routes recursively from a directory

package/{src2 → packages/core/src}/server.js

@@ -6,6 +6,4 @@ function getServer() {
     return server || (server = express());
 }
 
-module.exports = {
-    server: getServer
-};
+module.exports = getServer;

package/packages/crypto/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    crypto: require('./src/crypto'),
+};

package/packages/crypto/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "@binhend/crypto",
+    "version": "1.0.0",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT"
+}

package/packages/csd/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+    create: require('./src/csd'),
+    Controller: require('./src/controller'),
+    Service: require('./src/service'),
+    DAO: require('./src/dao'),
+};

package/packages/csd/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "@binhend/csd",
+    "version": "1.0.2",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/types": "^1.0.0",
+        "@binhend/utils": "^1.0.0",
+        "@binhend/middlewares": "^1.0.1"
+    }
+}

package/{src2/csd → packages/csd/src}/controller.js

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

package/packages/https/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ...require('./src/https'),
+};

package/packages/https/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "@binhend/https",
+    "version": "1.0.0",
+    "main": "index.js",
+    "license": "MIT",
+    "exports": {
+        ".": "./index.js"
+    }
+}

package/packages/middlewares/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+    cors: require('./src/cors'),
+    parseCookies: require('./src/parseCookies'),
+    parseBasicAuthToken: require('./src/parseBasicAuthToken'),
+    trycatch: require('./src/trycatch'),
+};

package/packages/middlewares/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "@binhend/middlewares",
+    "version": "1.0.1",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/types": "^1.0.0",
+        "@binhend/utils": "^1.0.1"
+    }
+}

package/{src2/middleware → packages/middlewares/src}/cors.js

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

package/{src2/middleware → packages/middlewares/src}/parseBasicAuthToken.js

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

package/{src2/middleware → packages/middlewares/src}/parseCookies.js

@@ -1,9 +1,11 @@
 
+const { isString } = require('@binhend/types');
+
 module.exports = (request, response, next) => {
     const header = request.headers.cookie;
     const cookies = {};
 
-    if (header) header.split(';').forEach(cookie => {
+    if (isString(header)) header.split(';').forEach(cookie => {
         const [key, ...val] = cookie.trim().split('=');
         cookies[key] = decodeURIComponent(val.join('='));
     });

package/{src2/api → packages/middlewares/src}/trycatch.js

@@ -1,5 +1,5 @@
 
-const responseErrorByDefault = require('./responseErrorByDefault');
+const { defaultErrorRepsonse } = require('@binhend/utils');
 
 function trycatch(callback) {
     if (callback?.isAppliedTryCatch) return callback;
@@ -9,7 +9,7 @@ function trycatch(callback) {
             return await callback(request, response, next);
         }
         catch (error) {
-            responseErrorByDefault(error, response, next);
+            defaultErrorRepsonse(error, response, next);
         }
     };
 

package/{src2/alias-module.js → packages/module-alias/index.js}

@@ -1,4 +1,4 @@
 
-require('./alias-cjs-loader');
+require('./src/alias-cjs-loader');
 
 // require('./alias-esm-loader'); // TODO implement this alias loader for ES Modules

package/packages/module-alias/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "@binhend/module-alias",
+    "version": "1.0.0",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/web": "^1.0.0"
+    }
+}

package/{src2 → packages/module-alias/src}/alias-cjs-loader.js

@@ -2,7 +2,7 @@
 
 const path = require('path');
 const DefaultModule = require('module');
-const { binh } = require('./web/component.method'); // TODO handle this 'binh' object again, more properly, workspaces will not recognize global 'binh' 
+const { binh } = require('@binhend/web'); // TODO handle this 'binh' object again, more properly, workspaces will not recognize global 'binh' 
 
 // Protect against improperly customized module constructors by other frameworks/packages
 const Module = module.constructor.length > 1 ? module.constructor : DefaultModule;

package/packages/types/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ...require('./src/typeCheck'),
+};

package/packages/types/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "@binhend/types",
+    "version": "1.0.0",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT"
+}

package/packages/utils/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+    Bromise: require('./src/Bromise'),
+    HttpError: require('./src/HttpError'),
+    HttpCodes: require('./src/HttpCodes'),
+    defaultErrorRepsonse: require('./src/defaultErrorRepsonse'),
+};

package/packages/utils/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "@binhend/utils",
+    "version": "1.0.1",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT"
+}

package/{src2/api → packages/utils/src}/HttpCodes.js

@@ -1,4 +1,5 @@
-module.exports =  {
+
+module.exports = {
     CONTINUE: 100,
     SWITCHING_PROTOCOLS: 101,
     PROCESSING: 102,

package/{src2/api/responseErrorByDefault.js → packages/utils/src/defaultErrorRepsonse.js}

@@ -1,9 +1,7 @@
 
 const HttpError = require('./HttpError');
 
-function responseErrorByDefault(error, response, next) {
+module.exports = function (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/packages/validation/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ...require('./src/typeValidation'),
+};

package/packages/validation/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "@binhend/validation",
+    "version": "1.0.0",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/types": "^1.0.0",
+        "@binhend/utils": "^1.0.0"
+    }
+}

package/{src2/utils/validation.js → packages/validation/src/typeValidation.js}

@@ -1,6 +1,5 @@
-const HttpError = require('../api/HttpError');
-const HttpCodes = require('../api/HttpCodes');
-const types = require('./types');
+const { HttpError, HttpCodes } = require('@binhend/utils');
+const types = require('@binhend/types');
 
 /**
  * @typedef {Object} Options

package/packages/web/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    WebBuild: require('./src/WebBuild').WebBuild,
+    binh: require('./src/component.method').binh, // { binh }
+};

package/packages/web/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "@binhend/web",
+    "version": "1.0.0",
+    "main": "index.js",
+    "exports": {
+        ".": "./index.js"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@binhend/core": "^1.0.0",
+        "@binhend/types": "^1.0.0",
+        "@binhend/config": "^1.0.0",
+        "express": "^4.17.1",
+        "js-beautify": "^1.15.1",
+        "uglify-js": "^3.17.4",
+        "uglifycss": "^0.0.29"
+    }
+}

package/{src2/web/index.js → packages/web/src/WebBuild.js}

@@ -1,11 +1,12 @@
-// @ts-nocheck
 
 const path = require('path');
-const { isEmptyString, isString, mustString } = require('../utils/types');
+// @ts-ignore
+const { isEmptyString, isString, mustString } = require('@binhend/types');
 const ComponentFormat = require('./component.format');
 const ComponentBuild = require('./component.build');
 const Component = require('./component');
-const { server } = require('../server');
+// @ts-ignore
+const { server } = require('@binhend/core');
 const express = require('express');
 
 const DEFAULT_DIR_BUILD = 'build';
@@ -13,6 +14,7 @@ const DEFAULT_DIR_BUILD_WEB = 'web';
 const DEFAULT_DIR_BUILD_MODULE = 'module';
 const DEFAULT_DIR_BUILD_EXTERNAL = 'NPM';
 
+// @ts-ignore
 function WebBuild(source, { output, external } = {}) {
 
     if (isEmptyString(source)) throw new Error(`[BINHEND][WEB] Require source code location. Current: source: ${source}`);
@@ -55,10 +57,13 @@ function WebBuild(source, { output, external } = {}) {
 
     setTimeout(() => {
         server().use(express.static(web));
+        // @ts-ignore
         server().get('/*', (req, res) => res.sendFile('index.html', { root: web }));
     });
 
+    // @ts-ignore
     binh.webModulePath = module;
+    // @ts-ignore
     binh.webSourcePath = source;
 
 }

package/{src2/web → packages/web/src}/component.format.js

@@ -1,4 +1,4 @@
-const { config } = require('../configuration');
+const { config } = require('@binhend/config');
 const { readFileSync } = require('fs');
 const { parseFileName, isAcceptedJS, isExceptedJS } = require('./file-check');
 const { scanNestedFiles, cloneFileIfNew, printError, makeFullDirPath, writeToFileIfNew } = require('./component.file');

package/{src2/web → packages/web/src}/component.method.js

@@ -1,10 +1,10 @@
-// @ts-nocheck
 
 const path = require('path');
 const fs = require('fs');
 const UglifyCSS = require('uglifycss');
 const Component = require('./component');
-const { isString } = require('../utils/types');
+// @ts-ignore
+const { isString } = require('@binhend/types');
 
 const binh = {};
 
@@ -130,14 +130,17 @@ binh.css = function (module, cssFilename) {
 
 /** Dummy Binh object for binhjs => build web not logging error of undefined */
 binh.Binh = function () { };
-binh.Binh.Util = { require: function () {} };
+binh.Binh.Util = { require: function () { } };
 
 function alias(name) {
     if (!isString(name)) return this;
     name = name.trim();
 
     var alias = this.alias || (this.alias = {});
+
+    // @ts-ignore
     if (this.parent) alias[this.parent.filename] = name;
+    // @ts-ignore
     delete this.parent;
 
     return this;

package/src2/types/common.d.ts

@@ -1,10 +0,0 @@
-
-/**
- * @typedef {Object<string, any>} ObjectType
- */
-
-/**
- * @typedef {(Date|string|number)} DateType
- */
-
-export {};

package/src2/types/index.d.ts

@@ -1,2 +0,0 @@
-
-export * from './common.d.ts';

package/src2/utils/typedefs.js

@@ -1,31 +0,0 @@
-
-/**
- * @typedef {Object<string, any>} ObjectType
- */
-
-/**
- * Type definition for object accepting any extra properties
- *
- * @returns {ObjectType}
- */
-function ObjectType() { return this; }
-
-
-
-/**
- * @typedef {(Date|string|number)} DateType
- */
-
-/**
- * Type definition for date accepting any valid formats (string, number, date)
- *
- * @returns {DateType}
- */
-function DateType() { return this; }
-
-
-
-module.exports = {
-    ObjectType,
-    DateType
-};