@contember/schema-utils 1.1.0-alpha.5 → 1.1.0-alpha.8

package/src/validation/ValidationValidator.ts

@@ -1,84 +1,57 @@
 import { Model, Validation } from '@contember/schema'
 import { ErrorBuilder, ValidationError } from './errors'
-import { everyIs, hasArrayProperty, hasStringProperty, isArray, isObject } from './utils'
 import { acceptFieldVisitor } from '../model'
 
 export class ValidationValidator {
 	constructor(private readonly model: Model.Schema) {}
 
-	public validate(schema: unknown): [Validation.Schema, ValidationError[]] {
+	public validate(schema: Validation.Schema): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], ['validation'])
-		let validSchema: Validation.Schema
-		if (!isObject(schema)) {
-			errorBuilder.add('Must be an object')
-			validSchema = { roles: {} }
-		} else {
-			validSchema = {}
-			for (const entityName in schema) {
-				const entity = this.model.entities[entityName]
-				const entityErrorBuilder = errorBuilder.for(entityName)
-				if (!entity) {
-					entityErrorBuilder.add('Entity not found')
-				} else {
-					validSchema[entityName] = this.validateEntityRules(entityErrorBuilder, schema[entityName], entity)
-				}
+		for (const entityName in schema) {
+			const entity = this.model.entities[entityName]
+			const entityErrorBuilder = errorBuilder.for(entityName)
+			if (!entity) {
+				entityErrorBuilder.add('Entity not found')
+			} else {
+				this.validateEntityRules(entityErrorBuilder, schema[entityName], entity)
 			}
 		}
-		return [validSchema, errorBuilder.errors]
+		return errorBuilder.errors
 	}
 
 	private validateEntityRules(
 		errorBuilder: ErrorBuilder,
-		entitySchema: unknown,
+		entitySchema: Validation.EntityRules,
 		entity: Model.Entity,
-	): Validation.EntityRules {
-		if (!isObject(entitySchema)) {
-			errorBuilder.add('Must be an object')
-			return {}
-		}
-		const validRules: Validation.EntityRules = {}
+	): void {
 		for (const fieldName in entitySchema) {
 			const field = entity.fields[fieldName]
 			const fieldErrorBuilder = errorBuilder.for(fieldName)
 			if (!field) {
 				fieldErrorBuilder.add('Field not found')
 			} else {
-				validRules[fieldName] = this.validateFieldRules(fieldErrorBuilder, entitySchema[fieldName], entity, field)
+				this.validateFieldRules(fieldErrorBuilder, entitySchema[fieldName], entity, field)
 			}
 		}
-		return validRules
 	}
 
 	private validateFieldRules(
 		errorBuilder: ErrorBuilder,
-		fieldSchema: unknown,
+		fieldSchema: readonly Validation.ValidationRule[],
 		entity: Model.Entity,
 		field: Model.AnyField,
-	): Validation.ValidationRule[] {
-		if (!isArray(fieldSchema)) {
-			errorBuilder.add('Must be an array')
-			return []
-		}
-		const validRules = []
+	): void {
 		for (const i in fieldSchema) {
-			const rule = this.validateFieldRule(errorBuilder.for(i), fieldSchema[i], entity, field)
-			if (rule !== undefined) {
-				validRules.push(rule)
-			}
+			this.validateFieldRule(errorBuilder.for(i), fieldSchema[i], entity, field)
 		}
-		return validRules
 	}
 
 	private validateFieldRule(
 		errorBuilder: ErrorBuilder,
-		rule: unknown,
+		rule: Validation.ValidationRule,
 		entity: Model.Entity,
 		field: Model.AnyField,
-	): Validation.ValidationRule | undefined {
-		if (!isObject(rule)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
+	): void {
 		const errorMessage = acceptFieldVisitor(this.model, entity, field, {
 			visitColumn: () => null,
 			visitHasOne: () => null,
@@ -87,173 +60,65 @@ export class ValidationValidator {
 			},
 		})
 		if (errorMessage) {
-			errorBuilder.add(errorMessage)
-			return undefined
-		}
-		const validMessage = this.validateFieldRuleMessage(errorBuilder.for('message'), rule.message)
-		if (!validMessage) {
-			return undefined
+			return errorBuilder.add(errorMessage)
 		}
-
-		const validValidator = this.validateValidator(errorBuilder.for('validator'), rule.validator, entity, field)
-		if (!validValidator) {
-			return undefined
-		}
-		return { message: validMessage, validator: validValidator }
+		this.validateValidator(errorBuilder.for('validator'), rule.validator, entity, field)
 	}
 
-	private validateFieldRuleMessage(errorBuilder: ErrorBuilder, message: unknown): Validation.Message | undefined {
-		if (!isObject(message)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
-		if (!hasStringProperty(message, 'text')) {
-			errorBuilder.for('text').add('Must be a string')
-			return undefined
-		}
-		let validMessage: Validation.Message = { text: message.text }
-		if (message.parameters) {
-			if (!hasArrayProperty(message, 'parameters')) {
-				errorBuilder.for('parameters').add('Must be an array')
-				return undefined
-			}
-			validMessage.parameters = message.parameters as string[]
-		}
-
-		return validMessage
-	}
 
 	private validateValidator(
 		errorBuilder: ErrorBuilder,
-		validator: unknown,
+		validator: Validation.Validator,
 		entity: Model.Entity,
 		field: Model.AnyField,
-	): Validation.Validator | undefined {
-		if (!isObject(validator)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
+	): void {
 		const validatorCast = validator as Validation.Validator
 		switch (validatorCast.operation) {
 			case 'and':
-				const andArgs = validatorCast.args
-					.map((it, index) => this.validateValidatorArgument(errorBuilder.for(String(index)), it, entity, field))
-					.filter((it): it is Validation.ValidatorArgument => it !== undefined)
-				return { operation: 'and' as const, args: andArgs }
 			case 'or':
-				const orArgs = validatorCast.args
-					.map((it, index) => this.validateValidatorArgument(errorBuilder.for(String(index)), it, entity, field))
-					.filter((it): it is Validation.ValidatorArgument => it !== undefined)
-				return { operation: 'or' as const, args: orArgs }
+				return validatorCast.args
+					.forEach((it, index) => this.validateValidatorArgument(errorBuilder.for(String(index)), it, entity, field))
 			case 'conditional':
-				const argA = this.validateValidatorArgument(errorBuilder.for('condition'), validatorCast.args[0], entity, field)
-				const argB = this.validateValidatorArgument(errorBuilder.for('rule'), validatorCast.args[1], entity, field)
-				if (argA === undefined || argB === undefined) {
-					return undefined
-				}
-
-				return { operation: 'conditional', args: [argA, argB] }
+				this.validateValidatorArgument(errorBuilder.for('condition'), validatorCast.args[0], entity, field)
+				this.validateValidatorArgument(errorBuilder.for('rule'), validatorCast.args[1], entity, field)
+				return
 			case 'pattern':
-				const patternLiteral = this.validateLiteralArgument(errorBuilder, validatorCast.args[0])
-				if (!patternLiteral) {
-					return undefined
-				}
-				if (
-					!isArray(patternLiteral.value) ||
-					patternLiteral.value.length !== 2 ||
-					typeof patternLiteral.value[0] !== 'string' ||
-					typeof patternLiteral.value[1] !== 'string'
-				) {
-					errorBuilder.add('Invalid pattern value')
-					return undefined
-				}
-				return { operation: 'pattern', args: [patternLiteral as Validation.LiteralArgument<[string, string]>] }
 			case 'lengthRange':
-				const lengthArgA = this.validateLiteralArgument(errorBuilder.for('min'), validatorCast.args[0])
-				const lengthArgB = this.validateLiteralArgument(errorBuilder.for('max'), validatorCast.args[1])
-				if (lengthArgA === undefined || lengthArgB === undefined) {
-					return undefined
-				}
-				return {
-					operation: 'lengthRange',
-					args: [lengthArgA as Validation.LiteralArgument<number>, lengthArgB as Validation.LiteralArgument<number>],
-				}
 			case 'range':
-				const rangeArgA = this.validateLiteralArgument(errorBuilder.for('min'), validatorCast.args[0])
-				const rangeArgB = this.validateLiteralArgument(errorBuilder.for('max'), validatorCast.args[1])
-				if (rangeArgA === undefined || rangeArgB === undefined) {
-					return undefined
-				}
-				return {
-					operation: 'range',
-					args: [rangeArgA as Validation.LiteralArgument<number>, rangeArgB as Validation.LiteralArgument<number>],
-				}
 			case 'equals':
-				const eqArg = this.validateLiteralArgument(errorBuilder, validatorCast.args[0])
-				if (eqArg === undefined) {
-					return undefined
-				}
-				return {
-					operation: 'equals',
-					args: [eqArg],
-				}
-			case 'not':
-				const notArg = this.validateValidatorArgument(errorBuilder, validatorCast.args[0], entity, field)
-				if (notArg === undefined) {
-					return undefined
-				}
-				return { operation: 'not', args: [notArg] }
 			case 'empty':
-				return { operation: 'empty', args: [] }
 			case 'defined':
-				return { operation: 'defined', args: [] }
+				return
+			case 'not':
+				return this.validateValidatorArgument(errorBuilder, validatorCast.args[0], entity, field)
 			case 'inContext':
 				const pathArgResult = this.validatePathArgument(errorBuilder.for('path'), validatorCast.args[0], entity)
 				if (pathArgResult === undefined) {
 					return undefined
 				}
-				const [pathArg, inField] = pathArgResult
-
-				const inValidatorArg = this.validateValidatorArgument(
+				return this.validateValidatorArgument(
 					errorBuilder.for('validator'),
 					validatorCast.args[1],
 					entity,
-					inField,
+					pathArgResult,
 				)
-				if (inValidatorArg === undefined) {
-					return undefined
-				}
-				return { operation: 'inContext', args: [pathArg, inValidatorArg] }
 			case 'every':
-				const everyArg = this.validateValidatorArgument(errorBuilder, validatorCast.args[0], entity, field)
-				if (everyArg === undefined) {
-					return undefined
-				}
-				return { operation: 'every', args: [everyArg] }
 			case 'any':
-				const anyArg = this.validateValidatorArgument(errorBuilder, validatorCast.args[0], entity, field)
-				if (anyArg === undefined) {
-					return undefined
-				}
-				return { operation: 'any', args: [anyArg] }
+				return this.validateValidatorArgument(errorBuilder, validatorCast.args[0], entity, field)
 			case 'filter':
-				const filterArgA = this.validateValidatorArgument(
+				this.validateValidatorArgument(
 					errorBuilder.for('filter'),
 					validatorCast.args[0],
 					entity,
 					field,
 				)
-				const filterArgB = this.validateValidatorArgument(
+				this.validateValidatorArgument(
 					errorBuilder.for('validator'),
 					validatorCast.args[1],
 					entity,
 					field,
 				)
-				if (filterArgA === undefined || filterArgB === undefined) {
-					return undefined
-				}
-
-				return { operation: 'filter', args: [filterArgA, filterArgB] }
+				return
 			default:
 				((_: never) => {
 					errorBuilder.for('operation', `Operation ${(validatorCast as any).operation} is not an valid option`)
@@ -263,65 +128,19 @@ export class ValidationValidator {
 
 	private validateValidatorArgument(
 		errorBuilder: ErrorBuilder,
-		argument: unknown,
+		argument: Validation.ValidatorArgument,
 		entity: Model.Entity,
 		field: Model.AnyField,
-	): Validation.ValidatorArgument | undefined {
-		if (!isObject(argument)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
-		if (!hasStringProperty(argument, 'type') || argument.type !== Validation.ArgumentType.validator) {
-			errorBuilder.for('type').add(`Invalid value ${argument.type}`)
-			return undefined
-		}
-		const validator = this.validateValidator(errorBuilder.for('validator'), argument.validator, entity, field)
-		if (!validator) {
-			return undefined
-		}
-		return { validator, type: argument.type }
+	): void {
+		this.validateValidator(errorBuilder.for('validator'), argument.validator, entity, field)
 	}
 
-	private validateLiteralArgument(
-		errorBuilder: ErrorBuilder,
-		argument: unknown,
-	): Validation.LiteralArgument<unknown> | undefined {
-		if (!isObject(argument)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
-		if (!hasStringProperty(argument, 'type') || argument.type !== Validation.ArgumentType.literal) {
-			errorBuilder.for('type').add(`Invalid value ${argument.type}`)
-			return undefined
-		}
-		if (!('value' in argument)) {
-			errorBuilder.for('value').add('Undefined literal value')
-			return undefined
-		}
-		return { type: argument.type, value: argument.value }
-	}
 
 	private validatePathArgument(
 		errorBuilder: ErrorBuilder,
-		argument: unknown,
+		argument: Validation.PathArgument,
 		entity: Model.Entity,
-	): [Validation.PathArgument, Model.AnyField] | undefined {
-		if (!isObject(argument)) {
-			errorBuilder.add('Must be an object')
-			return undefined
-		}
-		if (!hasStringProperty(argument, 'type') || argument.type !== Validation.ArgumentType.path) {
-			errorBuilder.for('type').add(`Invalid value ${argument.type}`)
-			return undefined
-		}
-		if (!hasArrayProperty(argument, 'path')) {
-			errorBuilder.add('Undefined path')
-			return undefined
-		}
-		if (!everyIs(argument.path, (it): it is string => typeof it === 'string')) {
-			errorBuilder.add('Invalid path')
-			return undefined
-		}
+	): Model.AnyField | undefined {
 		const isRelation = acceptFieldVisitor(this.model, entity, argument.path[0], {
 			visitColumn: () => false,
 			visitRelation: () => true,
@@ -330,6 +149,6 @@ export class ValidationValidator {
 			errorBuilder.add('Rules depending on relations are currently not supported.')
 			return undefined
 		}
-		return [{ type: argument.type, path: argument.path }, entity.fields[argument.path[0]]]
+		return entity.fields[argument.path[0]]
 	}
 }

package/src/validation/index.ts

@@ -1,3 +1,5 @@
 export * from './AclValidator'
+export * from './ModelValidator'
+export * from './ValidationValidator'
 export * from './errors'
 export * from './SchemaValidator'

package/dist/src/validation/utils.d.ts

@@ -1,18 +0,0 @@
-export declare type UnknownObject = Record<string, unknown>;
-export declare function isObject(input: unknown): input is UnknownObject;
-export declare function isArray(input: unknown): input is unknown[];
-export declare function hasStringProperty<Input extends UnknownObject, Property extends string>(input: Input, property: Property): input is Input & {
-    [key in Property]: string;
-};
-export declare function hasNumberProperty<Input extends UnknownObject, Property extends string>(input: Input, property: Property): input is Input & {
-    [key in Property]: number;
-};
-export declare function hasObjectProperty<Input extends UnknownObject, Property extends string>(input: Input, property: Property): input is Input & {
-    [key in Property]: UnknownObject;
-};
-export declare function hasArrayProperty<Input extends UnknownObject, Property extends string>(input: Input, property: Property): input is Input & {
-    [key in Property]: unknown[];
-};
-export declare function everyIs<Type>(input: unknown[], predicate: (it: unknown) => it is Type): input is Type[];
-export declare function checkExtraProperties(object: UnknownObject, allowedKeys: string[]): string[];
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/validation/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/validation/utils.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEnD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAE/D;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,EAAE,CAE1D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,aAAa,EAAE,QAAQ,SAAS,MAAM,EACrF,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,GAChB,KAAK,IAAI,KAAK,GAAG;KAAG,GAAG,IAAI,QAAQ,GAAG,MAAM;CAAE,CAEhD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,aAAa,EAAE,QAAQ,SAAS,MAAM,EACrF,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,GAChB,KAAK,IAAI,KAAK,GAAG;KAAG,GAAG,IAAI,QAAQ,GAAG,MAAM;CAAE,CAEhD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,aAAa,EAAE,QAAQ,SAAS,MAAM,EACrF,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,GAChB,KAAK,IAAI,KAAK,GAAG;KAAG,GAAG,IAAI,QAAQ,GAAG,aAAa;CAAE,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,SAAS,aAAa,EAAE,QAAQ,SAAS,MAAM,EACpF,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,GAChB,KAAK,IAAI,KAAK,GAAG;KAAG,GAAG,IAAI,QAAQ,GAAG,OAAO,EAAE;CAAE,CAEnD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,EAAE,IAAI,IAAI,GAAG,KAAK,IAAI,IAAI,EAAE,CAEvG;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAE3F"}

package/dist/src/validation/utils.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkExtraProperties = exports.everyIs = exports.hasArrayProperty = exports.hasObjectProperty = exports.hasNumberProperty = exports.hasStringProperty = exports.isArray = exports.isObject = void 0;
-function isObject(input) {
-    return typeof input === 'object' && input !== null;
-}
-exports.isObject = isObject;
-function isArray(input) {
-    return Array.isArray(input);
-}
-exports.isArray = isArray;
-function hasStringProperty(input, property) {
-    return typeof input[property] === 'string';
-}
-exports.hasStringProperty = hasStringProperty;
-function hasNumberProperty(input, property) {
-    return typeof input[property] === 'number';
-}
-exports.hasNumberProperty = hasNumberProperty;
-function hasObjectProperty(input, property) {
-    return isObject(input[property]);
-}
-exports.hasObjectProperty = hasObjectProperty;
-function hasArrayProperty(input, property) {
-    return isArray(input[property]);
-}
-exports.hasArrayProperty = hasArrayProperty;
-function everyIs(input, predicate) {
-    return input.every(it => predicate(it));
-}
-exports.everyIs = everyIs;
-function checkExtraProperties(object, allowedKeys) {
-    return Object.keys(object).filter(it => !allowedKeys.includes(it));
-}
-exports.checkExtraProperties = checkExtraProperties;
-//# sourceMappingURL=utils.js.map

package/dist/src/validation/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/validation/utils.ts"],"names":[],"mappings":";;;AAEA,SAAgB,QAAQ,CAAC,KAAc;IACtC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAA;AACnD,CAAC;AAFD,4BAEC;AAED,SAAgB,OAAO,CAAC,KAAc;IACrC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;AAC5B,CAAC;AAFD,0BAEC;AAED,SAAgB,iBAAiB,CAChC,KAAY,EACZ,QAAkB;IAElB,OAAO,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,QAAQ,CAAA;AAC3C,CAAC;AALD,8CAKC;AAED,SAAgB,iBAAiB,CAChC,KAAY,EACZ,QAAkB;IAElB,OAAO,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,QAAQ,CAAA;AAC3C,CAAC;AALD,8CAKC;AAED,SAAgB,iBAAiB,CAChC,KAAY,EACZ,QAAkB;IAElB,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;AACjC,CAAC;AALD,8CAKC;AAED,SAAgB,gBAAgB,CAC/B,KAAY,EACZ,QAAkB;IAElB,OAAO,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;AAChC,CAAC;AALD,4CAKC;AAED,SAAgB,OAAO,CAAO,KAAgB,EAAE,SAAsC;IACrF,OAAO,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAA;AACxC,CAAC;AAFD,0BAEC;AAED,SAAgB,oBAAoB,CAAC,MAAqB,EAAE,WAAqB;IAChF,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAA;AACnE,CAAC;AAFD,oDAEC"}

package/src/validation/utils.ts

@@ -1,45 +0,0 @@
-export type UnknownObject = Record<string, unknown>
-
-export function isObject(input: unknown): input is UnknownObject {
-	return typeof input === 'object' && input !== null
-}
-
-export function isArray(input: unknown): input is unknown[] {
-	return Array.isArray(input)
-}
-
-export function hasStringProperty<Input extends UnknownObject, Property extends string>(
-	input: Input,
-	property: Property,
-): input is Input & { [key in Property]: string } {
-	return typeof input[property] === 'string'
-}
-
-export function hasNumberProperty<Input extends UnknownObject, Property extends string>(
-	input: Input,
-	property: Property,
-): input is Input & { [key in Property]: number } {
-	return typeof input[property] === 'number'
-}
-
-export function hasObjectProperty<Input extends UnknownObject, Property extends string>(
-	input: Input,
-	property: Property,
-): input is Input & { [key in Property]: UnknownObject } {
-	return isObject(input[property])
-}
-
-export function hasArrayProperty<Input extends UnknownObject, Property extends string>(
-	input: Input,
-	property: Property,
-): input is Input & { [key in Property]: unknown[] } {
-	return isArray(input[property])
-}
-
-export function everyIs<Type>(input: unknown[], predicate: (it: unknown) => it is Type): input is Type[] {
-	return input.every(it => predicate(it))
-}
-
-export function checkExtraProperties(object: UnknownObject, allowedKeys: string[]): string[] {
-	return Object.keys(object).filter(it => !allowedKeys.includes(it))
-}