validno 0.1.10 → 0.2.0

package/dist/Schema.js

@@ -5,7 +5,8 @@ export const defaultSchemaKeys = [
     "eachType",
     "rules",
     "title",
-    "customMessage"
+    "customMessage",
+    "joinErrors"
 ];
 export class Schema {
     constructor(inputSchema) {

package/dist/checkType.js

@@ -1,31 +1,12 @@
 import { ErrorKeywords } from "./constants/details.js";
 import _validations from "./utils/validations.js";
-const getErrorDetails = (key, expectedType, receivedValue) => {
-    let receivedType = '';
-    if (typeof receivedValue === 'string')
-        receivedType = 'String';
-    else if (typeof receivedValue === 'number')
-        receivedType = 'Number';
-    else if (typeof receivedValue === 'boolean')
-        receivedType = 'Noolean';
-    else if (receivedValue === null)
-        receivedType = 'null';
-    else if (Array.isArray(receivedValue))
-        receivedType = 'Array';
-    else if (_validations.isDate(receivedValue))
-        receivedType = 'Date';
-    else if (_validations.isObject(receivedValue))
-        receivedType = 'Object';
-    else if (receivedValue === undefined)
-        receivedType = 'undefined';
-    return `Проверьте тип "${key}": ожидался ${(expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType}, получен ${receivedType || 'unknown'}`;
-};
+import _errors from "./utils/errors.js";
 const checkTypeMultiple = (key, value, requirements, keyName = key) => {
     const constructorNames = requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el));
     const result = {
         key: keyName,
         passed: false,
-        details: getErrorDetails(keyName, constructorNames.join('/'), value)
+        details: _errors.getErrorDetails(keyName, constructorNames.join('/'), value)
     };
     let i = 0;
     while (i < requirements.type.length) {
@@ -69,9 +50,10 @@ const checkType = (key, value, requirements, keyName = key) => {
             schema: null
         }) :
         null;
-    const baseErrDetails = getErrorDetails(keyName, requirements.type, value);
+    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
     const getDetails = (isOK) => isOK ? 'OK' : customErrDetails || baseErrDetails;
-    switch (requirements.type) {
+    const typeBySchema = requirements.type;
+    switch (typeBySchema) {
         case 'any':
             result.push({
                 key: keyName,
@@ -166,10 +148,13 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             break;
         default:
+            const isInstanceOf = value instanceof typeBySchema;
+            const isConstructorSame = value.constructor.name === typeBySchema.name;
+            const checked = isInstanceOf && isConstructorSame;
             result.push({
                 key: keyName,
-                passed: false,
-                details: `Тип '${keyName}' не определен`
+                passed: checked,
+                details: getDetails(checked)
             });
     }
     return result;

package/dist/dev.js

@@ -1,63 +1,52 @@
 import { Schema } from "./Schema.js";
+class Parent {
+    constructor(value) {
+        this.value = value;
+        this.version = 1;
+    }
+    getV() {
+        return this.version;
+    }
+}
+class Child extends Parent {
+    constructor(value) {
+        super(value);
+        this.isDeep = true;
+    }
+}
+const testCust = new Parent(12345678);
+const testCust2 = new Child(12345678);
 const schema = new Schema({
-    wrongType: {
-        type: Number,
+    parent1: {
+        type: Parent,
         required: true,
-        title: 'Не по типу',
-        customMessage: (input) => {
-            return 'wrong type 1 msg ' + input.keyword;
-        }
+        title: 'custom class test',
     },
-    missingKey: {
-        type: Date,
+    child1: {
+        type: Child,
         required: true,
-        title: 'Отсутствующий',
-        customMessage: (input) => {
-            return 'missing msg ' + input.keyword;
-        }
+        title: 'custom class test',
     },
-    wrongRule1: {
-        type: String,
-        required: true,
-        title: 'Wrong Rule #1',
-        rules: {
-            is: 'xxx'
-        },
-        customMessage: (input) => {
-            return 'wrong rule #1 msg ' + input.keyword;
-        }
-    },
-    wrongRule2: {
-        type: String,
-        required: true,
-        title: 'Wrong Rule #2',
-        rules: {
-            lengthMin: 999
-        },
-        customMessage: (input) => {
-            return 'wrong rule #2 msg ' + input.keyword;
-        }
+    parent2: {
+        type: Parent,
+        required: true
     },
-    wrongRule3: {
-        type: String,
+    err: {
+        type: Error,
         required: true,
-        title: 'Wrong Rule #3',
-        rules: {
-            lengthMax: 1
-        },
-        customMessage: (input) => {
-            const { keyword, value, key, title, reqs, schema, rules } = input;
-            if (keyword === 'lengthMax') {
-                return `Значение ${value} недопустимо для поля ${title}. Минимальная длина ${rules.lengthMax} символов`;
-            }
-            return 'Проверьте значение, кажется, что-то не в порядке';
-        }
+        title: 'custom class test',
     },
+    func: {
+        type: Function,
+        required: false,
+    }
 });
 const obj = {
-    wrongType: 'String',
-    wrongRule1: 'qwertyuiop',
-    wrongRule2: 'asdfghjkl',
-    wrongRule3: 'zxcvbnmasd'
+    parent1: testCust,
+    child1: testCust2,
+    parent2: testCust2,
+    err: new Error('ops'),
+    func: () => { console.log('ya tut'); }
 };
-console.log('finalResult', schema.validate(obj));
+const res = schema.validate(obj);
+console.log(res);

package/dist/utils/errors.js

@@ -1,3 +1,17 @@
 const _errors = {};
 _errors.getMissingError = (key) => `Ключ '${key}' отсутствует`;
+_errors.getErrorDetails = (key, expectedType, receivedValue) => {
+    var _a;
+    let receivedType = '';
+    if (receivedValue === undefined)
+        receivedType = 'undefined';
+    else if (receivedValue === null)
+        receivedType = 'null';
+    else
+        receivedType = ((_a = receivedValue.constructor) === null || _a === void 0 ? void 0 : _a.name) || typeof receivedValue || 'na';
+    return `Проверьте тип "${key}": ожидался ${(expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType}, получен ${receivedType || 'unknown'}`;
+};
+_errors.joinErrors = (errorsArr, separator = '; ') => {
+    return (errorsArr === null || errorsArr === void 0 ? void 0 : errorsArr.join(`${separator}`)) || '';
+};
 export default _errors;

package/dist/validate.js

@@ -1,9 +1,9 @@
-import checkRules from "./checkRules.js";
 import checkType from "./checkType.js";
 import _errors from "./utils/errors.js";
+import checkRules from "./checkRules.js";
 import _validations from "./utils/validations.js";
-import { defaultSchemaKeys } from "./Schema.js";
 import { ErrorKeywords } from "./constants/details.js";
+import { defaultSchemaKeys } from "./Schema.js";
 export const getResultDefaults = () => {
     return {
         ok: null,
@@ -62,7 +62,9 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         }
         return results;
     }
-    if (reqs.required === true && key in data === false || data === undefined) {
+    if (reqs.required === true &&
+        (key in data === false || data === undefined || data[key] === undefined)) {
+        console.log(data);
         let errMsg = _errors.getMissingError(deepKey);
         if (reqs.customMessage && typeof reqs.customMessage === 'function') {
             errMsg = reqs.customMessage({
@@ -78,6 +80,9 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         results.missed.push(deepKey);
         results.failed.push(deepKey);
         results.errors.push(errMsg);
+        if (deepKey in results.errorsByKeys === false)
+            results.errorsByKeys[deepKey] = [];
+        results.errorsByKeys[deepKey].push(errMsg);
         results.byKeys[deepKey] = false;
         return results;
     }
@@ -129,7 +134,22 @@ function validate(schema, data, onlyKeys) {
         results.ok = false;
     else
         results.ok = true;
-    return results;
+    return new ValidnoResult(results);
 }
 ;
+class ValidnoResult {
+    constructor(results) {
+        this.ok = results.ok;
+        this.missed = results.missed;
+        this.failed = results.failed;
+        this.passed = results.passed;
+        this.errors = results.errors;
+        this.byKeys = results.byKeys;
+        this.errorsByKeys = results.errorsByKeys;
+        this.byKeys = results.byKeys;
+    }
+    joinErrors(separator = '; ') {
+        return _errors.joinErrors(this.errors, separator);
+    }
+}
 export default validate;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "validno",
-  "version": "0.1.10",
+  "version": "0.2.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc -b src/",
     "tsc-watch": "tsc --b --watch src/",
+    "tscw": "tsc --b --watch src/",
     "dev": "nodemon dist/dev.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },