topkat-utils 1.0.60 → 1.1.2

package/src/string-utils.ts

@@ -0,0 +1,212 @@
+//----------------------------------------
+// STRING UTILS
+//----------------------------------------
+import { err500IfEmptyOrNotSet } from "./error-utils"
+import { ObjectGeneric } from "./private/types"
+import { isset } from "./isset"
+
+/**Eg: camelCase */
+export function camelCase(...wordBits) {
+    return wordBits.filter(e => e).map((w, i) => i === 0 ? w : capitalize1st(w)).join('')
+}
+
+/**Eg: snake_case
+ * trimmed but not lowerCased
+ */
+export function snakeCase(...wordBits) {
+    return wordBits.filter(e => e).map(w => w.trim()).join('_')
+}
+/**Eg: kebab-case
+ * trimmed AND lowerCased
+ * undefined, null... => ''
+ */
+export function kebabCase(...wordBits) {
+    return wordBits.filter(e => e).map(w => w.trim().toLowerCase()).join('-')
+}
+/**Eg: PascalCase undefined, null... => '' */
+export function pascalCase(...wordBits) {
+    return wordBits.filter(e => e).map((w, i) => capitalize1st(w)).join('')
+}
+
+/**Eg: Titlecase undefined, null... => '' */
+export function titleCase(...wordBits) {
+    return capitalize1st(wordBits.filter(e => e).map(w => w.trim()).join(''))
+}
+
+/**Eg: UPPERCASE undefined, null... => '' */
+export function upperCase(...wordBits) {
+    return wordBits.filter(e => e).map(w => w.trim().toUpperCase()).join('')
+}
+
+/**Eg: lowercase undefined, null... => '' */
+export function lowerCase(...wordBits) {
+    return wordBits.filter(e => e).map(w => w.trim().toLowerCase()).join('')
+}
+
+export function capitalize1st(str = '') { return str[0].toUpperCase() + str.slice(1) }
+
+export function camelCaseToWords(str) {
+    return str ? str.trim().replace(/([A-Z])/g, '-$1').toLowerCase().split('-') : []
+}
+
+/** GIVEN A STRING '{ blah;2}, ['nested,(what,ever)']' AND A SEPARATOR ",""
+ *  This will return the content separated by first level of separators
+ *  @return ["{ blah;2}", "['nested,(what,ever)']"]
+ */
+export function getValuesBetweenSeparator(str: string, separator: string, removeTrailingSpaces = true) {
+    err500IfEmptyOrNotSet({ separator, str })
+    const { outer } = getValuesBetweenStrings(str, separator, undefined, undefined, undefined, removeTrailingSpaces)
+    return outer
+}
+
+
+/** GIVEN A STRING "a: [ 'str', /[^]]/, '[aa]]]str', () => [ nestedArray ] ], b: ['arr']"
+ * @return matching: [ "'str', /[^]]/, '[aa]]]str', () => [ nestedArray ]", "'arr'" ], between: [ "a:", ", b: " ]
+ * @param str base string
+ * @param openingOrSeparator opening character OR separator if closing not set
+ * @param closing
+ * @param ignoreBetweenOpen default ['\'', '`', '"', '/'], when reaching an opening char, it will ignore all until it find the corresponding closing char
+ * @param ignoreBetweenClose default ['\'', '`', '"', '/'] list of corresponding closing chars
+ */
+export function getValuesBetweenStrings(str: string, openingOrSeparator, closing, ignoreBetweenOpen = ['\'', '`', '"', '/'], ignoreBetweenClose = ['\'', '`', '"', '/'], removeTrailingSpaces = true) {
+    err500IfEmptyOrNotSet({ openingOrSeparator, str })
+
+    str = str.replace(/<</g, '§§"').replace(/>>/g, '"§§')
+
+    const arrayValues = []
+    const betweenArray = []
+    let level = 0
+    let ignoreUntil: boolean | string = false
+    let actualValue = ''
+    let precedingChar = ''
+
+    let separatorMode = false
+    if (!closing) separatorMode = true
+
+    const separator = separatorMode ? openingOrSeparator : false
+    const openingChars = separatorMode ? ['(', '{', '['] : [openingOrSeparator]
+    const closingChars = separatorMode ? [')', '}', ']'] : [closing]
+
+    const pushActualValue = () => {
+        if (level === 0) betweenArray.push(removeTrailingSpaces ? actualValue.replace(/(?:^\s+|\s+$)/g, '') : actualValue)
+        else arrayValues.push(removeTrailingSpaces ? actualValue.replace(/(?:^\s+|\s+$)/g, '') : actualValue)
+        actualValue = ''
+    }
+
+    str.split('').forEach(char => {
+        // handle unwanted nested structure like characters in a strings that may be a unmatched closing / opening character
+        // Eg: {'azer}aze'}
+        if (ignoreUntil && char === ignoreUntil && precedingChar !== '\\') ignoreUntil = false
+        else if (ignoreUntil && char !== ignoreUntil) true
+        else if (ignoreBetweenOpen.includes(char)) {
+            const indexChar = ignoreBetweenOpen.findIndex(char2 => char2 === char)
+            ignoreUntil = ignoreBetweenClose[indexChar]
+        } else if (openingChars.includes(char)) {
+            // handle nested structures
+            if (!separatorMode && level === 0) pushActualValue()
+            level++
+            if (!separatorMode) return
+        } else if (closingChars.includes(char)) {
+            // handle nested structures
+            if (!separatorMode && level === 1) pushActualValue()
+            level--
+        } else if (separatorMode && level === 0 && char === separator) {
+            // SEPARATOR MODE
+            pushActualValue()
+            return
+        }
+        actualValue += char
+        precedingChar = char
+    })
+
+    pushActualValue()
+
+    const replaceValz = arr => arr.map(v => v.replace(/§§"/g, '<<').replace(/"§§/g, '>>')).filter(v => v)
+
+    return { inner: replaceValz(arrayValues), outer: replaceValz(betweenArray) }
+}
+
+/** Remove accentued character from string and eventually special chars and numbers
+ * @param {String} str input string
+ * @param {Object} config { removeSpecialChars: false, removeNumbers: false, removeSpaces: false }
+ * @returns String with all accentued char replaced by their non accentued version + config formattting
+ */
+export function convertAccentedCharacters(str, config: { removeNumbers?: boolean, removeSpecialChars?: boolean, removeSpaces?: boolean } = {}) {
+    let output = str
+        .replace(/[àáâãäå]/g, 'a')
+        .replace(/ç/g, 'c')
+        .replace(/[èéêë]/g, 'e')
+        .replace(/[ìíîï]/g, 'i')
+        .replace(/[ôö]/g, 'o')
+        .replace(/[ùúû]/g, 'u')
+        .replace(/(^\s*|\s*$)/g, '')
+    if (config.removeNumbers === true) output = output.replace(/\d+/g, '')
+    if (config.removeSpecialChars === true) output = output.replace(/[^A-Za-z0-9 ]/g, '')
+    if (config.removeSpaces === true) output = output.replace(/\s+/g, '')
+    return output
+}
+
+
+let generatedTokens = [] // cache to avoid collision
+let lastTs = new Date().getTime()
+/** minLength 8 if unique 
+* @param {Number} length default: 20
+* @param {Boolean} unique default: true. Generate a real unique token base on the date. min length will be min 8 in this case
+* @param {string} mode one of ['alphanumeric', 'hexadecimal']
+* NOTE: to generate a mongoDB Random Id, use the params: 24, true, 'hexadecimal'
+*/
+export function generateToken(length = 20, unique = true, mode: 'alphanumeric' | 'hexadecimal' = 'alphanumeric') {
+    let charConvNumeric = mode === 'alphanumeric' ? 36 : 16
+    if (unique && length < 8) length = 8
+    let token
+    let tokenTs
+    do {
+        tokenTs = (new Date()).getTime()
+        token = unique ? tokenTs.toString(charConvNumeric) : ''
+        while (token.length < length) token += Math.random().toString(charConvNumeric).substr(2, 1) // char alphaNumeric aléatoire
+    } while (generatedTokens.includes(token))
+    if (lastTs < tokenTs) generatedTokens = [] // reset generated token on new timestamp because cannot collide
+    generatedTokens.push(token)
+    return token
+}
+
+export function generateObjectId() {
+    return generateToken(24, true, 'hexadecimal')
+}
+
+
+/** Useful to join differents bits of url with normalizing slashes
+ * * urlPathJoin('https://', 'www.kikou.lol/', '/user', '//2//') => https://www.kikou.lol/user/2/
+ * * urlPathJoin('http:/', 'kikou.lol') => https://www.kikou.lol
+ */
+export function urlPathJoin(...bits: string[]) {
+    return bits.join('/').replace(/\/+/g, '/').replace(/(https?:)\/\/?/, '$1//')
+}
+
+
+
+export type MiniTemplaterOptions = {
+    valueWhenNotSet?: string
+    regexp?: RegExp
+    valueWhenContentUndefined?: string
+}
+/** Replace variables in a string like: `Hello {{userName}}!`
+ * @param {String} content 
+ * @param {Object} varz object with key => value === toReplace => replacer
+ * @param {Object} options 
+ * * valueWhenNotSet => replacer for undefined values. Default: ''
+ * * regexp          => must be 'g' and first capturing group matching the value to replace. Default: /{{\s*([^}]*)\s*}}/g
+ */
+export function miniTemplater(content: string, varz: ObjectGeneric, options: MiniTemplaterOptions = {}): string {
+    options = {
+        valueWhenNotSet: '',
+        regexp: /{{\s*([^}]*)\s*}}/g,
+        valueWhenContentUndefined: '',
+        ...options,
+    }
+    return isset(content) ? content.replace(options.regexp, (m, $1) => isset(varz[$1]) ? varz[$1] : options.valueWhenNotSet) : options.valueWhenContentUndefined
+}
+
+
+/** Clean output for outside world. All undefined / null / NaN / Infinity values are changed to '-' */
+export function cln(val, replacerInCaseItIsUndefinNaN = '-') { return ['undefined', undefined, 'indéfini', 'NaN', NaN, Infinity, null].includes(val) ? replacerInCaseItIsUndefinNaN : val }

package/src/tests-utils.ts

@@ -0,0 +1,70 @@
+//----------------------------------------
+// TESTS UTILS
+//----------------------------------------
+import { C } from "./logger-utils"
+import { ValidatorObject } from "./validation-utils"
+import { isset } from "./isset"
+import { validatorReturnErrArray } from "./validation-utils"
+import { Override } from "./private/types"
+import { isObject } from "./is-object"
+
+export const restTestMini = {
+    throwOnErr: false,
+    reset(throwOnErr = false) {
+        restTestMini.nbSuccess = 0
+        restTestMini.nbError = 0
+        restTestMini.lastErrors = []
+        restTestMini.throwOnErr = throwOnErr
+    },
+    newErr(err) {
+        restTestMini.nbError++
+        restTestMini.lastErrors.push(err)
+        if (restTestMini.throwOnErr) throw new Error(err)
+        else C.error(false, err)
+    },
+    printStats() {
+        // TODO print last errz
+        C.info(`ERRORS RESUME =========`)
+        if (restTestMini.lastErrors.length) C.log('\n\n\n')
+        for (const lastErr of restTestMini.lastErrors) C.error(false, lastErr)
+        C.log('\n\n\n')
+        C.info(`STATS =========`)
+        C.info(`Total: ${restTestMini.nbSuccess + restTestMini.nbError}`)
+        C.success(`Success: ${restTestMini.nbSuccess}`)
+        C.error(false, `    Errors: ${restTestMini.nbError}`)
+    },
+    nbSuccess: 0,
+    nbError: 0,
+    lastErrors: []
+}
+
+/** if validatorObject param is not set then it will consider checking that the value is set
+ * 
+ * @param description 
+ * @param value 
+ * @param validatorObject 
+ */
+export function assert(description: string, value: any, validatorObject?: Override<ValidatorObject, { value?: never, name?: never }> | number | boolean | string) {
+    try {
+        const validatorObjReal: ValidatorObject = {
+            value,
+            name: description,
+        }
+
+        if (isObject(validatorObject)) Object.assign(validatorObjReal, validatorObject)
+        else if (isset(validatorObject)) validatorObjReal.eq = validatorObject
+
+        const issetCheck = !isset(validatorObjReal) // isEmpty()
+        const [errMsg, , extraInfos] = validatorReturnErrArray(validatorObjReal)
+        const msg2 = description + ` ${issetCheck ? 'isset' : `${JSON.stringify(validatorObject)}`}`
+        if (isset(errMsg)) {
+            const err = msg2 + `\n    ${errMsg}\n    ${JSON.stringify(extraInfos)}`
+            restTestMini.newErr(err)
+        } else {
+            restTestMini.nbSuccess++
+            C.success(msg2)
+        }
+    } catch (err) {
+        restTestMini.newErr(err)
+    }
+}

package/src/timer-utils.ts

@@ -0,0 +1,58 @@
+
+//----------------------------------------
+// TIMEOUT UTILS
+//----------------------------------------
+import { cliProgressBar, C } from "./logger-utils"
+import { dataValidationUtilErrorHandler } from "./private/error-handler"
+
+
+export async function timeout(ms, fn = () => { }) { return new Promise(res => setTimeout(res, ms)).then(fn) }
+
+export async function runAsync(callback, milliseconds$ = 1) { return timeout(milliseconds$, callback) }
+
+/**
+ * 
+ * @param {Function} callback function that shall return ===true asynchronously 
+ * @param {Number} timeoutSec default:10; general timeout in seconds
+ * @param {Boolean|String} errorAfterNSeconds default:true output an error in case of timeout, can be the displayed error message
+ * @param {*} cliOutput write a cli progress to show that a process is running
+ */
+export async function waitUntilTrue(callback, timeoutSec = 10, errorAfterNSeconds = true, cliOutput = true) {
+    let generalTimeout = true
+    let step = 3
+    const errMess = typeof errorAfterNSeconds === 'string' ? 'Timeout: ' + errorAfterNSeconds : 'Timeout for waitUntilTrue() callback'
+
+    if (timeoutSec) setTimeout(() => generalTimeout = false, timeoutSec * 1000)
+
+    while (callback() !== true && generalTimeout) {
+        if (cliOutput) cliProgressBar(step++)
+        await timeout(300)
+    }
+    if (cliOutput) process.stdout.write(`\n`)
+    if (!generalTimeout && errorAfterNSeconds) throw new dataValidationUtilErrorHandler(errMess, 500)
+}
+
+
+const delayedLoopParams = []
+let isExecuting = false
+
+/** Allow to perform an action in a delayed loop, useful for example to avoid reaching limits on servers. This function can be securely called multiple times.
+ * @param {Function} callback 
+ * @param {Number} time default: 500ms;
+ * @param {Function} errorCallback default: e => C.error(e)
+ */
+export async function executeInDelayedLoop(callback, time = 500, errorCallback = e => C.error(e)) {
+    delayedLoopParams.push([callback, time, errorCallback])
+    if (isExecuting) return
+    isExecuting = true
+    while (delayedLoopParams.length) {
+        const [callback, time, errorCallback] = delayedLoopParams.shift()
+        try {
+            await callback()
+            await timeout(time)
+        } catch (err) {
+            errorCallback(err)
+        }
+    }
+    isExecuting = false
+}

package/src/transaction-utils.ts

@@ -0,0 +1,63 @@
+//----------------------------------------
+// TRANSACTION
+//----------------------------------------
+import { isset } from "./isset"
+import { C } from "./logger-utils"
+import { timeout } from "./timer-utils"
+
+const transactionRunning = { __default: false }
+const queue = { __default: [] }
+
+/** Allow to perform async functions in a defined order  
+ * This adds the callback to a queue and is resolved when ALL previous callbacks with same name are executed  
+ * Use it like: await transaction('nameOfTheFlow', async () => { ...myFunction })
+ * @param {String|Function} name name for the actions that should never happen concurrently
+ * @param {Function} asyncCallback 
+ * @param {Number} timeout default: 120000 (120s) will throw an error if transaction time is higher that this amount of ms
+ * @returns {Promise}
+ */
+export async function transaction(name, asyncCallback, timeout = 120000, doNotThrow = false) {
+    if (typeof name === 'function') {
+        asyncCallback = name
+        name = '__default'
+    }
+    if (!isset(queue[name])) queue[name] = []
+    if (!isset(transactionRunning[name])) transactionRunning[name] = false
+
+    return await new Promise((resolve, reject) => {
+        if (doNotThrow) reject = C.error
+        queue[name].push(async () => {
+            try {
+                setTimeout(() => {
+                    C.warning('Transaction Timout') // in case not catched
+                    reject(new Error('transactionTimeout'))
+                }, timeout)
+                const res = await asyncCallback()
+                resolve(res)
+            } catch (err) {
+                reject(err)
+            }
+        })
+        removeItemFromQueue(name)
+    })
+}
+
+export async function removeItemFromQueue(name) {//               meoww!
+    if (transactionRunning[name] === true) return //       v 
+    transactionRunning[name] = true //               A  A       /\
+    while (queue[name].length) await queue[name].shift()() //   II
+    transactionRunning[name] = false //              \==/_______II
+} //                                                    l  v_v_v _I
+//                                                       11    11
+
+/** Wait for a transaction to complete without creating a new transaction
+ * 
+ */
+export async function waitForTransaction(transactionName, forceReleaseInSeconds = 30) {
+    let brk = false
+    setTimeout(() => brk = true, forceReleaseInSeconds * 1000)
+    while (isset(transactionRunning[transactionName]) && transactionRunning[transactionName] === true) {
+        if (brk) break
+        await timeout(15)
+    }
+}

package/src/validation-utils.ts

@@ -0,0 +1,253 @@
+//----------------------------------------
+// VALIDATION UTILS
+//----------------------------------------
+import { dataValidationUtilErrorHandler } from "./private/error-handler"
+import { isset } from "./isset"
+import { isDateIsoOrObjectValid, isDateIntOrStringValid, isTimeStringValid } from "./date-utils"
+import { asArray } from "./array-utils"
+import { configFn } from "./private/config"
+import { isEmpty } from "./is-empty"
+
+export type BaseTypes = 'objectId' | 'dateInt6' | 'dateInt' | 'dateInt8' | 'dateInt12' | 'time' | 'humanReadableTimestamp' | 'date' | 'dateObject' | 'array' | 'object' | 'buffer' | 'string' | 'function' | 'boolean' | 'number' | 'bigint' | 'year' | 'email' | 'any'
+
+export function issetOr(...elms) { return elms.some(elm => typeof elm !== 'undefined' && elm !== null) }
+
+export function isEmptyOrNotSet(...elms) { return elms.some(elm => !isset(elm) || isEmpty(elm)) }
+
+export function isDateObject(variable) { return variable instanceof Date }
+
+/** Check all values are set */
+export function checkAllObjectValuesAreEmpty(o) { return Object.values(o).every(value => !isset(value)) }
+
+/** Throw an error in case data passed is not a valid ctx */
+export function checkCtxIntegrity(ctx) {
+    if (!isset(ctx) || !isset(ctx.user)) throw new dataValidationUtilErrorHandler('ctxNotSet', 500)
+}
+
+/**
+## VALIDATOR
+
+@name validator
+
+@description support multiple names, multiple values and multiple type check
+@option if nameString ends by $ sign it is considered optional
+
+@function validator([Objects])
+@return {error|true/false|testMode} depend on mode (see prop mode)
+@param {} mode normal (default) | test (TODO) | boolean
+@param {} name 'myName' || [{myVar1: 'blah, myvar2: myvar2}], support multiple names / values
+@param {} value myVar,
+@param {string} myVar myVar, instead of name / value
+@param {array} in ['blah', 'otherPossibleValue', true], equal ONE OF THESE values
+@param {any} eq exactly equal to in, both support string or array of values
+@param {any} neq not in, both support string or array of values
+@param {number} lte 3, less than or equal
+@param {number} gte 1, greater or equal
+@param {number} lt 3, less than
+@param {number} gt 1, greater
+@param {string|string[]} type
+ * possibleTypes: object, number, string, boolean, array, date, dateInt8, dateInt12, dateInt6, time, objectId (mongo), humanReadableTimestamp, buffer
+ * Notes: multiples value is an OR, /!\ Array is type 'array' and not 'object' like in real JS /!\
+@param {regExp} regexp /regexp/, test against regexp
+@param {number} minLength for string, array or number length
+@param {number} maxLength
+@param {number} length
+@param {boolean} optional default false
+@param {boolean} emptyAllowed default false (to use if must be set but can be empty)
+@param {boolean} mustNotBeSet this one must not be set
+@param {any} includes check if array or string includes value (like js .includes())
+
+@example
+    validator(
+        { myNumber : 3, type: 'number', gte: 1, lte: 3 }, // use the name directly as a param
+        { name: 'email', value: 'nameATsite.com', regexp: /[^\sAT]+AT[^\sAT]+\.[^\sAT]/},
+        { name: [{'blahVar': blahVarValue, 'myOtherVar': myOtherVarValue}], type: 'string'} // multiple names for same check
+    )
+----------------------------------------*/
+
+export type ValidatorObject = {
+    name?: string
+    value?: any
+    type?: BaseTypes
+    eq?: any
+    neq?: any
+    in?: any[]
+    lt?: number
+    gt?: number
+    lte?: number
+    gte?: number
+    length?: number
+    minLength?: number
+    maxLength?: number
+    emptyAllowed?: boolean
+    regexp?: RegExp
+    mustNotBeSet?: boolean
+    optional?: boolean
+    isArray?: boolean
+    [k: string]: any
+}
+export function validator(...paramsToValidate: ValidatorObject[]) {
+    const errArray = validatorReturnErrArray(...paramsToValidate)
+    if (errArray.length) throw new dataValidationUtilErrorHandler(...errArray)
+}
+
+
+/** Same as validator but return a boolean
+ * See {@link validator}
+ */
+export function isValid(...paramsToValidate) {
+    const errArray = validatorReturnErrArray(...paramsToValidate)
+    return errArray.length ? false : true
+}
+
+/** Default types + custom types
+ * 'objectId','dateInt6','dateInt','dateInt8','dateInt12','time','humanReadableTimestamp','date','array','object','buffer','string','function','boolean','number','bigint',
+ */
+export function isType(value, type: BaseTypes) { return isValid({ name: 'Is type check', value, type }) }
+
+export function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]): [string?, number?, object?] {
+    let paramsFormatted = []
+
+    // support for multiple names with multiple values for one rule. Eg: {name: [{startDate:'20180101'}, {endDate:'20180101'}], type: 'dateInt8'}
+    paramsToValidate.forEach(param => {
+        if (typeof param !== 'object' || Array.isArray(param))
+            throw new dataValidationUtilErrorHandler(`wrongTypeForDataValidatorArgument`, 500, { origin: 'Generic validator', expected: 'object', actualType: Array.isArray(param) ? 'array' : typeof param })
+
+        // parse => name: {myVar1: 'blah, myvar2: myvar2}
+        if (typeof param.name === 'object' && !Array.isArray(param.name))
+            Object.keys(param.name).forEach(name => paramsFormatted.push(Object.assign({}, param, { name: name, value: param.name[name] })))
+        else paramsFormatted.push(param)
+    })
+
+    for (const paramObj of paramsFormatted) {
+        let name = paramObj.name
+        let value = paramObj.value
+        let optional = paramObj.optional || false
+        let emptyAllowed = optional || paramObj.emptyAllowed || false
+        const errMess = (msg, extraInfos = {}, errCode = 422): [string, number, object] => [msg, errCode, { origin: 'Generic validator', varName: name, gotValue: isset(value) && isset(value.data) && isset(value.data.data) ? { ...value, data: 'Buffer' } : value, ...extraInfos }]
+
+        // accept syntax { 'myVar.var2': myVar.var2, ... }
+        if (!isset(name)) {
+            name = Object.keys(paramObj).find(param => !['in', 'eq', 'lte', 'gte', 'name', 'value', 'type', 'regexp', 'minLength', 'maxLength', 'optional', 'emptyAllowed', 'mustNotBeSet', 'includes', 'length'].includes(param))
+            if (isset(name)) value = paramObj[name] // throw new dataValidationUtilErrorHandler('noNameProvidedForDataValidator', 500, { origin: 'Generic validator', });
+        }
+        // if nameString ends by $ sign it is optional
+        if (isset(name) && /.*\$$/.test(name)) {
+            name = name.substr(0, name.length - 1)
+            optional = true
+        }
+
+        // DEFINED AND NOT EMPTY
+        if (!isset(value) && optional) continue
+        if (isset(value) && paramObj.mustNotBeSet) return errMess('variableMustNotBeSet')
+        if (paramObj.mustNotBeSet) continue // exit
+        if (!isset(value)) return errMess('requiredVariableEmptyOrNotSet')
+        if (!emptyAllowed && value === '') return errMess('requiredVariableEmpty')
+
+        const isArray = paramObj.isArray
+        if (isArray && !Array.isArray(value)) return errMess('wrongTypeForVar', { expectedTypes: 'array', gotType: typeof value })
+
+        // TYPE
+        if (isset(paramObj.type)) {
+            const types = asArray(paramObj.type) // support for multiple type
+            const areSomeTypeValid = types.some(type => {
+                if (type.endsWith('[]')) {
+                    if (!Array.isArray(value)) errMess('wrongTypeForVar', { expectedTypes: 'array', gotType: typeof value })
+                    type = type.replace('[]', '')
+                }
+
+                const allTypes: Array<BaseTypes> = [
+                    'objectId',
+                    'dateInt6',
+                    'dateInt', // alias for dateInt8
+                    'dateInt8',
+                    'dateInt12',
+                    'time',
+                    'humanReadableTimestamp',
+                    'date',
+                    'dateObject', // alias
+                    'array',
+                    'object',
+                    'buffer',
+                    'string',
+                    'function',
+                    'boolean',
+                    'number',
+                    'bigint',
+                    'year',
+                    'any',
+                    'email',
+                    //...Object.keys(configFn().customTypes)
+                ]
+
+                if (!allTypes.includes(type)) throw new dataValidationUtilErrorHandler('typeDoNotExist', 500, { type })
+
+                const basicTypeCheck = {
+                    objectId: val => /^[0-9a-fA-F-]{24,}$/.test(val), // "0c65940b-6b0c-4dd8-9c7a-7c5fe1ba907a"
+                    dateInt6: val => isDateIntOrStringValid(parseInt(val + '01'), true, 8),
+                    dateInt: val => isDateIntOrStringValid(val, true, 8),
+                    dateInt8: val => isDateIntOrStringValid(val, true, 8),
+                    dateInt12: val => isDateIntOrStringValid(val, true, 12),
+                    time: val => /^\d\d:\d\d$/.test(val) && isTimeStringValid(val),
+                    humanReadableTimestamp: val => (val + '').length === 17,
+                    date: val => isDateIsoOrObjectValid(val, true),
+                    dateObject: val => isDateIsoOrObjectValid(val, true),
+                    array: val => Array.isArray(val),
+                    object: val => !Array.isArray(val) && val !== null && typeof val === type,
+                    buffer: val => Buffer.isBuffer(val),
+                    year: val => /^\d\d\d\d$/.test(val),
+                    email: val => /^[^\s@]+@([^\s@.,]+\.)+[^\s@.,]+$/.test(val),
+                    any: () => true,
+                }
+
+                return isset(basicTypeCheck[type]) && basicTypeCheck[type](value) ||
+                    typeof value === type && type !== 'object' || // for string, number, boolean...
+                    isset(configFn().customTypes[type]) && configFn().customTypes[type].test(value)
+            })
+            if (!areSomeTypeValid) return errMess(`wrongTypeForVar`, { expectedTypes: types.join(', '), gotType: Object.prototype.toString.call(value) })
+        }
+
+        // GREATER / LESS
+        if (isset(paramObj.gte) && value < paramObj.gte) return errMess(`valueShouldBeSuperiorOrEqualForVar`, { shouldBeSupOrEqTo: paramObj.gte })
+        if (isset(paramObj.lte) && value > paramObj.lte) return errMess(`valueShouldBeInferiorOrEqualForVar`, { shouldBeInfOrEqTo: paramObj.lte })
+        if (isset(paramObj.gt) && value <= paramObj.gt) return errMess(`valueShouldBeSuperiorForVar`, { shouldBeSupOrEqTo: paramObj.gt })
+        if (isset(paramObj.lt) && value >= paramObj.lt) return errMess(`valueShouldBeInferiorForVar`, { shouldBeInfOrEqTo: paramObj.lt })
+
+        // IN VALUES
+        if (isset(paramObj.in)) {
+            const equals = Array.isArray(paramObj.in) ? paramObj.in : [paramObj.in]
+            if (!equals.some(equalVal => equalVal === value)) return errMess(`wrongValueForVar`, { supportedValues: JSON.stringify(equals) })
+        }
+
+        // EQUAL (exact copy of .in)
+        if (paramObj.hasOwnProperty('eq')) {
+            const equals = Array.isArray(paramObj.eq) ? paramObj.eq : [paramObj.eq]
+            if (!equals.some(equalVal => equalVal === value)) return errMess(`wrongValueForVar`, { supportedValues: equals.join(', '), })
+        }
+
+        // NOT EQUAL
+        if (paramObj.hasOwnProperty('neq')) {
+            const notEquals = Array.isArray(paramObj.neq) ? paramObj.neq : [paramObj.neq]
+            if (notEquals.some(equalVal => equalVal === value)) return errMess(`wrongValueForVar`, { NOTsupportedValues: notEquals.join(', ') })
+        }
+
+        // INCLUDES
+        if (isset(paramObj.includes) && !value.includes(paramObj.includes))
+            return errMess(`wrongValueForVar`, { shouldIncludes: paramObj.includes })
+
+        // REGEXP
+        if (isset(paramObj.regexp) && !paramObj.regexp.test(value))
+            return errMess(`wrongValueForVar`, { shouldMatchRegexp: paramObj.regexp.toString() })
+
+        // MIN / MAX LENGTH works for number length. Eg: 20180101.length == 8
+        if (isset(paramObj.minLength) && paramObj.minLength > (typeof value == 'number' ? value + '' : value).length)
+            return errMess(`wrongLengthForVar`, { minLength: paramObj.minLength })
+        if (isset(paramObj.maxLength) && paramObj.maxLength < (typeof value == 'number' ? value + '' : value).length)
+            return errMess(`wrongLengthForVar`, { maxLength: paramObj.maxLength })
+        if (isset(paramObj.length) && paramObj.length !== (typeof value == 'number' ? value + '' : value).length)
+            return errMess(`wrongLengthForVar`, { length: paramObj.length })
+    }
+
+    return []
+}
+