validno 0.3.0 → 0.3.2

package/README.md

@@ -1 +1,517 @@
-#TODO
+# Validno
+
+A lightweight and flexible TypeScript validation library for Node.js applications.
+
+## Installation
+
+```bash
+npm i validno
+```
+
+## Quick Start
+
+```javascript
+import Schema from 'validno';
+
+// Define your schema
+const userSchema = new Schema({
+  name: {
+    type: String,
+    required: true,
+    rules: {
+      lengthMin: 2,
+      lengthMax: 50
+    }
+  },
+  email: {
+    type: String,
+    required: true,
+    rules: {
+      isEmail: true
+    }
+  },
+  age: {
+    type: Number,
+    required: false,
+    rules: {
+      min: 18,
+      max: 120
+    }
+  }
+});
+
+// Validate data
+const userData = {
+  name: "Barney Stinson",
+  email: "barney@himym.com",
+  age: 35
+};
+
+const result = userSchema.validate(userData);
+
+if (result.ok) {
+  console.log('Validation passed!');
+} else {
+  console.log('Errors:', result.errors);
+}
+```
+
+## Features
+
+- **Type Validation**: Support for built-in types (String, Number, Boolean, Array, Object, Date, RegExp) and custom types
+- **Flexible Rules**: Comprehensive set of validation rules for strings, numbers, arrays, and custom logic
+- **Nested Objects**: Full support for nested object validation
+- **Custom Messages**: Define custom error messages for validation failures
+- **Partial Validation**: Validate only specific keys when needed
+- **TypeScript Support**: Written in TypeScript with full type definitions
+
+## Schema Definition
+
+### Basic Schema Structure
+
+```javascript
+const schema = new Schema({
+  fieldName: {
+    type: String,           // Required: field type
+    required: true,         // Optional: whether field is required (default: true)
+    rules: {},             // Optional: validation rules
+    title: "Field Name",   // Optional: human-readable field name (only used in custom messages for now)
+    customMessage: (details) => "Custom error" // Optional: custom error function
+  }
+});
+```
+
+### Supported Types
+
+```javascript
+const schema = new Schema({
+  stringField: { type: String },
+  numberField: { type: Number },
+  booleanField: { type: Boolean },
+  arrayField: { type: Array },
+  objectField: { type: Object },
+  dateField: { type: Date },
+  regexField: { type: RegExp },
+  nullField: { type: null },
+  
+  // Union types (multiple allowed types)
+  mixedField: { type: [String, Number] },
+  
+  // Custom classes
+  customField: { type: MyCustomClass },
+  
+  // Any type
+  anyField: { type: 'any' }
+});
+```
+
+### Array Type Validation
+
+```javascript
+const schema = new Schema({
+  // Array of any items
+  items: { type: Array },
+  
+  // Array where each item must be a specific type
+  numbers: { 
+    type: Array, 
+    eachType: Number, 
+  }
+});
+```
+
+## Validation Rules
+
+### String Rules
+
+```javascript
+const schema = new Schema({
+  text: {
+    type: String,
+    rules: {
+      // Length validations
+      length: 10,              // Exact length
+      lengthMin: 5,           // Minimum length
+      lengthMax: 100,         // Maximum length
+      lengthMinMax: [5, 100], // Length range
+      lengthNot: 0,           // Not this length
+      
+      // Format validations
+      isEmail: true,          // Valid email format
+      regex: /^[A-Z]+$/,      // Custom regex pattern
+      
+      // Value comparisons
+      is: "exact value",      // Must equal this value
+      isNot: "forbidden"      // Must not equal this value
+    }
+  }
+});
+```
+
+### Number Rules
+
+```javascript
+const schema = new Schema({
+  count: {
+    type: Number,
+    rules: {
+      min: 0,              // Minimum value (>=)
+      max: 100,            // Maximum value (<=)
+      minMax: [0, 100],    // Value range
+      is: 42,              // Must equal this value
+      isNot: 0             // Must not equal this value
+    }
+  }
+});
+```
+
+### Array Rules
+
+```javascript
+const schema = new Schema({
+  items: {
+    type: Array,
+    rules: {
+      length: 5,              // Exact length
+      lengthMin: 1,          // Minimum length
+      lengthMax: 10,         // Maximum length
+      lengthMinMax: [1, 10], // Length range
+      enum: ['a', 'b', 'c']  // All items must be from this list
+    }
+  }
+});
+```
+
+### Custom Rules
+
+```javascript
+const schema = new Schema({
+  password: {
+    type: String,
+    rules: {
+      custom: (value, { schema, input }) => {
+        // Custom validation logic
+        const hasUpperCase = /[A-Z]/.test(value);
+        const hasLowerCase = /[a-z]/.test(value);
+        const hasNumbers = /\d/.test(value);
+
+        const isPassed = hasUpperCase && hasLowerCase && hasNumbers
+        
+        // Return true or false value...
+        return isPassed
+
+        // ...or provide details for the validation
+        return {
+          result: isPassed,
+          details: isPassed ? '' : "Password must contain an uppercase letter, a lowercase letter, and a number"
+        }
+      }
+    }
+  }
+});
+```
+
+### Enum Validation
+
+```javascript
+const schema = new Schema({
+  status: {
+    type: String,
+    rules: {
+      enum: ['active', 'inactive', 'pending']
+    }
+  }
+});
+```
+
+## Nested Objects
+
+```javascript
+const schema = new Schema({
+  user: {
+    name: {
+      type: String,
+      required: true
+    },
+    address: {
+      street: {
+        type: String,
+        required: true
+      },
+      city: {
+        type: String,
+        required: true
+      },
+      zipCode: {
+        type: String,
+        required: false,
+        rules: {
+          regex: /^\d{5}$/
+        }
+      }
+    }
+  }
+});
+
+const data = {
+  user: {
+    name: "Barney Stinson",
+    address: {
+      street: "123 Main St",
+      city: "New York",
+      zipCode: "10001"
+    }
+  }
+};
+
+const result = schema.validate(data);
+```
+
+## Custom Error Messages
+
+### Field-Level Custom Messages
+
+```javascript
+const schema = new Schema({
+  email: {
+    type: String,
+    required: true,
+    rules: {
+      isEmail: true
+    },
+    customMessage: ({ keyword, value, key }) => {
+      if (keyword === 'isEmail') {
+        return `Please enter a valid email address for ${key}`;
+      }
+      return `Invalid value for ${key}`;
+    }
+  }
+});
+```
+
+### Custom Message Parameters
+
+The `customMessage` function receives an object with:
+- `keyword`: The validation rule that failed
+- `value`: The actual value being validated
+- `key`: The field name
+- `title`: The field title (if specified)
+- `reqs`: The field requirements object
+- `schema`: The full schema object
+- `rules`: The rules object for this field
+
+## Partial Validation
+
+Validate only specific fields:
+
+```javascript
+const schema = new Schema({
+  name: { type: String },
+  email: { type: String },
+  phone: { type: String }
+});
+
+const data = { name: "Barney", email: "barney@himym.com" };
+
+// Validate only the name field
+const nameResult = schema.validate(data, 'name');
+
+// Validate only name and email fields
+const partialResult = schema.validate(data, ['name', 'email']);
+```
+
+## Validation Result
+
+The `validate` method returns a result object with:
+
+```javascript
+{
+  ok: boolean,                    // Overall validation success
+  passed: string[],              // Array of field names that passed
+  failed: string[],              // Array of field names that failed
+  missed: string[],              // Array of required fields that were missing
+  errors: string[],              // Array of all error messages
+  byKeys: {                      // Validation status by field name
+    fieldName: boolean
+  },
+  errorsByKeys: {                // Error messages by field name
+    fieldName: string[]
+  },
+  joinErrors: (separator?) => string  // Method to join all errors
+}
+```
+
+### Using the Result
+
+```javascript
+const result = schema.validate(data);
+
+if (result.ok) {
+  console.log('All validations passed!');
+} else {
+  console.log('Failed fields:', result.failed);
+  console.log('Missing fields:', result.missed);
+  console.log('All errors:', result.joinErrors(', '));
+  
+  // Check specific field
+  if (!result.byKeys.email) {
+    console.log('Email errors:', result.errorsByKeys.email);
+  }
+}
+```
+
+## Built-in Validation Utilities
+
+Validno exports validation utilities that you can use independently:
+
+```javascript
+import { validations } from 'validno';
+
+// Type checks
+validations.isString(value);
+validations.isNumber(value);
+validations.isArray(value);
+validations.isObject(value);
+validations.isDate(value);
+validations.isBoolean(value);
+
+// String format validation
+validations.isEmail(email);
+validations.isDateYYYYMMDD(dateString);
+validations.isHex(colorCode);
+
+// Length validation
+validations.lengthIs(value, 5);
+validations.lengthMin(value, 2);
+validations.lengthMax(value, 10);
+
+// Number comparisons
+validations.isNumberGte(value, 10);
+validations.isNumberLt(value, 100);
+
+// Date comparisons
+validations.isDateLte(date1, date2);
+validations.isDateGt(date1, date2);
+
+// Deep equality
+validations.is(obj1, obj2);
+validations.not(value1, value2);
+
+// Regular expressions
+validations.regexTested(string, /pattern/);
+```
+
+## Advanced Examples
+
+### Complex Nested Validation
+
+```javascript
+const orderSchema = new Schema({
+  orderId: {
+    type: String,
+    required: true,
+    rules: {
+      regex: /^ORD-\d{6}$/
+    }
+  },
+  customer: {
+    id: {
+      type: Number,
+      required: true,
+      rules: {
+        min: 1
+      }
+    },
+    profile: {
+      firstName: {
+        type: String,
+        required: true,
+        rules: {
+          lengthMin: 2,
+          lengthMax: 50
+        }
+      },
+      lastName: {
+        type: String,
+        required: true,
+        rules: {
+          lengthMin: 2,
+          lengthMax: 50
+        }
+      },
+      email: {
+        type: String,
+        required: true,
+        rules: {
+          isEmail: true
+        }
+      }
+    }
+  },
+  items: {
+    type: Array,
+    eachType: Object,
+    required: true,
+    rules: {
+      lengthMin: 1
+    }
+  },
+  totalAmount: {
+    type: Number,
+    required: true,
+    rules: {
+      min: 0.01
+    }
+  },
+  status: {
+    type: String,
+    required: true,
+    rules: {
+      enum: ['pending', 'processing', 'shipped', 'delivered', 'cancelled']
+    }
+  }
+});
+```
+
+## TypeScript Support
+
+Validno is written in TypeScript and provides full type definitions:
+
+```typescript
+import Schema from 'validno';
+import { SchemaDefinition, FieldSchema } from 'validno';
+
+interface User {
+  name: string;
+  email: string;
+  age?: number;
+}
+
+const userSchema = new Schema({
+  name: {
+    type: String,
+    required: true
+  } as FieldSchema,
+  email: {
+    type: String,
+    required: true,
+    rules: {
+      isEmail: true
+    }
+  } as FieldSchema,
+  age: {
+    type: Number,
+    required: false
+  } as FieldSchema
+} as SchemaDefinition);
+
+const newUser = {
+  name: "Barney",
+  email: "barney@himym.com",
+}
+
+// Use generic type...
+const result = userSchema.validate<User>(newUser, ['name', 'email'])
+
+// ...or use automatic type inference based on the object
+const result = userSchema.validate(newUser, ['name', 'email'])

package/dist/Schema.js

@@ -10,6 +10,7 @@ export class Schema {
     }
     validate(inputData, validationKeys) {
         const engine = new ValidateEngine(this.definition);
-        return engine.validate(inputData, validationKeys);
+        const result = engine.validate(inputData, validationKeys);
+        return result;
     }
 }

package/dist/constants/details.js

@@ -8,4 +8,5 @@ export var ValidationDetails;
 (function (ValidationDetails) {
     ValidationDetails["OK"] = "OK";
     ValidationDetails["INVALID_DATE"] = "Invalid date";
+    ValidationDetails["CustomRuleFailed"] = "Custom rule failed";
 })(ValidationDetails || (ValidationDetails = {}));

package/dist/dev.js

@@ -1,70 +1,12 @@
 import Schema from './index.js';
 const schema = new Schema({
-    name: {
-        type: String,
-        required: true
-    },
-    lastVisit: {
-        type: Date,
-        required: true,
-    },
-    age: {
-        type: Number,
-        required: true,
-    },
-    email: {
-        type: String,
-        required: true,
-        rules: {
-            isEmail: true
-        }
-    },
-    isAwesome: {
-        type: Boolean,
-        required: true
-    },
-    friends: {
-        type: Array,
-        required: true,
-        eachType: String,
-    },
-    broRegex: {
-        type: RegExp,
-        required: true,
-    },
-    socials: {
-        x: {
-            type: String,
-            required: false
-        },
-        instagram: {
-            type: String,
-            required: false
-        }
-    },
-    nullableField: {
-        type: null,
-        required: false,
-    },
+    query: { type: Object },
+    data: { type: Object },
+    params: {
+        upsert: { type: Boolean, required: false },
+    }
 });
-const exampleObj = {
-    name: 'Barney Stinson',
-    age: 35,
-    lastVisit: new Date('2025-05-05'),
-    email: 'legggen@dary.com',
-    isAwesome: true,
-    friends: [
-        'Ted Mosby',
-        'Marshall Eriksen',
-        'Lily Aldrin',
-        'Robin Scherbatsky'
-    ],
-    socials: {
-        x: '@barney_stinson',
-        insstagram: '@barney_stinson'
-    },
-    broRegex: /bro/i,
-    deletedAt: null,
-};
-const validation = schema.validate(exampleObj);
-console.log(validation);
+console.log(schema.validate({
+    query: {},
+    data: {}
+}));

package/dist/engine/methods/handleKey.js

@@ -5,7 +5,7 @@ function validateKeyValue(params) {
     const missedCheck = [];
     const typeChecked = [];
     const rulesChecked = [];
-    if (hasMissing) {
+    if (hasMissing || !data) {
         return this.handleMissingKeyValidation({ results, key, nestedKey, data, reqs, missedCheck });
     }
     this.validateType({ results, key, value: data[key], reqs, nestedKey, typeChecked });

package/dist/engine/methods/validateRules.js

@@ -1,4 +1,5 @@
 import _validations from "../../utils/validations.js";
+import { ValidationDetails } from "../../constants/details.js";
 export const rulesParams = {
     lengthMin: {
         allowedTypes: [String]
@@ -13,7 +14,21 @@ const ensureRuleHasCorrectType = (value, allowedTypes) => {
 };
 const rulesFunctions = {
     custom: (key, val, func, extra) => {
-        return func(val, extra);
+        const customResult = func(val, extra);
+        if (typeof customResult === 'object' && 'result' in customResult) {
+            return {
+                result: customResult.result,
+                details: customResult.details || ValidationDetails.CustomRuleFailed,
+            };
+        }
+        if (typeof customResult === 'boolean') {
+            return {
+                result: customResult,
+                details: customResult ? "" : ValidationDetails.CustomRuleFailed
+            };
+        }
+        throw new Error(`Custom rule function must return an object with 'result' and 'details' properties or a boolean value. Received: ${typeof customResult}`);
+        return;
     },
     isEmail: (key, val) => {
         return {
@@ -110,7 +125,7 @@ const rulesFunctions = {
         return output;
     }
 };
-function unnamed(key, value, requirements, inputObj) {
+function checkRules(key, value, requirements, inputObj) {
     const result = {
         ok: true,
         details: []
@@ -133,7 +148,7 @@ function unnamed(key, value, requirements, inputObj) {
         }
         const func = rulesFunctions[ruleName];
         const args = rules[ruleName];
-        const result = func(key, value, args, { schema: this.schema, input: inputObj });
+        let result = func(key, value, args, { schema: this.schema, input: inputObj });
         if (requirements.customMessage && typeof requirements.customMessage === 'function') {
             result.details = requirements.customMessage({
                 keyword: ruleName,
@@ -158,7 +173,7 @@ function unnamed(key, value, requirements, inputObj) {
 ;
 function validateRules(input) {
     const { results, nestedKey, value, reqs, data, rulesChecked } = input;
-    const ruleCheck = unnamed.call(this, nestedKey, value, reqs, data);
+    const ruleCheck = checkRules.call(this, nestedKey, value, reqs, data);
     if (!ruleCheck.ok) {
         rulesChecked.push(false);
         ruleCheck.details.forEach((el) => {

package/dist/engine/methods/validateType.js

@@ -20,33 +20,34 @@ const validateUnionType = (key, value, requirements, keyName = key) => {
 };
 const handleTypeValidation = (key, value, requirements, keyName = key) => {
     var _a;
+    const reqs = Object.assign({ required: true }, requirements);
     const isNotNull = value !== null;
-    const keyTitle = 'title' in requirements ? requirements.title : keyName;
-    const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function';
-    if (value === undefined && requirements.required) {
+    const keyTitle = 'title' in reqs && reqs.title !== undefined ? reqs.title : keyName;
+    const hasCustomMessage = reqs.customMessage && typeof reqs.customMessage === 'function';
+    if (value === undefined && reqs.required) {
         return [_validateType.getResult(keyName, false, _errors.getMissingError(keyName))];
     }
-    if (Array.isArray(requirements.type)) {
-        return [validateUnionType(key, value, requirements)];
+    if (Array.isArray(reqs.type)) {
+        return [validateUnionType(key, value, reqs)];
     }
-    if (value === undefined && requirements.required !== true) {
+    if (value === undefined && reqs.required === false) {
         return [_validateType.getResult(keyName, true)];
     }
     const customErrDetails = hasCustomMessage ?
-        requirements.customMessage({
+        reqs.customMessage({
             keyword: ValidationIds.Type,
             value: value,
             key: keyName,
             title: keyTitle,
-            reqs: requirements,
-            schema: null
+            reqs: reqs,
+            schema: {}
         }) :
         null;
-    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
+    const baseErrDetails = _errors.getErrorDetails(keyName, reqs.type, value);
     const getDetails = (isOK, errorText) => isOK ?
         ValidationDetails.OK :
         errorText || customErrDetails || baseErrDetails;
-    const typeBySchema = requirements.type;
+    const typeBySchema = reqs.type;
     const result = [];
     switch (typeBySchema) {
         case 'any': {
@@ -82,9 +83,9 @@ const handleTypeValidation = (key, value, requirements, keyName = key) => {
                 break;
             }
             let isEachChecked = { passed: true, details: "" };
-            if ('eachType' in requirements) {
+            if ('eachType' in reqs) {
                 for (const el of value) {
-                    const result = handleTypeValidation(`each of ${key}`, el, { type: requirements.eachType, required: true });
+                    const result = handleTypeValidation(`each of ${key}`, el, { type: reqs.eachType, required: true });
                     if (!result[0].passed) {
                         isEachChecked.passed = false;
                         isEachChecked.details = result[0].details || '';

package/dist/utils/errors.js

@@ -5,17 +5,17 @@ class ErrorUtility {
     getErrorDetails(key, expectedType, receivedValue) {
         const receivedType = this.getTypeString(receivedValue);
         const expectedOutput = this.getExpectedTypeString(expectedType);
-
-        if (expectedOutput === receivedType) return '';
-
+        if (expectedOutput === receivedType) {
+            return '';
+        }
         return `Check the type of '${key}': expected ${expectedOutput}, received ${receivedType}`;
     }
     joinErrors(errorsArr, separator = '; ') {
-        let _a;
+        var _a;
         return ((_a = errorsArr === null || errorsArr === void 0 ? void 0 : errorsArr.filter(error => error === null || error === void 0 ? void 0 : error.trim())) === null || _a === void 0 ? void 0 : _a.join(separator)) || '';
     }
     getTypeString(value) {
-        let _a;
+        var _a;
         if (value === undefined)
             return 'undefined';
         if (value === null)

package/dist/utils/helpers.js

@@ -27,10 +27,8 @@ class HelperUtility {
     }
     hasMissing(input) {
         const { reqs, data, key } = input;
-        const isRequired = !!reqs.required;
-        const missingData = (data === undefined ||
-            !(key in data) ||
-            data[key] === undefined);
+        const isRequired = reqs.required === undefined || reqs.required === true;
+        const missingData = (data === undefined || !(key in data) || data[key] === undefined);
         return isRequired && missingData;
     }
     compareArrs(v1, v2) {

package/dist/utils/validations.js

@@ -10,7 +10,7 @@ class ValidationUtility {
         return Array.isArray(value);
     }
     isObject(value) {
-        let _a;
+        var _a;
         return value !== null &&
             typeof value === 'object' &&
             ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Object' &&

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "validno",
-  "version": "0.3.0",
-  "description": "",
+  "version": "0.3.2",
+  "description": "A lightweight TypeScript validation library for runtime data validation.",
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc -b src/",