arstotzka 0.11.0 → 0.11.2

package/index.js

@@ -4,7 +4,8 @@ export const ERRORS = {
 	customFail: "Custom validation function failed",
 	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"
+	notArray: "Tried using ARRAY_OF constraint on non-array value",
+	targetIsNull: "Passed object or array item is null"
 };
 
 export const OPTIONAL = Symbol();
@@ -18,7 +19,7 @@ export function ARRAY_OF(rawConstraints){
 }
 
 const TYPE = t => x => typeof x == t;
-export const NOT_NULL = x => x !== null;
+export const IS_NULL = x => x === null;
 export const IS_ARRAY = x => Array.isArray(x);
 
 function forbiddenObject(){
@@ -112,17 +113,21 @@ function stricterConstraints(raw){
 * - selfAlias ("_self"): Schema property name for referring nested object itself
 * @return Array of errors
  */
-export function validate(target = {}, schema = {}, options = {}){
+export function validate(target, schema = {}, options = {}){
 	options = Object.assign(VALIDATION_DEFAULTS, options)
 	const errors = [];
 
-	const targetKeys = Object.keys(target);
+	if (IS_NULL(target)) return [error(null, "targetIsNull", "object", target)];
+
+	const targetKeys = Object.keys(target || {});
 	const schemaKeys = Object.keys(schema);
 
 	for (let sKey of schemaKeys){
 		if (!options.allErrors && errors.length > 0)
 			return errors;
 
+		if (sKey == options.selfAlias) continue;
+
 		const rawPropertySchema = schema[sKey];
 		const schemaAsArray = arrayOfConstraints(rawPropertySchema, options.selfAlias);
 		const flags = schemaAsArray.filter(c => typeof c == "symbol");
@@ -170,11 +175,10 @@ export function validate(target = {}, schema = {}, options = {}){
 		}
 
 		if (typeof rawPropertySchema == "object" && !Array.isArray(rawPropertySchema) && !isForbidden(rawPropertySchema)){
-			delete rawPropertySchema[options.selfAlias];
-
 			const nestedErrors = validate(target[sKey], rawPropertySchema, options);
 			const mappedErrors = nestedErrors.map(e => {
-				e.propertyName = `${sKey}.${e.propertyName}`;
+				const dot = IS_NULL(e.propertyName) ? "" : ".";
+				e.propertyName = `${sKey}${dot}${e.propertyName || ""}`;
 				return e;
 			});
 			errors.push(...mappedErrors);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arstotzka",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "JS validation utility",
   "main": "index.js",
   "type": "module",

package/readme.md

@@ -5,6 +5,31 @@ JS data validation tool featuring laconic schema format and a sexy name.
 
 See detailed usage example in **[usage.js](https://github.com/MilesVII/arstotzka/blob/master/usage.js)**
 
+```
+const schema = {
+	id: "number",
+	username: ["string", x => x.length < 10],
+	post: "string",
+	comments: Arstotzka.ARRAY_OF({
+		author: ["string", Arstotzka.OPTIONAL],
+		text: "string"
+	})
+}
+
+const goodData = {
+	id: 1337,
+	username: "mr.hands",
+	post: "Henlo there",
+	comments: [
+		{author: "Johnny", text: "henlo"},
+		{text: "hey hey"},
+		{author: "miles", text: "birb"},
+	]
+}
+
+console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false}));
+```
+
 ### Import:
 `import * as Arstotzka from "Arstotzka";`
 
@@ -14,14 +39,14 @@ See detailed usage example in **[usage.js](https://github.com/MilesVII/arstotzka
 - 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 faction will be catched and added as errors into output
-- Examples: `positiveNumber: x => x > 0`, `nickname: x => x.length < 10`
+- 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]`
+- 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.