binhend 2.3.7 → 2.3.9

package/index.js

@@ -11,7 +11,7 @@ const path = require('path');
 
 //___ Run scripts ___//
 const moduleAlias = require('./packages/module-alias'); // path alias '@' for requiring modules: require('@/any/path') - use jsconfig.json
-moduleAlias.path('@binhend/*', [ path.join(__dirname, './packages') ]); // set path alias '@binhend' for all packages to call each others when 'npm install' in another project
+moduleAlias.path('@binhend/*', [path.join(__dirname, './packages')]); // set path alias '@binhend' for all packages to call each others when 'npm install' in another project
 
 
 //___ Load packages ___//
@@ -30,7 +30,7 @@ const csrf = require('./packages/middlewares/src/csrf');
 const trycatch = require('./packages/middlewares/src/trycatch');
 const { Auth } = require('./packages/middlewares/src/authorize');
 
-const { config, ConfigLoader } = require('./packages/config/src/configuration');
+const { config, ConfigLoader, env } = require('./packages/config');
 
 const CSD = require('./packages/csd/src/csd');
 const CinCSD = require('./packages/csd/src/controller');
@@ -53,7 +53,7 @@ module.exports = {
 
     cors, csrf, trycatch, Auth,
 
-    config, ConfigLoader,
+    env, config, ConfigLoader,
 
     CSD, CinCSD, SinCSD, DinCSD, // only use CSD, others for exposing methods (via IDE auto-suggestion)
 

package/jsconfig.json

@@ -2,7 +2,7 @@
     "compilerOptions": {
         "forceConsistentCasingInFileNames": true,
         "moduleResolution": "node",
-        "target": "ES2017",
+        "target": "ES2022",
         "checkJs": true,
         "allowJs": true,
         "noEmit": true,

package/package.json

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

package/packages/config/index.js

@@ -1,3 +1,4 @@
 module.exports = {
     ...require('./src/configuration'),
+    ...require('./src/process.env')
 };

package/packages/config/src/process.env.js

@@ -0,0 +1,32 @@
+
+const path = require('path');
+const { cli } = require('./configuration').ConfigLoader;
+const { String } = require('@binhend/validation');
+
+function env(env = String(), rootPath = String()) {
+    rootPath = String(rootPath, { default: require.main.path });
+
+    const envExtension = typeof env === 'string' ? `.${env}` : '';
+    const configModuleFileName = `./env${envExtension}`;
+    const configModuleFilePath = path.resolve(rootPath, configModuleFileName);
+
+    try {
+        const localConfigs = require(configModuleFilePath);
+
+        for (var key in localConfigs) {
+            const value = localConfigs[key];
+            localConfigs[key] = typeof value === 'string' ? value : JSON.stringify(value);
+        }
+
+        return {
+            ...localConfigs,
+            ...process.env,
+            ...cli()
+        };
+    }
+    catch (error) {
+        throw new Error(`[BINHEND][CONFIG] Failed loading config from: ${configModuleFilePath}`, { cause: error });
+    }
+};
+
+module.exports = { env };

package/packages/utils/src/HttpError.js

@@ -1,7 +1,7 @@
 
 class HttpError extends Error {
-    constructor(httpCode, message) {
-        super(message);
+    constructor(httpCode, message, options = {}) {
+        super(message, options);
         this.name = 'HttpError';
         this.httpCode = httpCode;
     }

package/packages/utils/src/defaultErrorRepsonse.js

@@ -1,7 +1,17 @@
 
-const HttpError = require('./HttpError');
+function StatusCode(code = 500) {
+    /**
+     * Range of HTTP codes are from 100 to 599.
+     * HTTP code 500 is `Internal Server Error`.
+     */
+    return Number.isInteger(code) && code >= 100 && code <= 599 ? code : 500;
+}
 
 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' });
+    if (Object.prototype.hasOwnProperty.call(error, 'httpCode')) {
+        response.status(StatusCode(error.httpCode)).json({ error: error.message || 'Internal Server Error' });
+    }
+    else {
+        next(error);
+    }
 };

package/packages/validation/src/typeValidation.js

@@ -274,6 +274,44 @@ function Prop(key, object, validator, options) {
     });
 }
 
+/**
+ * Return an object with all properties defined in the validator, using non-strict validation.
+ * Instead of throwing errors, invalid values are set to `null` by enforcing `{ default: null, required: false }` across all validations.
+ *
+ * @template V
+ * @param {((...args: any[]) => V)} [validator] - Validation function
+ * @returns {V} - An object with keys bypass requirement
+ * @throws {HttpError} - If validation fails
+ */
+function DefaultObject(validator) {
+    OptionControl.default = null;
+    OptionControl.required = false;
+
+    try {
+        var value = validator();
+        return value;
+    }
+    catch (error) {
+        // TODO app log error for debug
+        throw new HttpError(HttpCodes.INTERNAL_SERVER_ERROR, `Type validation failed`);
+    }
+    finally {
+        delete OptionControl.default;
+        delete OptionControl.required;
+    }
+}
+
+/**
+ * Returns an empty object as the validator output without performing any validation.
+ *
+ * @template V
+ * @param {((...args: any[]) => V)} [validator] - Validation function
+ * @returns {V} - An empty object with no property
+ */
+function EmptyObject(validator) {
+    return /** @type {V} */ ({});
+}
+
 /**
  * Validate an input being a function
  *
@@ -407,10 +445,12 @@ function NotNullish(input, options = {}) {
 /**
  * Generic validator that accepts a validation function
  *
- * @param {*} input - Input value needs to be validated.
+ * @template T
+ * 
+ * @param {T} 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
+ * @returns {T} - The validated input
  * @throws {HttpError} - If validation fails
  */
 function Validator(input, validate, options = {}) {
@@ -418,14 +458,22 @@ function Validator(input, validate, options = {}) {
         return input;
     }
 
-    options = { ...options }; // prevent options being null
+    options = { ...options, ...OptionControl }; // prevent options being null
 
     // 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;
+    if (options.hasOwnProperty('default')) {
+        var defaultValue = options.default;
+
+        if (validate(defaultValue)) {
+            return defaultValue;
+        }
+
+        if (!options.required && types.isNullish(defaultValue)) {
+            return defaultValue;
+        }
     }
 
-    // allow null or undefined by default, set `options.required=true` for not allowing
+    // accept `null` or `undefined` by default, set `options.required=true` for not accepting nullish values
     if (!options.required && types.isNullish(input)) {
         return input;
     }
@@ -443,6 +491,8 @@ function Validator(input, validate, options = {}) {
     }
 }
 
+const OptionControl = {};
+
 module.exports = {
     String,
     Number,
@@ -453,6 +503,7 @@ module.exports = {
     PropIf, Prop,
     AssignIf, Assign,
     Value, Optional,
+    DefaultObject, EmptyObject,
     Function,
     AsyncFunction,
     Date,