binhend 2.1.15 → 2.1.17

package/demo.js

@@ -1,10 +1,45 @@
 
-const { HttpCodes, ConfigLoader, WebBuilder } = require('./index');
+const { HttpCodes, ConfigLoader, WebBuilder, HttpError, validation } = require('./index');
 
-HttpCodes.ACCEPTED;
+// HttpCodes.ACCEPTED;
 
-new ConfigLoader({}).cli;
+// new ConfigLoader({}).cli;
 
 // const builder = new WebBuilder('src', { output: 'build/bundle' });
 
-// builder.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

@@ -22,8 +22,9 @@ const cors = require('./src/middleware/cors');
 
 const createCSD = require('./src/csd');
 const security = require('./src/security');
-const typeOf = require('./src/utils/typeOf');
-const Bromise = require('./src/utils/bromise');
+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');
@@ -44,7 +45,8 @@ module.exports = {
     cors,
     createCSD,
     security,
-    typeOf,
+    types,
+    validation,
     Bromise,
     WebBuilder,
     binh

package/jsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "forceConsistentCasingInFileNames": true,
         "moduleResolution": "node",
         "target": "ES2017",
         "checkJs": true,

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "binhend",
-  "version": "2.1.15",
+  "version": "2.1.17",
   "description": "",
   "main": "index.js",
+  "types": "src/types/index.d.ts",
   "author": "Nguyen Duc Binh",
   "license": "UNLICENSED",
   "bin": {

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');

package/src/api/routes.js

@@ -1,6 +1,6 @@
 const { readdir, stat } = require('fs/promises');
 const { join, parse, resolve } = require('path');
-const { isUndefined } = require('../utils/typeOf');
+const { isUndefined } = require('../utils/types');
 const { server } = require('../server');
 const cors = require('../middleware/cors');
 const express = require('express');

package/src/configuration.js

@@ -1,6 +1,6 @@
 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 } = {}) {

package/src/csd/controller.js

@@ -1,5 +1,5 @@
 
-const { isEmptyObject, isString } = require('../utils/typeOf');
+const { isEmptyObject, isString } = require('../utils/types');
 const trycatch = require('../api/trycatch');
 const HttpError = require('../api/HttpError');
 

package/src/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/types/common.d.ts

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

package/src/types/index.d.ts

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

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

@@ -7,6 +7,10 @@ function isObject(input) {
     return typeOf(input) === 'Object';
 }
 
+function mustObject(input, defaultValue = {}) {
+    return isObject(input) ? input : isObject(defaultValue) ? defaultValue : {};
+}
+
 function isEmptyObject(input) {
     return isObject(input) && Object.keys(input).length === 0;
 }
@@ -17,8 +21,8 @@ function isEmptyArray(input) {
     return isArray(input) && input.length === 0;
 }
 
-function mustArray(input, defaultOutput = []) {
-    return isArray(input) ? input : isArray(defaultOutput) ? defaultOutput : [defaultOutput];
+function mustArray(input, defaultValue = []) {
+    return isArray(input) ? input : isArray(defaultValue) ? defaultValue : [];
 }
 
 function isFunction(input) {
@@ -45,6 +49,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,10 +82,15 @@ function isNullOrUndefined(input) {
     return isNull(input) || isUndefined(input);
 }
 
+function isNullish(input) {
+    return input == null;
+}
+
 module.exports = {
     typeOf,
     isObject,
     isEmptyObject,
+    mustObject,
     isArray,
     isEmptyArray,
     mustArray,
@@ -80,6 +98,7 @@ module.exports = {
     isNull,
     isUndefined,
     isNullOrUndefined,
+    isNullish,
     isBoolean,
     isNumber,
     mustNumber,
@@ -87,5 +106,7 @@ module.exports = {
     isEmptyString,
     mustString,
     isSymbol,
-    isBigInt
+    isBigInt,
+    isDate,
+    isDateLike
 };

package/src/utils/validation.js

@@ -0,0 +1,272 @@
+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 an integer
+ *
+ * @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 Integer(input, options = {}) {
+    return Validator(input, global.Number.isInteger, { ...options, type: 'integer' });
+}
+
+/**
+ * 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 {Date|string|number} - 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 one of the specified enum values
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Array|Object} enumValues - Array of allowed values or object whose keys are allowed values
+ * @param {Options} options - Additional options for validation.
+ * @returns {*} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function Enum(input, enumValues, options = {}) {
+    var validArray = types.isArray(enumValues),
+        validObject = types.isObject(enumValues);
+
+    if (!(validArray || validObject)) {
+        throwError('Enum validator requires an array or object of allowed values');
+    }
+
+    var method = validArray ? 'includes' : 'hasOwnProperty';
+
+    return Validator(
+        input, (input) => enumValues[method](input),
+        { ...options, message: options.message || `${input} is not defined in enum` }
+    );
+}
+
+/**
+ * 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,
+    Integer,
+    Boolean,
+    Array,
+    Object,
+    Function,
+    Date,
+    DateLike,
+    Enum,
+    Defined,
+    NotNull,
+    NotNullish,
+    Validator,
+    throwError
+};

package/src/web/component.method.js

@@ -4,7 +4,7 @@ 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,7 +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');