arstotzka 0.11.2 → 0.12.1

package/index.js

@@ -5,32 +5,33 @@ export const ERRORS = {
 	extraProperty: "Provided object contains properties not present in schema",
 	exceptionOnCustom: "Exception thrown during constraint validation",
 	notArray: "Tried using ARRAY_OF constraint on non-array value",
-	targetIsNull: "Passed object or array item is null"
+	targetIsNull: "Passed object or array item is null",
+	functionExpected: "Expected function as dynamic constraint",
+	objectExpected: "Expected object"
 };
 
 export const OPTIONAL = Symbol();
-const FORBIDDEN_SIGNATURE = Symbol(); // https://www.youtube.com/watch?v=qSqXGeJJBaI
-const FC_ARRAY = Symbol();
-export function ARRAY_OF(rawConstraints){
-	const proto = forbiddenObject();
-	proto.type = FC_ARRAY;
-	proto.rawConstraints = rawConstraints;
-	return proto;
+export function ARRAY_OF(constraints){
+	if (arguments.length > 1){
+		console.error("Got more than one argument to ARRAY_OF. Did you mean to pass an array of constraints?");
+	}
+	return constraint(FC_ARRAY, null, constraints);
+}
+export function DYNAMIC(constraints){
+	return constraint(FC_DYNAMIC, null, constraints);
 }
 
 const TYPE = t => x => typeof x == t;
-export const IS_NULL = x => x === null;
-export const IS_ARRAY = x => Array.isArray(x);
 
-function forbiddenObject(){
-	return {
-		forbiddenKey: FORBIDDEN_SIGNATURE
-	};
-}
+const CONSTRAINT = Symbol();
+const FC_ARRAY = Symbol(); // https://www.youtube.com/watch?v=qSqXGeJJBaI
+const FC_DYNAMIC = Symbol();
+const FC_NESTED = Symbol();
 
-function isForbidden(obj){
-	return obj?.forbiddenKey == FORBIDDEN_SIGNATURE;
-}
+const VALIDATION_DEFAULTS = {
+	allErrors: true,
+	allowExtraProperties: true
+};
 
 function safe(cb){
 	try {
@@ -50,147 +51,157 @@ function error(propertyName, id, expected, got){
 	};
 }
 
-const VALIDATION_DEFAULTS = {
-	allErrors: true,
-	allowExtraProperties: true,
-	selfAlias: "_self"
-};
-
 function constraint(f, failMessageId, expected){
 	return {
+		type: CONSTRAINT,
 		validation: f,
 		failMessageId: failMessageId,
 		expected: expected
 	};
 }
 
-function arrayOfConstraints(raw, selfAlias){
-	if (Array.isArray(raw)){
-		return raw;
-	} else {
-		if (typeof raw == "object"){
-			if (isForbidden(raw)){
-				return [raw]
-			} else {
-				if (raw.hasOwnProperty(selfAlias)){
-					return arrayOfConstraints(raw[selfAlias]);
-				} else {
-					return ["object"];
+function parseSchema(schemaProperty){
+	function unify(raw){
+		if (raw.type == CONSTRAINT) return raw;
+
+		if (Array.isArray(raw)){
+			return raw.map(c => unify(c));
+		} else {
+			switch (typeof raw){
+				case ("string"): {
+					if (raw == "array")
+						return constraint(IS_ARRAY, "typeMismatch", raw);
+					else
+						return constraint(TYPE(raw), "typeMismatch", raw);
+				}
+				case ("function"): {
+					return constraint(raw, "customFail", undefined);
+				}
+				case ("object"): {
+					return constraint(FC_NESTED, null, raw);
+				}
+				case ("symbol"): {
+					return raw;
 				}
 			}
-		} else {
-			return [raw];
-		}
-	}
-}
-
-function stricterConstraints(raw){
-	const r = [];
-	for (let c of raw){
-		if (isForbidden(c)) continue;
-		switch (typeof c){
-		case ("string"): {
-			if (c == "array")
-				r.push(constraint(IS_ARRAY, "typeMismatch", c))
-			else
-				r.push(constraint(TYPE(c), "typeMismatch", c))
-			break;
-		}
-		case ("function"): {
-			r.push(constraint(c, "customFail", undefined));
-			break;
-		}
 		}
 	}
-	return r;
+	
+	let intermediate = unify(schemaProperty);
+	if (!Array.isArray(intermediate))
+		intermediate = [intermediate];
+	return [
+		intermediate.filter(i => i.type == CONSTRAINT),
+		intermediate.filter(i => i.type != CONSTRAINT && typeof i == "symbol")
+	];
 }
 
-/**
-* @param options Validation options:
-*
-* - allErrors (true) : return all errors instead of interrupting after first fail
-* - allowExtraProperties (true) : If false, adds specific error to a list for every property of target object not present in schema
-* - selfAlias ("_self"): Schema property name for referring nested object itself
-* @return Array of errors
- */
-export function validate(target, schema = {}, options = {}){
-	options = Object.assign(VALIDATION_DEFAULTS, options)
+function checkValue(propertyName, value, constraints, options){
 	const errors = [];
+	for (let constraint of constraints){
+		if (typeof constraint.validation == "function"){
+			const [success, validationResult] = safe(() => constraint.validation(value));
+			if (!success){
+				errors.push(error(propertyName, "exceptionOnCustom", undefined, validationResult.toString()));
+			} else if (!validationResult){
+				errors.push(error(propertyName, constraint.failMessageId, constraint.expected, value));
+			}
+			continue;
+		}
 
-	if (IS_NULL(target)) return [error(null, "targetIsNull", "object", target)];
+		switch(constraint.validation){
+			case FC_NESTED: {
+				if (typeof value != "object" || value === null || value == undefined){
+					errors.push(error(propertyName, "objectExpected", "object", value));
+					break;
+				}
 
-	const targetKeys = Object.keys(target || {});
-	const schemaKeys = Object.keys(schema);
+				const targetKeys = Object.keys(value);
+				const schemaKeys = Object.keys(constraint.expected);
 
-	for (let sKey of schemaKeys){
-		if (!options.allErrors && errors.length > 0)
-			return errors;
+				for (let key of schemaKeys){
+					const [subConstraints, flags] = parseSchema(constraint.expected[key]);
 
-		if (sKey == options.selfAlias) continue;
+					if (!targetKeys.includes(key)){
+						if (!flags.includes(OPTIONAL)){
+							errors.push(error(`${propertyName}.${key}`, "noProperty"));
+						}
+						continue;
+					}
 
-		const rawPropertySchema = schema[sKey];
-		const schemaAsArray = arrayOfConstraints(rawPropertySchema, options.selfAlias);
-		const flags = schemaAsArray.filter(c => typeof c == "symbol");
-		const constraints = stricterConstraints(schemaAsArray);
-		const forbiddenConstraints = schemaAsArray.filter(s => isForbidden(s));
+					const subErrors = checkValue(`${propertyName}.${key}`, value[key], subConstraints, options);
+					errors.push(...subErrors);
+				}
 
-		if (!targetKeys.includes(sKey)){
-			if (!flags.includes(OPTIONAL)){
-				errors.push(error(sKey, "noProperty"));
-			}
-			continue;
-		}
+				if (!options.allowExtraProperties){
+					const extraProperties = targetKeys.filter(k => !schemaKeys.includes(k));
+					if (extraProperties.length > 0){
+						errors.push(...extraProperties.map(k => error(`${propertyName}.${k}`, "extraProperty")))
+					}
+				}
 
-		for (let constraint of constraints){
-			const [success, validationResult] = safe(() => constraint.validation(target[sKey]));
-			if (!success){
-				errors.push(error(sKey, "exceptionOnCustom", undefined, validationResult.toString()));
-			} else if (!validationResult){
-				errors.push(error(sKey, constraint.failMessageId, constraint.expected, target[sKey]));
+				break;
 			}
-			continue;
-		}
-
-		for (let fc of forbiddenConstraints){
-			switch (fc.type){
 			case FC_ARRAY: {
-				if (Array.isArray(target[sKey])){
-					const forbiddenErrors = [];
-					let indexCounter = 0;
-					for (let item of target[sKey]){
-						const e = validate({"": item}, {"": fc.rawConstraints}, options);
-						e.forEach(err => err.propertyName = `${sKey}[${indexCounter}]${err.propertyName}`);
-						forbiddenErrors.push(...e);
-						++indexCounter;
-					}
+				if (!Array.isArray(value)){
+					errors.push(error(propertyName, "notArray", "array", typeof value))
+					break;
+				}
 
-					errors.push(...forbiddenErrors);
-				} else {
-					errors.push(error(sKey, "notArray", "array", typeof target[sKey]))
+				const [subConstraints, flags] = parseSchema(constraint.expected);
+
+				let indexCounter = 0;
+				for (let item of value){
+					const subErrors = checkValue(`${propertyName}[${indexCounter}]`, item, subConstraints, options);
+					errors.push(...subErrors);
+					++indexCounter;
 				}
-				const success = true;
+
 				break;
 			}
+			case FC_DYNAMIC: {
+				const constraintCallback = constraint.expected;
+
+				if (typeof constraintCallback != "function"){
+					errors.push(error(propertyName, "functionExpected", "function", typeof constraintCallback))
+					break;
+				}
+
+				const [subConstraints, flags] = parseSchema(constraintCallback(value))
+				const subErrors = checkValue(propertyName, value, subConstraints, options);
+				errors.push(...subErrors);
+
+				break;
 			}
 		}
 
-		if (typeof rawPropertySchema == "object" && !Array.isArray(rawPropertySchema) && !isForbidden(rawPropertySchema)){
-			const nestedErrors = validate(target[sKey], rawPropertySchema, options);
-			const mappedErrors = nestedErrors.map(e => {
-				const dot = IS_NULL(e.propertyName) ? "" : ".";
-				e.propertyName = `${sKey}${dot}${e.propertyName || ""}`;
-				return e;
-			});
-			errors.push(...mappedErrors);
-		}
+		if (!options.allErrors && errors.length > 0) break;
 	}
+	return errors;
+}
 
-	if (!options.allowExtraProperties){
-		const extraProperties = targetKeys.filter(k => !schemaKeys.includes(k));
-		if (extraProperties.length > 0){
-			errors.push(...extraProperties.map(k => error(k, "extraProperty")))
-		}
+/**
+* @param options Validation options:
+*
+* - allErrors (true) : return all errors instead of interrupting after first fail
+* - allowExtraProperties (true) : If false, adds specific error to a list for every property of target object not present in schema
+* @return Array of errors
+ */
+export function validate(target, schema = {}, options = {}){
+	options = Object.assign(VALIDATION_DEFAULTS, options)
+
+	const [constraints, flags] = parseSchema(schema);
+
+	if (flags.length > 0) {
+		console.error("Flags can't be used at schema's root")
 	}
 
+	const errors = checkValue("", target, constraints, options);
+
+	errors.forEach(e => {
+		if (e.propertyName?.startsWith("."))
+			e.propertyName = e.propertyName.slice(1);
+	});
+
 	return errors;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arstotzka",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "description": "JS validation utility",
   "main": "index.js",
   "type": "module",
@@ -10,10 +10,11 @@
   "keywords": [
     "JSON",
     "schema",
+    "data",
     "validator",
     "validation",
-    "jsonschema",
-    "json-schema"
+    "data-validation",
+    "schema-validation"
   ],
   "author": "milesseventh",
   "license": "WTFPL",

package/readme.md

@@ -27,35 +27,47 @@ const goodData = {
 	]
 }
 
-console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false}));
+console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false})); // Prints an array of errors
 ```
 
 ### Import:
-`import * as Arstotzka from "Arstotzka";`
+Arstotzka is an ES6 module, so:
+```
+import * as Arstotzka from "arstotzka";
+```
+or, if you are okay with polluting namespace:
+```
+import { validate, OPTIONAL, ARRAY_OF, DYNAMIC } from "arstotzka";
+```
+
 
 ### Schema format:
-- You build a schema, an object describing requirements for each property of object you wish to validate, then pass target object, that schema and options to `validate()` function and receive an array of detailed errors in return.
-- `const arrayOfErrors = Arstotzka.validate(objectToCheck, schema, options);`
-- Aforemetioned requirements are called **constraints**. 
-- Plain string constraints check porperty's type with [typeof operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof), with exception of "array" constraint -- validator will [treat this type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) as special case.
-- Examples: `name: "string"`, `id: "number"`, `list: "array"`
-- You can also specify custom constraint by providing a validation function. Validator will pass property value to it and will add an error if returned value is falsy. Exception thrown inside validation function will be catched and added as errors into output
-- Examples: `notaNaN: x => !isNaN(x)`, `nickname: x => x.length < 10`
-- It is possible to validate nested objects by passing a schema object instead of constraint:
-- `user: {name: "string", age: "number"}`
-- If needed, you can still add constraints to the nested object itself, passing them to it's `_self` property. Name of the property can be changed in the options.
-- `phrase: {_self: x => x.text.length == x.letterCount, text: "string", letterCount: "number"}`
-- You can combine different constraints by passing an array of them.
-- Just like that: `nickname: ["string",  x => x.length < 10]`, `count: ["number",  x => x >= 0,  x => x % 1 == 0]`
-- There are special constraints that serve as flags. (The only) one of them is **Arstotzka.OPTIONAL**. It allows to validate a property but prevents validator from adding an error if that property is not present in target object.
-- `commentary: ["string", Arstotzka.OPTIONAL]`
-- Finally, you can apply constraints to array's elements with **Arstotzka.ARRAY_OF()**. All the constraints passed to that function will be applied for each element. 
-- `numberArray: Arstotzka.ARRAY_OF("number")`, `posts: Arstotzka.ARRAY_OF({id: "number", text: "string"})`, `positives: Arstotzka.ARRAY_OF(["number", x = x > 0])`, or even `matrix: Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number"))`
+Schema is a value that can be either of
+- **string**: such schema will make validator check coresponding value's type with [typeof operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof), with exception of "array" constraint -- validator will [treat this type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) as special case;
+`"string"`, `"number"`, `"array"`
+
+- **function**: such schema will make validator call it, pass corresponding value to it, and log an error if returned value is falsy;
+`x => !isNaN(x)`, `x => x.length < 10`
+
+- **object**: object schema requires corresponding value to also be an object, and will recursively match it's properties against provided value;
+`{name: "string", age: x => x.length > 21}`
+
+- **array**, which elements are any of above. That will require a value it matched against to fullfill *every* requirement;
+`["string", x => x != x.trim()]`, `["number", x => x >= 0, x => x % 1 === 0]`
+
+- **Arstotzka.ARRAY_OF()**: the function accepts any of above and returns a special constraint appliable to an array of values;
+`Arstotzka.ARRAY_OF("number")`, `Arstotzka.ARRAY_OF({id: "number", text: "string"})`, `Arstotzka.ARRAY_OF(["number", x => x > 0])`, `Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number"))`
+
+- **Arstotzka.DYNAMIC()**: the function accepts a callback that should return a valid schema, allowing to define schema at runtime;
+`Arstotzka.DYNAMIC(x => dynSchema[x.type])`
+
+Applying a schema to a property that is an object can be done by combining **object** schema with anything via **array** schema;
+
 
 ### Available options:
 - **allErrors** (default is `true`) : If false, will return errors as soon as encountered, interrupting validation
 - **allowExtraProperties** (default is `true`) : If false, adds specific error to a list for every property of target object not present in schema
-- **selfAlias** (default is `"_self"`): Schema property name for referring nested object itself
+
 
 ### Error format
 ```
@@ -67,7 +79,9 @@ console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false}))
 	got: null
 }
 ```
+
 All error ids and messages can be found at `Arstotzka.ERRORS`
 
+
 ## License
 Shared under WTFPL license.

package/usage.js

@@ -1,6 +1,5 @@
 import * as Arstotzka from "./index.js";
 
-
 const schema = {
 	title: "string",
 	array: [Arstotzka.ARRAY_OF("number"), x => x.length > 1],
@@ -13,11 +12,10 @@ const schema = {
 	positiveArray: Arstotzka.ARRAY_OF(x => x > 0),
 	nested: {
 		parseableNumber: [x => !isNaN(parseInt(x, 10))],
-		anotherNest: {
-			_self: [x => x.phrase.split(" ").length == x.wordCount],
+		anotherNest: [{
 			phrase: "string",
 			wordCount: "number"
-		},
+		}, x => x.phrase.split(" ").length == x.wordCount],
 		missing: []
 	},
 	invalidValidator: [x => null.invalid],
@@ -48,7 +46,7 @@ const testSubject0 = {
 		missing: 0
 	},
 	invalidValidator: "uhm"
-}
+};
 
 const testSubject1 = {
 	title: 1337,
@@ -75,6 +73,32 @@ const testSubject1 = {
 		}
 	},
 	invalidValidator: "uhm"
-}
+};
+
+const schema1 = Arstotzka.DYNAMIC(x => dynSchema[x.type]);
+const dynSchema = [
+	{
+		type: "number",
+		zero: "string"
+	},
+	{
+		type: "number",
+		one: ["number", x => x === 1]
+	}
+];
+const testSubject2 = {
+	type: 0,
+	zero: "0"
+};
+
+const tests = [
+	[null, {x: "number"}],
+	[testSubject0, schema], // Only an error caused by invalid validator
+	[testSubject1, schema], // Full of errors
+	["miles", "string"],    // Any value can be validated, not only objects
+	[7, "string"],
+	[testSubject2, schema1]
+];
 
-console.log(Arstotzka.validate(testSubject1, schema, {allowExtraProperties: false}));
+const TEST_SELECTOR = 0;
+console.log(Arstotzka.validate(tests[TEST_SELECTOR][0], tests[TEST_SELECTOR][1], {allowExtraProperties: false}));