binhend 2.3.3 → 2.3.5

package/package.json

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

package/packages/validation/src/typeValidation.js

@@ -5,9 +5,9 @@ const types = require('@binhend/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
+ * @property {string=} name - The name of variable/property holding value
+ * @property {boolean=} required - The value must not be null or undefined
+ * @property {*=} default - The default value being used if null or undefined
  */
 
 /**
@@ -109,15 +109,160 @@ function Array(input, options = {}) {
 /**
  * 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
+ * @template {Record<string, any>} [T={}]
+ * 
+ * @param {T=} input - Input value needs to be validated.
+ * @param {Options} options - Options for validation.
+ * @returns {T & Record<string, any>} - The validated input
  * @throws {HttpError} - If validation fails
  */
 function Object(input, options = {}) {
     return Validator(input, types.isObject, { ...options, type: 'object' });
 }
 
+/**
+ * Return an object fragment from an object via a specific key
+ * only if the value is defined (accept null), and pass validation.
+ *
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {*} object - Any target that may have properties (objects or primitives)
+ * @param {((value: any, options: Options) => V)} [validator] - An optional validation function
+ * @param {Options=} options - Options for validation.
+ * @returns {{ [P in K]?: V }} - An object fragment with a single key/value at most
+ * @throws {HttpError} - If validation fails
+ */
+function PropIf(key, object, validator, options) {
+    var value = object != null ? object[key] : undefined;
+
+    if (validator instanceof Function) {
+        value = validator(value, { ...options, name: key });
+    }
+
+    if (object == null || !Object.prototype.hasOwnProperty.call(object, key)) {
+        return /** @type {{ [P in K]: V }} */ ({});
+    }
+
+    return /** @type {{ [P in K]: V }} */ ({ [key]: value });
+}
+
+/**
+ * Return an object fragment from an object via a specific key
+ * even if the value is undefined, but must pass validation.
+ *
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {*} object - Any target that may have properties (objects or primitives)
+ * @param {((value: any, options: Options) => V)} [validator] - An optional validation function
+ * @param {Options=} options - Options for validation.
+ * @returns {{ [P in K]: V }} - An object fragment with a single key/value at most
+ * @throws {HttpError} - If validation fails
+ */
+function Prop(key, object, validator, options) {
+    return /** @type {{ [P in K]: V }} */ ({ [key]: PropIf(key, object, validator, options)[key] });
+}
+
+/**
+ * Return an object fragment from a value with a specific key
+ * only if the value is defined (accept null), and pass validation.
+ *
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {*} value - A value
+ * @param {((value: any, options: Options) => V)} [validator] - An optional validation function
+ * @param {Options=} options - Options for validation.
+ * @returns {{ [P in K]?: V }} - An object fragment with a single key/value at most
+ * @throws {HttpError} - If validation fails
+ */
+function AssignIf(key, value, validator, options) {
+    return PropIf(key, { [key]: value }, validator, options);
+}
+
+/**
+ * Return an object fragment from a value with a specific key
+ * even if the value is undefined, but must pass validation.
+ *
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {*} value - A value
+ * @param {((value: any, options: Options) => V)} [validator] - An optional validation function
+ * @param {Options=} options - Options for validation.
+ * @returns {{ [P in K]: V }} - An object fragment with a single key/value at most
+ * @throws {HttpError} - If validation fails
+ */
+function Assign(key, value, validator, options) {
+    return /** @type {{ [P in K]: V }} */ ({ [key]: AssignIf(key, value, validator, options)[key] });
+}
+
+/**
+ * Return an object fragment with a specific key,
+ * only if the value is defined. (accept null, but not undefined)
+ * 
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {V | undefined} value - A value
+ * @returns {{ [P in K]?: V }} - An object fragment with a single key/value at most
+ */
+function Value(key, value) {
+    if (value === undefined) {
+        return /** @type {{ [P in K]?: V }} */ ({});
+    }
+
+    return /** @type {{ [P in K]?: V }} */ ({ [key]: value });
+}
+
+/**
+ * Return a new plain object containing keys with defined values only. (accept null)
+ *
+ * @template {Record<string, any>} T
+ * @param {T=} object
+ * @returns {{ [K in keyof T]?: T[K] }}
+ */
+function Optional(object) {
+    var key, output = {};
+
+    for (key in object) {
+        if (object[key] !== undefined) {
+            output[key] = object[key];
+        }
+    }
+
+    return output;
+}
+
+/**
+ * Return an object fragment with a specific key
+ * only if the key exists AND validation is passed.
+ *
+ * @template {string} K
+ * @template V
+ * @param {K} key - A property name
+ * @param {*} object - Any target that may have properties (objects or primitives)
+ * @param {((value: any, options: Options) => V)} [validator] - An optional validation function
+ * @param {Options=} options - Options for validation.
+ * @returns {{ [P in K]?: V }}
+ */
+function Prop(key, object, validator, options) {
+    var value = object != null ? object[key] : undefined;
+
+    if (validator instanceof Function) {
+        value = validator(value, { ...options, name: key });
+    }
+
+    if (object == null || !Object.prototype.hasOwnProperty.call(object, key)) {
+        return /** @type {{ [P in K]?: V }} */ ({});
+    }
+
+    return /** @type {{ [P in K]?: V }} */ ({
+        [key]: value
+    });
+}
+
 /**
  * Validate an input being a function
  *
@@ -273,6 +418,9 @@ module.exports = {
     Boolean,
     Array,
     Object,
+    PropIf, Prop,
+    AssignIf, Assign,
+    Value, Optional,
     Function,
     AsyncFunction,
     Date,