hono 2.2.4 → 2.3.0

package/dist/middleware/validator/validator.js

@@ -1,26 +1,106 @@
-import { JSONPath } from '../../utils/json';
+import { JSONPathCopy } from '../../utils/json';
 import { rule } from './rule';
 import { sanitizer } from './sanitizer';
+export class VObjectBase {
+    constructor(container, key) {
+        this.keys = [];
+        this._isOptional = false;
+        this.getValidators = () => {
+            const validators = [];
+            const thisKeys = [];
+            Object.assign(thisKeys, this.keys);
+            const walk = (container, keys, isOptional) => {
+                for (const v of Object.values(container)) {
+                    if (v instanceof VArray || v instanceof VObject) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        isOptional || (isOptional = v._isOptional);
+                        keys.push(...v.keys);
+                        walk(v.container, keys, isOptional);
+                        const tmp = [];
+                        Object.assign(tmp, thisKeys);
+                        keys = tmp;
+                    }
+                    else if (v instanceof VBase) {
+                        if (isOptional)
+                            v.isOptional();
+                        v.baseKeys.push(...keys);
+                        validators.push(v);
+                    }
+                }
+            };
+            walk(this.container, this.keys, this._isOptional);
+            return validators;
+        };
+        this.container = container;
+        if (this instanceof VArray) {
+            this.keys.push(key, '[*]');
+        }
+        else if (this instanceof VObject) {
+            this.keys.push(key);
+        }
+    }
+    isOptional() {
+        this._isOptional = true;
+        return this;
+    }
+}
+export class VObject extends VObjectBase {
+    constructor(container, key) {
+        super(container, key);
+    }
+}
+export class VArray extends VObjectBase {
+    constructor(container, key) {
+        super(container, key);
+        this.type = 'array';
+    }
+}
 export class Validator {
     constructor() {
+        this.isArray = false;
         this.query = (key) => new VString({ target: 'query', key: key });
         this.header = (key) => new VString({ target: 'header', key: key });
         this.body = (key) => new VString({ target: 'body', key: key });
-        this.json = (key) => new VString({ target: 'json', key: key });
+        this.json = (key) => {
+            if (this.isArray) {
+                return new VStringArray({ target: 'json', key: key });
+            }
+            else {
+                return new VString({ target: 'json', key: key });
+            }
+        };
+        this.array = (path, validator) => {
+            this.isArray = true;
+            const res = validator(this);
+            const arr = new VArray(res, path);
+            return arr;
+        };
+        this.object = (path, validator) => {
+            this.isArray = false;
+            const res = validator(this);
+            const obj = new VObject(res, path);
+            return obj;
+        };
     }
 }
 export class VBase {
     constructor(options) {
-        this.addRule = (rule) => {
-            this.rules.push(rule);
-            return this;
-        };
+        this.baseKeys = [];
+        this._nested = () => (this.baseKeys.length ? true : false);
         this.addSanitizer = (sanitizer) => {
             this.sanitizers.push(sanitizer);
             return this;
         };
+        this.message = (text) => {
+            const len = this.rules.length;
+            if (len >= 1) {
+                this.rules[len - 1].customMessage = text;
+            }
+            return this;
+        };
         this.isRequired = () => {
-            return this.addRule((value) => {
+            return this.addRule('isRequired', (value) => {
                 if (value !== undefined && value !== null && value !== '')
                     return true;
                 return false;
@@ -28,34 +108,28 @@ export class VBase {
         };
         this.isOptional = () => {
             this._optional = true;
-            return this.addRule(() => true);
+            return this.addRule('isOptional', () => true);
         };
         this.isEqual = (comparison) => {
-            return this.addRule((value) => {
+            return this.addRule('isEqual', (value) => {
                 return value === comparison;
             });
         };
         this.asNumber = () => {
-            const newVNumber = new VNumber(this);
+            const newVNumber = new VNumber({ ...this, type: 'number' });
+            if (this.isArray)
+                return newVNumber.asArray();
             return newVNumber;
         };
         this.asBoolean = () => {
-            const newVBoolean = new VBoolean(this);
+            const newVBoolean = new VBoolean({ ...this, type: 'boolean' });
+            if (this.isArray)
+                return newVBoolean.asArray();
             return newVBoolean;
         };
-        this.asObject = () => {
-            const newVObject = new VObject(this);
-            return newVObject;
-        };
         this.validate = async (req) => {
-            const result = {
-                isValid: true,
-                message: undefined,
-                target: this.target,
-                key: this.key,
-                value: undefined,
-            };
             let value = undefined;
+            let jsonData = undefined;
             if (this.target === 'query') {
                 value = req.query(this.key);
             }
@@ -67,105 +141,178 @@ export class VBase {
                 value = body[this.key];
             }
             if (this.target === 'json') {
+                if (this._nested()) {
+                    this.key = `${this.baseKeys.join('.')}.${this.key}`;
+                }
+                let obj = {};
                 try {
-                    const obj = (await req.json());
-                    value = JSONPath(obj, this.key);
+                    obj = (await req.json());
                 }
                 catch (e) {
                     throw new Error('Malformed JSON in request body');
                 }
+                const dst = {};
+                value = JSONPathCopy(obj, dst, this.key);
+                if (this._nested())
+                    jsonData = dst;
             }
-            result.value = value;
-            result.isValid = this.validateValue(value);
-            if (result.isValid === false) {
-                if (this._message) {
-                    result.message = this._message;
+            const results = [];
+            let typeRule = this.rules.shift();
+            for (const rule of this.rules) {
+                if (rule.type === 'type') {
+                    typeRule = rule;
                 }
-                else {
-                    const valToStr = Array.isArray(value)
-                        ? `[${value
-                            .map((val) => val === undefined ? 'undefined' : typeof val === 'string' ? `"${val}"` : val)
-                            .join(', ')}]`
-                        : value;
-                    switch (this.target) {
-                        case 'query':
-                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${valToStr}`;
-                            break;
-                        case 'header':
-                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${valToStr}`;
-                            break;
-                        case 'body':
-                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${valToStr}`;
-                            break;
-                        case 'json':
-                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${valToStr}`;
-                            break;
-                    }
+                else if (rule.type === 'value') {
+                    const result = this.validateRule(rule, value);
+                    result.jsonData || (result.jsonData = jsonData);
+                    results.push(result);
                 }
             }
-            return result;
+            if (typeRule) {
+                const typeResult = this.validateRule(typeRule, value);
+                typeResult.jsonData || (typeResult.jsonData = jsonData);
+                results.unshift(typeResult);
+            }
+            return results;
         };
-        this.validateValue = (value) => {
-            // Check type
+        this.validateType = (value) => {
             if (this.isArray) {
                 if (!Array.isArray(value)) {
                     return false;
                 }
                 for (const val of value) {
-                    if (typeof val !== this.type) {
-                        // Value is of wrong type here
-                        // If not optional, or optional and not undefined, return false
-                        if (!this._optional || typeof val !== 'undefined')
-                            return false;
+                    if (typeof val === 'undefined' && this._nested()) {
+                        value.pop();
                     }
-                }
-                // Sanitize
-                for (const sanitizer of this.sanitizers) {
-                    value = value.map((innerVal) => sanitizer(innerVal));
-                }
-                for (const rule of this.rules) {
                     for (const val of value) {
-                        if (!rule(val)) {
-                            return false;
+                        if (typeof val !== this.type) {
+                            // Value is of wrong type here
+                            // If it is not optional and not undefined, return false
+                            if (!this._optional || typeof val !== 'undefined')
+                                return false;
                         }
                     }
                 }
-                return true;
             }
             else {
                 if (typeof value !== this.type) {
-                    if (this._optional && typeof value === 'undefined') {
+                    if (this._optional && (typeof value === 'undefined' || Array.isArray(value))) {
                         // Do nothing.
-                        // The value is allowed to be `undefined` if it is `optional`
+                        // If it is optional it's OK to be `undefined` or Array
                     }
                     else {
                         return false;
                     }
                 }
+            }
+            return true;
+        };
+        this.validateValue = (func, value) => {
+            if (Array.isArray(value)) {
                 // Sanitize
                 for (const sanitizer of this.sanitizers) {
-                    value = sanitizer(value);
+                    value = value.map((innerVal) => sanitizer(innerVal));
                 }
-                for (const rule of this.rules) {
-                    if (!rule(value)) {
+                for (const val of value) {
+                    if (!func(val)) {
                         return false;
                     }
                 }
                 return true;
             }
+            else {
+                // Sanitize
+                for (const sanitizer of this.sanitizers) {
+                    value = sanitizer(value);
+                }
+                if (!func(value)) {
+                    return false;
+                }
+                return true;
+            }
+        };
+        this.getMessage = (opts) => {
+            let keyText;
+            const valueText = Array.isArray(opts.value)
+                ? `${opts.value
+                    .map((val) => val === undefined ? 'undefined' : typeof val === 'string' ? `"${val}"` : val)
+                    .join(', ')}`
+                : opts.value;
+            switch (this.target) {
+                case 'query':
+                    keyText = `the query parameter "${this.key}"`;
+                    break;
+                case 'header':
+                    keyText = `the request header "${this.key}"`;
+                    break;
+                case 'body':
+                    keyText = `the request body "${this.key}"`;
+                    break;
+                case 'json':
+                    keyText = `the JSON body "${this.key}"`;
+                    break;
+            }
+            return `Invalid Value [${valueText}]: ${keyText} is invalid - ${opts.ruleName}`;
         };
         this.target = options.target;
         this.key = options.key;
         this.type = options.type || 'string';
-        this.rules = [];
+        this.rules = [
+            {
+                name: this.getTypeRuleName(),
+                type: 'type',
+                func: this.validateType,
+            },
+        ];
         this.sanitizers = [];
-        this.isArray = options.isArray || false;
         this._optional = false;
+        this.isArray = options.isArray || false;
+    }
+    addRule(arg, func) {
+        if (typeof arg === 'string' && func) {
+            this.rules.push({ name: arg, func, type: 'value' });
+        }
+        else if (arg instanceof Function) {
+            this.rules.push({ name: arg.name, func: arg, type: 'value' });
+        }
+        return this;
     }
-    message(value) {
-        this._message = value;
+    get(value) {
+        const len = this.rules.length;
+        if (len > 0) {
+            this.rules[this.rules.length - 1].customMessage = value;
+        }
         return this;
     }
+    getTypeRuleName() {
+        const prefix = 'should be';
+        return this.isArray ? `${prefix} "${this.type}[]"` : `${prefix} "${this.type}"`;
+    }
+    validateRule(rule, value) {
+        let isValid = false;
+        if (this._nested() && this.target != 'json') {
+            isValid = false;
+        }
+        else if (rule.type === 'value') {
+            isValid = this.validateValue(rule.func, value);
+        }
+        else if (rule.type === 'type') {
+            isValid = this.validateType(value);
+        }
+        const message = isValid
+            ? undefined
+            : rule.customMessage || this.getMessage({ ruleName: rule.name, value });
+        const result = {
+            isValid: isValid,
+            message: message,
+            target: this.target,
+            key: this.key,
+            value,
+            ruleName: rule.name,
+            ruleType: rule.type,
+        };
+        return result;
+    }
 }
 export class VString extends VBase {
     constructor(options) {
@@ -174,28 +321,28 @@ export class VString extends VBase {
             return new VStringArray(this);
         };
         this.isEmpty = (options = { ignore_whitespace: false }) => {
-            return this.addRule((value) => rule.isEmpty(value, options));
+            return this.addRule('isEmpty', (value) => rule.isEmpty(value, options));
         };
         this.isLength = (options, arg2) => {
-            return this.addRule((value) => rule.isLength(value, options, arg2));
+            return this.addRule('isLength', (value) => rule.isLength(value, options, arg2));
         };
         this.isAlpha = () => {
-            return this.addRule((value) => rule.isAlpha(value));
+            return this.addRule('isAlpha', (value) => rule.isAlpha(value));
         };
         this.isNumeric = () => {
-            return this.addRule((value) => rule.isNumeric(value));
+            return this.addRule('isNumeric', (value) => rule.isNumeric(value));
         };
         this.contains = (elem, options = {
             ignoreCase: false,
             minOccurrences: 1,
         }) => {
-            return this.addRule((value) => rule.contains(value, elem, options));
+            return this.addRule('contains', (value) => rule.contains(value, elem, options));
         };
         this.isIn = (options) => {
-            return this.addRule((value) => rule.isIn(value, options));
+            return this.addRule('isIn', (value) => rule.isIn(value, options));
         };
         this.match = (regExp) => {
-            return this.addRule((value) => rule.match(value, regExp));
+            return this.addRule('match', (value) => rule.match(value, regExp));
         };
         this.trim = () => {
             return this.addSanitizer((value) => sanitizer.trim(value));
@@ -210,10 +357,10 @@ export class VNumber extends VBase {
             return new VNumberArray(this);
         };
         this.isGte = (min) => {
-            return this.addRule((value) => rule.isGte(value, min));
+            return this.addRule('isGte', (value) => rule.isGte(value, min));
         };
         this.isLte = (min) => {
-            return this.addRule((value) => rule.isLte(value, min));
+            return this.addRule('isLte', (value) => rule.isLte(value, min));
         };
         this.type = 'number';
     }
@@ -225,35 +372,32 @@ export class VBoolean extends VBase {
             return new VBooleanArray(this);
         };
         this.isTrue = () => {
-            return this.addRule((value) => rule.isTrue(value));
+            return this.addRule('isTrue', (value) => rule.isTrue(value));
         };
         this.isFalse = () => {
-            return this.addRule((value) => rule.isFalse(value));
+            return this.addRule('isFalse', (value) => rule.isFalse(value));
         };
         this.type = 'boolean';
     }
 }
-export class VObject extends VBase {
-    constructor(options) {
-        super(options);
-        this.type = 'object';
-    }
-}
 export class VNumberArray extends VNumber {
     constructor(options) {
         super(options);
         this.isArray = true;
+        this.rules[0].name = this.getTypeRuleName();
     }
 }
 export class VStringArray extends VString {
     constructor(options) {
         super(options);
         this.isArray = true;
+        this.rules[0].name = this.getTypeRuleName();
     }
 }
 export class VBooleanArray extends VBoolean {
     constructor(options) {
         super(options);
         this.isArray = true;
+        this.rules[0].name = this.getTypeRuleName();
     }
 }

package/dist/utils/json.d.ts

@@ -4,4 +4,4 @@ export declare type JSONObject = {
     [key: string]: JSONPrimitive | JSONArray | JSONObject;
 };
 export declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
-export declare const JSONPath: (data: JSONObject, path: string) => JSONValue;
+export declare const JSONPathCopy: (src: JSONObject, dst: JSONObject, path: string) => JSONPrimitive | JSONObject | JSONArray;

package/dist/utils/json.js

@@ -1,27 +1,81 @@
-const JSONPathInternal = (data, parts) => {
+const JSONPathCopyInternal = (src, dst, parts, results) => {
+    let srcVal = src;
+    let dstVal = dst;
     const length = parts.length;
-    for (let i = 0; i < length && data !== undefined; i++) {
+    for (let i = 0; i < length && srcVal !== undefined && dstVal; i++) {
         const p = parts[i];
-        if (p === '') {
-            continue;
+        if (typeof srcVal !== 'object') {
+            return srcVal;
         }
-        if (typeof data !== 'object' || data === null) {
+        if (srcVal === null) {
             return undefined;
         }
         if (p === '*') {
             const restParts = parts.slice(i + 1);
-            const values = Object.values(data).map((v) => JSONPathInternal(v, restParts));
-            return restParts.indexOf('*') === -1 ? values : values.flat();
+            const restLength = srcVal.length;
+            if (restLength === undefined) {
+                parts = Object.keys(srcVal);
+                for (const p of parts) {
+                    const srcVal2 = srcVal;
+                    const dst2 = {};
+                    JSONPathCopyInternal(srcVal2, dst2, [p], results);
+                    dstVal[p] = dst2[p];
+                }
+            }
+            else {
+                const res = [];
+                for (let i2 = 0; i2 < restLength; i2++) {
+                    if (typeof srcVal[i2] !== 'object' || srcVal[i2] === undefined) {
+                        res.push(srcVal[i2]);
+                    }
+                    else {
+                        const srcVal2 = srcVal[i2];
+                        const dst2 = {};
+                        const res2 = JSONPathCopyInternal(srcVal2, dst2, restParts, results);
+                        if (res2 === undefined)
+                            results.push(undefined);
+                        dstVal[i2] = dst2;
+                    }
+                }
+                if (res.length) {
+                    Object.assign(dstVal, srcVal);
+                    results.push(...res);
+                }
+            }
+            return results;
+        }
+        if (typeof srcVal[p] === 'object') {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            dstVal[p] || (dstVal[p] = new srcVal[p].constructor());
+        }
+        else if (typeof srcVal[p] !== 'undefined') {
+            dstVal[p] = srcVal[p];
         }
         else {
-            data = data[p]; // `data` may be an array, but accessing it as an object yields the same result.
+            return undefined;
         }
+        srcVal = srcVal[p];
+        dstVal = dstVal[p];
+    }
+    if (typeof srcVal === 'object' && dstVal) {
+        Object.assign(dstVal, srcVal);
     }
-    return data;
+    results.push(srcVal);
+    return results;
 };
-export const JSONPath = (data, path) => {
+export const JSONPathCopy = (src, dst, path) => {
+    const results = [];
+    const parts = path.replace(/\.?\[(.*?)\]/g, '.$1').split(/\./);
     try {
-        return JSONPathInternal(data, path.replace(/\[(.*?)\]/g, '.$1').split(/\./));
+        JSONPathCopyInternal(src, dst, parts, results);
+        if (results.length === 0) {
+            return undefined;
+        }
+        else if (results.length === 1 && !parts.includes('*')) {
+            return results[0];
+        }
+        return results;
     }
     catch (e) {
         return undefined;

package/dist/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare const isObject: (val: any) => boolean;
+export declare const mergeObjects: (target: any, source: any) => any;

package/dist/utils/object.js

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val);
+export const mergeObjects = (target, source) => {
+    const merged = Object.assign({}, target);
+    if (isObject(target) && isObject(source)) {
+        for (const key of Object.keys(source)) {
+            if (isObject(source[key])) {
+                if (target[key] === undefined)
+                    Object.assign(merged, { [key]: source[key] });
+                else
+                    merged[key] = mergeObjects(target[key], source[key]);
+            }
+            else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
+                const srcArr = source[key];
+                const tgtArr = target[key];
+                const outArr = [];
+                for (let i = 0; i < srcArr.length; i += 1) {
+                    // If corresponding index for both arrays is an object, then merge them
+                    // Otherwise just copy src arr index into out arr index
+                    if (isObject(srcArr[i]) && isObject(tgtArr[i])) {
+                        outArr[i] = mergeObjects(tgtArr[i], srcArr[i]);
+                    }
+                    else {
+                        outArr[i] = srcArr[i];
+                    }
+                }
+                Object.assign(merged, { [key]: outArr });
+            }
+            else {
+                Object.assign(merged, { [key]: source[key] });
+            }
+        }
+    }
+    return merged;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "module": "dist/index.js",