arstotzka 0.13.0 → 0.13.3

package/index.js

@@ -8,7 +8,8 @@ export const ERRORS = {
 	targetIsNull: "Passed object or array item is null",
 	functionExpected: "Expected function as dynamic constraint",
 	objectExpected: "Expected object",
-	anyFailed: "None of ANY_OF constraints are met"
+	anyFailed: "None of ANY_OF constraints are met",
+	parsingError: "Schema parsing error"
 };
 
 export const OPTIONAL = Symbol();
@@ -35,6 +36,7 @@ export function DYNAMIC(constraints){
 }
 
 const TYPE = t => x => typeof x == t;
+const IS_ARRAY = x => Array.isArray(x);
 
 const CONSTRAINT = Symbol();
 const FC_ARRAY = Symbol(); // https://www.youtube.com/watch?v=qSqXGeJJBaI
@@ -74,34 +76,38 @@ function constraint(f, failMessageId, expected){
 	};
 }
 
-function parseSchema(schemaProperty){
+function parseSchema(schemaProperty, errors){
 	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;
+		if (raw !== null && raw !== undefined){
+			if (raw.type == CONSTRAINT) return raw;
+
+			if (Array.isArray(raw)){
+				return raw.map(c => unify(c)).filter(raw => raw !== null);
+			} 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;
+					}
 				}
 			}
 		}
+		errors.push(error("<schema>", "parsingError", undefined, raw));
+		return null;
 	}
 	
-	let intermediate = unify(schemaProperty);
+	let intermediate = unify(schemaProperty) || [];
 	if (!Array.isArray(intermediate))
 		intermediate = [intermediate];
 	return [
@@ -134,7 +140,7 @@ function checkValue(propertyName, value, constraints, options){
 				const schemaKeys = Object.keys(constraint.expected);
 
 				for (let key of schemaKeys){
-					const [subConstraints, flags] = parseSchema(constraint.expected[key]);
+					const [subConstraints, flags] = parseSchema(constraint.expected[key], errors);
 
 					if (!targetKeys.includes(key)){
 						if (!flags.includes(OPTIONAL)){
@@ -162,7 +168,7 @@ function checkValue(propertyName, value, constraints, options){
 					break;
 				}
 
-				const [subConstraints, flags] = parseSchema(constraint.expected);
+				const [subConstraints, flags] = parseSchema(constraint.expected, errors);
 
 				let indexCounter = 0;
 				for (let item of value){
@@ -181,8 +187,10 @@ function checkValue(propertyName, value, constraints, options){
 				let counter = 0;
 
 				for (let subSchema of subSchemas){
-					const [subConstraints, flags] = parseSchema(subSchema);
+					const subParseErrors = [];
+					const [subConstraints, flags] = parseSchema(subSchema, subParseErrors);
 					const caseErrors = checkValue(`${propertyName}.<any#${counter}>`, value, subConstraints, options);
+					caseErrors.push(...subParseErrors);
 					++counter;
 					subErrors.push(caseErrors);
 					if (caseErrors.length == 0) {
@@ -203,7 +211,7 @@ function checkValue(propertyName, value, constraints, options){
 					break;
 				}
 
-				const [subConstraints, flags] = parseSchema(constraintCallback(value))
+				const [subConstraints, flags] = parseSchema(constraintCallback(value), errors)
 				const subErrors = checkValue(propertyName, value, subConstraints, options);
 				errors.push(...subErrors);
 
@@ -226,14 +234,15 @@ function checkValue(propertyName, value, constraints, options){
 export function validate(target, schema = {}, options = {}){
 	options = Object.assign(VALIDATION_DEFAULTS, options)
 
-	const [constraints, flags] = parseSchema(schema);
+	const parseErrors = [];
+	const [constraints, flags] = parseSchema(schema, parseErrors);
 
 	if (flags.length > 0) {
 		console.error("Flags can't be used at schema's root")
 	}
 
 	const errors = checkValue("", target, constraints, options);
-
+	errors.push(...parseErrors)
 	errors.forEach(e => {
 		if (e.propertyName?.startsWith("."))
 			e.propertyName = e.propertyName.slice(1);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "arstotzka",
-  "version": "0.13.0",
+  "version": "0.13.3",
   "description": "JS validation utility",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node tests.js"
   },
   "keywords": [
     "JSON",

package/tests.js

@@ -0,0 +1,115 @@
+import * as Arstotzka from "./index.js";
+
+const schema = {
+	title: "string",
+	array: [Arstotzka.ARRAY_OF("number"), x => x.length > 1],
+	arrayOfObjs: Arstotzka.ARRAY_OF({
+		id: "number",
+		name: "string"
+	}),
+	notArray: Arstotzka.ARRAY_OF("string"),
+	arrayOof: Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number")),
+	positiveArray: Arstotzka.ARRAY_OF(x => x > 0),
+	nested: {
+		parseableNumber: [x => !isNaN(parseInt(x, 10))],
+		anotherNest: [{
+			phrase: "string",
+			wordCount: "number"
+		}, x => x.phrase.split(" ").length == x.wordCount],
+		missing: []
+	},
+	invalidValidator: [x => null.invalid],
+	optional: ["number", Arstotzka.OPTIONAL]
+};
+
+const testSubject0 = {
+	title: "1337",
+	array: [1, 2, 3],
+	arrayOfObjs: [
+		{id: 0, name: "_"},
+		{id: 1, name: "second"},
+		{id: 2, name: "3"},
+	],
+	notArray: [],
+	arrayOof: [
+		[1, 2, 3],
+		[4, 5, 6],
+		[1, 2]
+	],
+	positiveArray: [Infinity, 1, 4, 5],
+	nested: {
+		parseableNumber: "777",
+		anotherNest: {
+			phrase:"henlo",
+			wordCount: 1
+		},
+		missing: 0
+	},
+	invalidValidator: "uhm"
+};
+
+const testSubject1 = {
+	title: 1337,
+	array: [1, null, 3],
+	arrayOfObjs: [
+		{id: 0, name: "_"},
+		{id: 0,},
+		{id: "0", name: "_"}
+	],
+	notArray: "[1, 2, 3]",
+	arrayOof: [
+		[1, 2, 3],
+		[4, "5", 6],
+		null,
+		[1, 2]
+	],
+	positiveArray: [0, 1, 4, -5],
+	nested: {
+		parseableNumber: "seven",
+		extraProperty: "hey",
+		anotherNest: {
+			phrase:"henlo",
+			wordCount: 2
+		}
+	},
+	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 parseableIntSchema = Arstotzka.ANY_OF(
+	"number",
+	["string", x => !isNaN(parseInt(x))]
+);
+
+// [target, schema, error count]
+const tests = [
+	[null, "array", 1],            // null values and non-object constraints
+	[testSubject0, schema, 1],     // Only an error caused by invalid validator
+	[testSubject1, schema, 13],    // Full of errors
+	["miles", "string", 0],        // Any value can be validated, not only objects
+	[7, "string", 1],              // Same but failed
+	[testSubject2, schema1, 0],    // Dynamic schema
+	["7", parseableIntSchema, 0],  // Schema with ANY_OF
+	[testSubject0, null, 1]        // Invalid schema
+];
+
+const testResults = tests
+	.map(t => Arstotzka.validate(t[0], t[1]).length == t[2])
+	.map((testPassed, i) => `Test ${i}: ${testPassed ? "PASSED" : "FAILED"}`)
+	.join("\n");
+console.log(testResults);

package/usage.js

@@ -1,28 +1,7 @@
 import * as Arstotzka from "./index.js";
 
-const schema = {
-	title: "string",
-	array: [Arstotzka.ARRAY_OF("number"), x => x.length > 1],
-	arrayOfObjs: Arstotzka.ARRAY_OF({
-		id: "number",
-		name: "string"
-	}),
-	notArray: Arstotzka.ARRAY_OF("string"),
-	arrayOof: Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number")),
-	positiveArray: Arstotzka.ARRAY_OF(x => x > 0),
-	nested: {
-		parseableNumber: [x => !isNaN(parseInt(x, 10))],
-		anotherNest: [{
-			phrase: "string",
-			wordCount: "number"
-		}, x => x.phrase.split(" ").length == x.wordCount],
-		missing: []
-	},
-	invalidValidator: [x => null.invalid],
-	optional: ["number", Arstotzka.OPTIONAL]
-};
-
-const testSubject0 = {
+// This value will be validated against schema described below
+const value = {
 	title: "1337",
 	array: [1, 2, 3],
 	arrayOfObjs: [
@@ -30,81 +9,72 @@ const testSubject0 = {
 		{id: 1, name: "second"},
 		{id: 2, name: "3"},
 	],
-	notArray: [],
-	arrayOof: [
+	matrix: [
 		[1, 2, 3],
 		[4, 5, 6],
-		[1, 2]
+		[1, 2, 0]
 	],
 	positiveArray: [Infinity, 1, 4, 5],
 	nested: {
 		parseableNumber: "777",
 		anotherNest: {
-			phrase:"henlo",
-			wordCount: 1
+			phrase:"henlo there",
+			wordCount: 2
 		},
-		missing: 0
+		justBeThere: 0
 	},
-	invalidValidator: "uhm"
+	booleanOrNumber: 0,
+	dynamic: 69
 };
 
-const testSubject1 = {
-	title: 1337,
-	array: [1, null, 3],
-	arrayOfObjs: [
-		{id: 0, name: "_"},
-		{id: 0,},
-		{id: "0", name: "_"}
-	],
-	notArray: "[1, 2, 3]",
-	arrayOof: [
-		[1, 2, 3],
-		[4, "5", 6],
-		null,
-		[1, 2]
-	],
-	positiveArray: [0, 1, 4, -5],
+const schema = { // Require value to be an object
+	// Require typeof value.title to be "string"
+	title: "string",
+	
+	//Require value.array to be an array of numbers AND to be longer than 1 element
+	array: [Arstotzka.ARRAY_OF("number"), x => x.length > 1],
+
+	// Require each element of value.arrayOfObjs to be valid according to provided schema
+	arrayOfObjs: Arstotzka.ARRAY_OF({
+		id: "number",
+		name: "string"
+	}),
+
+	// Require each element of value.matrix to be an array of numbers
+	matrix: Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number")),
+
+	// Require each element of value.positiveArray be larger than zero, regardless of type
+	positiveArray: Arstotzka.ARRAY_OF(x => x > 0),
+
+	// Require value.nested to be an object
 	nested: {
-		parseableNumber: "seven",
-		extraProperty: "hey",
-		anotherNest: {
-			phrase:"henlo",
-			wordCount: 2
-		}
+		// Require value.nested.parseableNumber to make this function return true
+		parseableNumber: x => !isNaN(parseInt(x, 10)),
+		// Require value.nested.anotherNest to be an object AND make provided function return true
+		anotherNest: [{
+			phrase: "string",
+			wordCount: "number"
+		}, x => x.phrase.split(" ").length == x.wordCount],
+		// Require value.nested.justBeThere to be present
+		justBeThere: []
 	},
-	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"
+	// Require value.optional to be of type "number", but only if present
+	optional: ["number", Arstotzka.OPTIONAL],
+
+	// Require value.booleanOrNumber to be either boolean, or 0 or 1
+	booleanOrNumber: Arstotzka.ANY_OF("boolean", x => x === 0 || x === 1),
+
+	// Require value.dynamic to be valid according to schema returned from provided callback (always "number" in that case)
+	dynamic: Arstotzka.DYNAMIC(x => "number")
 };
 
-const parseableIntSchema = Arstotzka.ANY_OF(
-	"number",
-	["string", x => !isNaN(parseInt(x))]
-);
+// You can call validate() without providing any options. Below are all options with default values
+const optionalValidationOptions = {
+	allowExtraProperties: true,
+	allErrors: true
+};
 
-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],
-	["7", parseableIntSchema]
-];
+const errors = Arstotzka.validate(value, schema, optionalValidationOptions);
 
-const TEST_SELECTOR = 0;
-console.log(Arstotzka.validate(tests[TEST_SELECTOR][0], tests[TEST_SELECTOR][1], {allowExtraProperties: false}));
+console.log(errors); // Empty, meaning validation is passed