binhend 2.1.25 → 2.1.27

package/demo.js

@@ -1,45 +1,14 @@
 
 const { HttpCodes, ConfigLoader, WebBuilder, HttpError, validation } = require('./index');
 
-// HttpCodes.ACCEPTED;
+// var jsonPath = __dirname + '/jsconfig.json';
+// var cc = ConfigLoader.json(jsonPath);
+// console.log('cc', cc);
 
-// new ConfigLoader({}).cli;
+const config = {};
+console.log('config', config);
+const loader = new ConfigLoader(config);
 
-// const builder = new WebBuilder('src', { output: 'build/bundle' });
+loader.object({ foo: '1', koo: '2', hoo: '3' }, { filter: ['koo', 'hoo'] });
 
-// 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));
+console.log('config', config);

package/index.js

@@ -32,7 +32,7 @@ const { WebBuilder } = require('./src/web');
 const { binh } = require('./src/web/component.method');
 
 // Run scripts
-require('./src/supportRequireAliasPath');
+require('./src/alias-module');
 
 module.exports = {
     server,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "binhend",
-  "version": "2.1.25",
+  "version": "2.1.27",
   "description": "",
   "main": "index.js",
   "author": "Nguyen Duc Binh",
@@ -8,8 +8,14 @@
   "bin": {
     "binhend": "./bin/index.js"
   },
+  "workspaces": [
+    "test"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "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"

package/src/{supportRequireAliasPath.js → alias-cjs-loader.js}

@@ -2,6 +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' 
 
 // Protect against improperly customized module constructors by other frameworks/packages
 const Module = module.constructor.length > 1 ? module.constructor : DefaultModule;
@@ -15,7 +16,7 @@ try {
     jsconfig = require(jsconfigPath);
 }
 catch (error) {
-    return console.log(`[BINEND] Not load 'jsconfig.json' for alias paths.`);
+    return console.log(`[BINEND] Not found 'jsconfig.json' for alias paths.`);
 }
 
 const baseUrl = jsconfig?.compilerOptions?.baseUrl || '.';
@@ -45,7 +46,9 @@ Module._resolveFilename = function (request, parent, isMain, options) {
             // Construct the new request path
             var newRequest = request.replace(alias, resolvedPath);
 
+            // BINHEND web components load each others stil requiring src paths (src file paths), not module paths (formatted file paths)
             if (parent.filename.startsWith(binh.webModulePath)) {
+                // TODO test if this branch is acutally called.
                 newRequest = newRequest.replace(binh.webSourcePath, binh.webModulePath);
             }
 

package/src/alias-esm-loader.js

@@ -0,0 +1,40 @@
+
+// TODO apply module alias loader for ES Modules
+// TODO like in alias-cjs-loader.js, need to handle paths on UI components requiring each others (paths for web, src, module)
+
+// alias-loader.mjs
+import { fileURLToPath, pathToFileURL } from 'url';
+import path from 'path';
+import fs from 'fs';
+
+// Load jsconfig paths
+const configPath = path.resolve('jsconfig.json');
+const tsconfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+const baseUrl = path.resolve(tsconfig.compilerOptions?.baseUrl || '.');
+const paths = tsconfig.compilerOptions?.paths || {};
+
+function resolveAlias(specifier) {
+    for (const alias in paths) {
+        if (!alias.endsWith('/*')) continue;
+        const aliasPrefix = alias.slice(0, -2);
+        if (specifier.startsWith(aliasPrefix)) {
+            const subPath = specifier.slice(aliasPrefix.length);
+            const targetPaths = paths[alias];
+            for (const target of targetPaths) {
+                const fullPath = path.resolve(baseUrl, target.replace('/*', subPath));
+                if (fs.existsSync(fullPath) || fs.existsSync(fullPath + '.js') || fs.existsSync(path.join(fullPath, 'index.js'))) {
+                    return pathToFileURL(fullPath).href;
+                }
+            }
+        }
+    }
+    return null;
+}
+
+export async function resolve(specifier, context, defaultResolve) {
+    const resolved = resolveAlias(specifier);
+    if (resolved) {
+        return { url: resolved };
+    }
+    return defaultResolve(specifier, context, defaultResolve);
+}

package/src/alias-module.js

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

package/src/configuration.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { isEmptyArray, isArray, isObject, mustString } = require('./utils/types');
+const { isEmptyArray, isArray, isObject, mustString, isNullish } = require('./utils/types');
 
 // @ts-ignore
 function ConfigLoader(configObject, { rootPath } = {}) {
@@ -8,23 +8,24 @@ function ConfigLoader(configObject, { rootPath } = {}) {
 
     rootPath = mustString(rootPath) || require.main.path;
 
-    this.getConfigs = () => {
-        return configs;
-    };
-
     function getConfigPosition(key) {
         return key == undefined ? configs : configs[key] || (configs[key] = {});
     };
 
     // @ts-ignore
-    this.object = (object, { key, filter: filters } = {}) => {
-        try {
-            var config = getConfigPosition(key);
-            var filtered = isArray(filters) ? filter(object, filters) : object;
-            Object.assign(config, filtered);
+    this.object = (object, { key, filter: filters, overwrite } = {}) => {
+        let config = getConfigPosition(key);
+        let filtered = isArray(filters) ? filter(object, filters) : object;
+
+        if (overwrite === false) {
+            for (let key in filtered) {
+                if (isNullish(config[key])) {
+                    config[key] = filtered[key];
+                }
+            }
         }
-        catch (error) {
-            return failed(error, object);
+        else {
+            Object.assign(config, filtered);
         }
 
         return this;
@@ -34,17 +35,35 @@ function ConfigLoader(configObject, { rootPath } = {}) {
         return this.object(cli(), options);
     };
 
-    this.json = (filepath, options) => {
-        var filePath = path.resolve(rootPath, filepath);
-        return this.object(json(filePath), options);
+    this.json = (filepath, options = {}) => {
+        let filePath = path.resolve(rootPath, filepath);
+        let jsonObject = json(filePath);
+
+        if (options.hasOwnProperty('env')) {
+            let env = options.env;
+            for (let key in jsonObject) {
+                let value = jsonObject[key];
+                if (isObject(value) && value.hasOwnProperty(env)) {
+                    // if object has no "env" key, it means the intended value is the whole object => no new assignment
+                    jsonObject[key] = value[env];
+                }
+            }
+        }
+
+        return this.object(jsonObject, options);
     };
 
     this.file = (filepath, options) => {
-        var filePath = path.resolve(rootPath, filepath);
+        let filePath = path.resolve(rootPath, filepath);
         return this.object(file(filePath, options?.encoding), options);
     };
 }
 
+ConfigLoader.cli = cli;
+ConfigLoader.json = json;
+ConfigLoader.file = file;
+ConfigLoader.require = require.main.require;
+
 function filter(object, filterKeys) {
     if (!isObject(object) || isEmptyArray(filterKeys)) return {};
 
@@ -61,7 +80,8 @@ function filter(object, filterKeys) {
 
 function json(path) {
     try {
-        return require.main.require(path);
+        // return require.main.require(path);
+        return ConfigLoader.require(path);
     }
     catch (e) {
         return failed(e, path);

package/src/crypto.js

@@ -6,7 +6,7 @@ const lenght_iv = 16;
 const lenght_key = 32;
 
 function randomUUID(disableEntropyCache = true) {
-    crypto.randomUUID({ disableEntropyCache });
+    return crypto.randomUUID({ disableEntropyCache });
 }
 
 function generateSecurityKey() {

package/src/server.js

@@ -1,7 +1,11 @@
 const express = require('express');
 
-const server = express();
+var server;
+
+function getServer() {
+    return server || (server = express());
+}
 
 module.exports = {
-    server
+    server: getServer
 };

package/src/utils/Bromise.js

@@ -4,12 +4,16 @@ function Bromise() {
 
     this.promise = promise;
 
-    this.resolve = (value) => {
+    this.done = function() {
+        return promise;
+    };
+
+    this.returns = this.resolve = function(value) {
         resolve(value);
         return promise;
     };
 
-    this.reject = (error) => {
+    this.throws = this.reject = function(error) {
         reject(error);
         return promise;
     };

package/src/utils/validation.js

@@ -189,7 +189,7 @@ function Enum(input, enumValues, options = {}) {
  * @throws {HttpError} - If validation fails
  */
 function Defined(input, options = {}) {
-    return Validator(input, (input) => !types.isUndefined(input), { ...options, type: 'defined' });
+    return Validator(input, (input) => !types.isUndefined(input), { ...options, type: 'defined', required: true });
 }
 
 /**