arstotzka 0.11.0

package/index.js

@@ -0,0 +1,192 @@
+export const ERRORS = {
+	noProperty: "Required property not present",
+	typeMismatch: "Provided type is not allowed by schema",
+	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"
+};
+
+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;
+}
+
+const TYPE = t => x => typeof x == t;
+export const NOT_NULL = x => x !== null;
+export const IS_ARRAY = x => Array.isArray(x);
+
+function forbiddenObject(){
+	return {
+		forbiddenKey: FORBIDDEN_SIGNATURE
+	};
+}
+
+function isForbidden(obj){
+	return obj?.forbiddenKey == FORBIDDEN_SIGNATURE;
+}
+
+function safe(cb){
+	try {
+		return [true, cb()];
+	} catch (e) {
+		return [false, e];
+	}
+}
+
+function error(propertyName, id, expected, got){
+	return {
+		propertyName,
+		id,
+		message: ERRORS[id],
+		expected,
+		got
+	};
+}
+
+const VALIDATION_DEFAULTS = {
+	allErrors: true,
+	allowExtraProperties: true,
+	selfAlias: "_self"
+};
+
+function constraint(f, failMessageId, expected){
+	return {
+		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"];
+				}
+			}
+		} 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;
+}
+
+/**
+* @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)
+	const errors = [];
+
+	const targetKeys = Object.keys(target);
+	const schemaKeys = Object.keys(schema);
+
+	for (let sKey of schemaKeys){
+		if (!options.allErrors && errors.length > 0)
+			return errors;
+
+		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));
+
+		if (!targetKeys.includes(sKey)){
+			if (!flags.includes(OPTIONAL)){
+				errors.push(error(sKey, "noProperty"));
+			}
+			continue;
+		}
+
+		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]));
+			}
+			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;
+					}
+
+					errors.push(...forbiddenErrors);
+				} else {
+					errors.push(error(sKey, "notArray", "array", typeof target[sKey]))
+				}
+				const success = true;
+				break;
+			}
+			}
+		}
+
+		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}`;
+				return e;
+			});
+			errors.push(...mappedErrors);
+		}
+	}
+
+	if (!options.allowExtraProperties){
+		const extraProperties = targetKeys.filter(k => !schemaKeys.includes(k));
+		if (extraProperties.length > 0){
+			errors.push(...extraProperties.map(k => error(k, "extraProperty")))
+		}
+	}
+
+	return errors;
+}

package/license.md

@@ -0,0 +1,15 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+
+  

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "arstotzka",
+  "version": "0.11.0",
+  "description": "JS validation utility",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "JSON",
+    "schema",
+    "validator",
+    "validation",
+    "jsonschema",
+    "json-schema"
+  ],
+  "author": "milesseventh",
+  "license": "WTFPL",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MilesVII/arstotzka.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MilesVII/arstotzka/issues"
+  },
+  "homepage": "https://github.com/MilesVII/arstotzka#readme"
+}

package/readme.md

@@ -0,0 +1,48 @@
+# Arstotzka
+JS data validation tool featuring laconic schema format and a sexy name.
+
+## Usage
+
+See detailed usage example in **[usage.js](https://github.com/MilesVII/arstotzka/blob/master/usage.js)**
+
+### Import:
+`import * as Arstotzka 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 faction will be catched and added as errors into output
+- Examples: `positiveNumber: x => x > 0`, `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"))`
+
+### 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
+```
+{ // Example error item:
+	propertyName: 'age', // Name of a property that failed validation
+	id: 'typeMismatch', // String describing type of an error. Can be used to localize error message
+	message: 'Provided type is not allowed by schema', // Error message that coressponds to error id
+	expected: 'number', // Arbitrary-purpose fields
+	got: null
+}
+```
+All error ids and messages can be found at `Arstotzka.ERRORS`
+
+## License
+Shared under WTFPL license.

package/usage.js

@@ -0,0 +1,80 @@
+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: {
+			_self: [x => x.phrase.split(" ").length == x.wordCount],
+			phrase: "string",
+			wordCount: "number"
+		},
+		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"
+}
+
+console.log(Arstotzka.validate(testSubject1, schema, {allowExtraProperties: false}));