@contember/schema-utils 1.2.1 → 1.3.0-alpha.13

package/src/index.ts

@@ -2,8 +2,10 @@ import { Schema } from '@contember/schema'
 import { emptyModelSchema } from './model'
 import * as Typesafe from '@contember/typesafe'
 import { aclSchema, modelSchema, validationSchema, settingsSchema } from './type-schema'
+import { actionsSchema } from './type-schema/actions'
 
 export * from './definition-generator'
+export * from './SchemaDatabaseMetadata'
 export * from './lax'
 export * from './model'
 export * from './acl'
@@ -11,12 +13,13 @@ export * from './dataUtils'
 export * from './validation'
 export * from './schemaNormalizer'
 export * from './schemaFilter'
-export { deepCompare } from './utils'
+export { deepCompare, compareArraysIgnoreOrder } from './utils'
 
 export const emptySchema: Schema = {
 	model: emptyModelSchema,
 	acl: { roles: {} },
 	validation: {},
+	actions: { triggers: {}, targets: {} },
 	settings: {},
 }
 
@@ -24,5 +27,6 @@ export const schemaType: Typesafe.Type<Schema> = Typesafe.object({
 	model: modelSchema,
 	acl: aclSchema,
 	validation: validationSchema,
+	actions: Typesafe.coalesce(actionsSchema, { triggers: {}, targets: {} }),
 	settings: Typesafe.coalesce(settingsSchema, {}),
 })

package/src/lax/LaxSchemaConverter.ts

@@ -1,6 +1,7 @@
 import { Model, Schema, Writable } from '@contember/schema'
 import { LaxSchema, LaxSchemaColumn, LaxSchemaEnum, LaxSchemaField, LaxSchemaRelation } from './schema'
 import { DefaultNamingConventions, NamingConventions, resolveDefaultColumnType } from '../model'
+import { emptySchema } from '../index'
 
 const simpleColumnTypes: { [K in LaxSchemaColumn['type']]: { type: Model.ColumnType; columnType: string } } = {
 	boolean: { type: Model.ColumnType.Bool, columnType: 'boolean' },
@@ -53,9 +54,7 @@ class LaxSchemaBuilder {
 			}
 		}
 		return {
-			acl: { roles: {} },
-			settings: {},
-			validation: {},
+			...emptySchema,
 			model: {
 				enums: this.enums,
 				entities: this.entities,
@@ -193,8 +192,8 @@ class LaxSchemaBuilder {
 	private getEntity(entityName: string): Model.Entity {
 		return this.entities[entityName] ??= {
 			name: entityName,
-			unique: {},
-			indexes: {},
+			unique: [],
+			indexes: [],
 			primary: 'id',
 			primaryColumn: 'id',
 			tableName: this.conventions.getTableName(entityName),

package/src/model/index.ts

@@ -1,4 +1,3 @@
 export * from './modelUtils'
-export * from './NamingHelper'
 export * from './resolveDefaultColumnType'
 export * from './NamingConventions'

package/src/tsconfig.json

@@ -5,11 +5,7 @@
 		"esModuleInterop": true
 	},
 	"references": [
-		{
-			"path": "../../schema/src"
-		},
-		{
-			"path": "../../typesafe/src"
-		}
+		{ "path": "../../schema/src" },
+		{ "path": "../../typesafe/src" }
 	]
 }

package/src/type-schema/actions.ts

@@ -0,0 +1,79 @@
+import * as Typesafe from '@contember/typesafe'
+import { Actions } from '@contember/schema'
+
+const selectionNodeSchemaFactory = (): Typesafe.Type<Actions.SelectionNode> => {
+	return (input: unknown, path: PropertyKey[] = []): Actions.SelectionNode => {
+		return Typesafe.array(Typesafe.union(
+			Typesafe.string,
+			Typesafe.tuple(
+				Typesafe.string,
+				Typesafe.anyJsonObject,
+				selectionNodeSchemaFactory(),
+			),
+		))(input, path)
+	}
+}
+
+const webhookTargetSchema = Typesafe.intersection(
+	Typesafe.object({
+		type: Typesafe.literal('webhook'),
+		name: Typesafe.string,
+		url: Typesafe.string,
+	}),
+	Typesafe.partial({
+		headers: Typesafe.record(Typesafe.string, Typesafe.string),
+		timeoutMs: Typesafe.integer,
+		maxAttempts: Typesafe.integer,
+		initialRepeatIntervalMs: Typesafe.integer,
+		batchSize: Typesafe.integer,
+	}),
+)
+const webhookTargetSchemaCheck: Typesafe.Equals<Actions.WebhookTarget, ReturnType<typeof webhookTargetSchema>> = true
+
+const anyTargetSchema: Typesafe.Type<Actions.AnyTarget> = Typesafe.union(webhookTargetSchema)
+
+const watchTriggerSchema = Typesafe.intersection(
+	Typesafe.object({
+		type: Typesafe.literal('watch'),
+		name: Typesafe.string,
+		entity: Typesafe.string,
+		watch: selectionNodeSchemaFactory(),
+		target: Typesafe.string,
+	}),
+	Typesafe.partial({
+		selection: selectionNodeSchemaFactory(),
+		priority: Typesafe.integer,
+	}),
+)
+
+const watchTriggerSchemaCheck: Typesafe.Equals<Actions.WatchTrigger, ReturnType<typeof watchTriggerSchema>> = true
+
+
+const basicTriggerSchema = Typesafe.intersection(
+	Typesafe.object({
+		type: Typesafe.literal('basic'),
+		name: Typesafe.string,
+		entity: Typesafe.string,
+		create: Typesafe.boolean,
+		delete: Typesafe.boolean,
+		update: Typesafe.union(Typesafe.boolean, Typesafe.array(Typesafe.string)),
+		target: Typesafe.string,
+	}),
+	Typesafe.partial({
+		selection: selectionNodeSchemaFactory(),
+		priority: Typesafe.integer,
+	}),
+)
+
+const basicTriggerSchemaCheck: Typesafe.Equals<Actions.BasicTrigger, ReturnType<typeof basicTriggerSchema>> = true
+
+
+const anyTriggerSchema = Typesafe.union(
+	watchTriggerSchema,
+	basicTriggerSchema,
+)
+
+export const actionsSchema = Typesafe.object({
+	triggers: Typesafe.record(Typesafe.string, anyTriggerSchema),
+	targets: Typesafe.record(Typesafe.string, anyTargetSchema),
+})

package/src/type-schema/model.ts

@@ -148,10 +148,22 @@ const viewSchemaCheck: Typesafe.Equals<Model.View, ReturnType<typeof viewSchemaI
 const viewSchema: Typesafe.Type<Model.View> = viewSchemaInner
 
 
-const indexesSchema = Typesafe.coalesce<Model.Indexes, Model.Indexes>(Typesafe.record(Typesafe.string, Typesafe.object({
-	fields: Typesafe.array(Typesafe.string),
-	name: Typesafe.string,
-})), { })
+const indexLike: Typesafe.Type<{readonly fields: readonly string[]; readonly name?: string | undefined}> = Typesafe.intersection(
+	Typesafe.object({
+		fields: Typesafe.array(Typesafe.string),
+	}),
+	Typesafe.partial({
+		name: Typesafe.string,
+	}),
+)
+
+const indexesSchema = Typesafe.coalesce<Model.Indexes, Model.Indexes>(
+	Typesafe.preprocess(
+		Typesafe.array(indexLike),
+		it => it?.constructor === Object ? Object.values(it) : it,
+	),
+	[],
+)
 
 const entitySchema = Typesafe.intersection(
 	Typesafe.object({
@@ -160,15 +172,16 @@ const entitySchema = Typesafe.intersection(
 		primaryColumn: Typesafe.string,
 		tableName: Typesafe.string,
 		fields: Typesafe.record(Typesafe.string, fieldSchema),
-		unique: Typesafe.record(Typesafe.string, Typesafe.object({
-			fields: Typesafe.array(Typesafe.string),
-			name: Typesafe.string,
-		})),
+		unique: Typesafe.preprocess(
+			Typesafe.array(indexLike),
+			it => it?.constructor === Object ? Object.values(it) : it,
+		),
 		indexes: indexesSchema,
 		eventLog: eventLogSchema,
 	}),
 	Typesafe.partial({
 		view: viewSchema,
+		orderBy: orderBySchema,
 	}),
 )
 

package/src/type-schema/where.ts

@@ -0,0 +1,28 @@
+import { Input, Model } from '@contember/schema'
+import { acceptFieldVisitor } from '../model'
+import { conditionSchema } from './condition'
+import * as Typesafe from '@contember/typesafe'
+
+export const whereSchema = ({ schema, entity }: {
+	schema: Model.Schema
+	entity: Model.Entity
+}): Typesafe.Type<Input.Where> => {
+	return (input: unknown, path: PropertyKey[] = []): Input.Where => {
+		const whereSchemaInner = Typesafe.noExtraProps(Typesafe.partial({
+			and: Typesafe.array(whereSchema({ schema, entity })),
+			or: Typesafe.array(whereSchema({ schema, entity })),
+			not: whereSchema({ schema, entity }),
+			...Object.fromEntries(Object.values(entity.fields).map((it): [string, Typesafe.Type<Input.Where[any]>] => {
+				return [
+					it.name,
+					acceptFieldVisitor(schema, entity, it.name, {
+						visitColumn: ({ column }) => conditionSchema(column.type),
+						visitRelation: ({ targetEntity }) => whereSchema({ schema, entity: targetEntity }),
+					}),
+				]
+			})),
+		}))
+
+		return whereSchemaInner(input, path)
+	}
+}

package/src/utils/deepCompare.ts

@@ -1,5 +1,7 @@
+type Path = (string | number)[]
+
 type CompareError = {
-	path: (string | number)[]
+	path: Path
 	message: string
 }
 
@@ -26,10 +28,41 @@ const getType = (val: any): ExtendedType => {
 	return 'object'
 }
 
-export function deepCompare(a: any, b: any, path: (string | number)[]): CompareError[] {
+type Comparator = (a: unknown, b: unknown) => CompareError[]
+
+export const compareArraysIgnoreOrder = (a: unknown, b: unknown, path: Path) => {
+	if (!Array.isArray(a) || !Array.isArray(b)) {
+		return [{ path, message: 'Invalid type, expected array' }]
+	}
+	if (a.length !== b.length) {
+		return [{ path, message: `Array length: ${a.length} != ${b.length}` }]
+	}
+	const haystack = [...b]
+	for (const needle of a) {
+		const index = haystack.findIndex(it => {
+			const errors = deepCompare(needle, it, path)
+			return errors.length === 0
+		})
+		if (index < 0) {
+			return [{ path, message: `Array item: ${JSON.stringify(needle)} not found in ${JSON.stringify(haystack)}` }]
+		}
+		haystack.splice(index, 1)
+	}
+	if (haystack.length > 0) {
+		return [{ path, message: `Array items: ${JSON.stringify(haystack)} not found in ${JSON.stringify(a)}` }]
+	}
+	return []
+}
+
+export function deepCompare(a: any, b: any, path: Path = [], getCustomComparator?: (path: Path) => Comparator | null): CompareError[] {
 	if (a === b) {
 		return []
 	}
+	const comparator = getCustomComparator?.(path)
+	if (comparator) {
+		return comparator(a, b)
+	}
+
 	const aType = getType(a)
 	const bType = getType(b)
 	if (aType !== bType) {
@@ -53,7 +86,7 @@ export function deepCompare(a: any, b: any, path: (string | number)[]): CompareE
 		}
 		const errors: CompareError[] = []
 		for (let i = 0; i < aLength; i++) {
-			errors.push(...deepCompare(a[i], b[i], [...path, i]))
+			errors.push(...deepCompare(a[i], b[i], [...path, i], getCustomComparator))
 		}
 		return errors
 	}
@@ -91,7 +124,7 @@ export function deepCompare(a: any, b: any, path: (string | number)[]): CompareE
 					message: `Missing property: ${key} not in right`,
 				})
 			} else {
-				errors.push(...deepCompare(a[key], b[key], [...path, key]))
+				errors.push(...deepCompare(a[key], b[key], [...path, key], getCustomComparator))
 			}
 		}
 		for (const key of bKeys) {

package/src/utils/printJsValue.ts

@@ -0,0 +1,62 @@
+export class Literal {
+	constructor(public readonly value: string) {
+	}
+}
+
+export type FormatterPath = ({ type: 'array' } | { type: 'object'; key: string })[]
+export type IndentDecider = (value: any, path: FormatterPath) => boolean
+
+
+export const printJsValue = (value: any, shouldIndentCb: IndentDecider = () => false, path: FormatterPath = []): string => {
+	if (value instanceof Literal) {
+		return value.value
+	}
+	if (value === undefined || value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'function') {
+		return String(value)
+	}
+	if (typeof value === 'bigint') {
+		return value.toString(10) + 'n'
+	}
+	if (typeof value === 'string') {
+		return `'${value.replaceAll(/'/g, '\\\'')}'`
+	}
+	const shouldIndent = shouldIndentCb(value, path)
+	if (!shouldIndent) {
+		shouldIndentCb = () => false
+	}
+
+	const indent = (inc: number) => '\t'.repeat(path.length + inc)
+	const nl = '\n'
+
+	if (Array.isArray(value)) {
+		return  ''
+				+ '['
+				+ value.map((it, index, arr) =>
+					(shouldIndent ? nl + indent(1) : '')
+					+ printJsValue(it, shouldIndentCb, [...path, { type: 'array' }])
+					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : '')),
+				).join('')
+				+ (shouldIndent ? nl + indent(0) : '')
+				+ ']'
+	}
+
+	return ''
+			+ '{'
+			+ (shouldIndent ? '' : ' ')
+			+ Object.entries(value).map(([key, value], index, arr) => {
+				const formattedKey = isSimpleIdentifier(key) ? key : `[${printJsValue(key)}]`
+				return ''
+					+ (shouldIndent ? nl + indent(1) : '')
+					+ formattedKey
+					+ ': '
+					+ printJsValue(value, shouldIndentCb, [...path, { type: 'object', key }])
+					+ (shouldIndent ? ',' : ((index + 1) < arr.length ? ', ' : ''))
+			}).join('')
+			+ (shouldIndent ? nl + indent(0) : ' ')
+			+ '}'
+
+}
+
+const isSimpleIdentifier = (identifier: string): boolean => {
+	return !!identifier.match(/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/)
+}

package/src/validation/ActionsValidator.ts

@@ -0,0 +1,119 @@
+import { Actions, Model } from '@contember/schema'
+import { acceptFieldVisitor } from '../model'
+import { ErrorBuilder, ValidationError } from './errors'
+import { assertNever } from '../utils'
+import * as Typesafe from '@contember/typesafe'
+import { whereSchema } from '../type-schema/where'
+
+const manyArgsSchema = (args: {schema: Model.Schema; entity: Model.Entity}) => Typesafe.partial({
+	limit: Typesafe.integer,
+	offset: Typesafe.integer,
+	orderBy: Typesafe.array(Typesafe.anyJsonObject),
+	filter: whereSchema(args),
+})
+
+export class ActionsValidator {
+	constructor(private readonly model: Model.Schema) {}
+
+	public validate(schema: Actions.Schema): ValidationError[] {
+		const errorBuilder = new ErrorBuilder([], ['actions'])
+		this.validateTriggers(schema, errorBuilder.for('triggers'))
+		return errorBuilder.errors
+	}
+
+	private validateTriggers(schema: Actions.Schema, errorBuilder: ErrorBuilder) {
+		for (const [name, def] of Object.entries(schema.triggers)) {
+			const triggerErrorBuilder = errorBuilder.for(name)
+			if (name !== def.name) {
+				triggerErrorBuilder.add('ACTIONS_NAME_MISMATCH', `Trigger name ${def.name} does not match the name in a map ${name}`)
+			}
+			if (!schema.targets[def.target]) {
+				triggerErrorBuilder.add('ACTIONS_UNDEFINED_TRIGGER_TARGET', `Trigger target ${def.target} not found`)
+			}
+			this.validateTrigger(def, triggerErrorBuilder)
+		}
+	}
+
+
+	private validateTrigger(trigger: Actions.AnyTrigger, errorBuilder: ErrorBuilder): void {
+		const entity = this.model.entities[trigger.entity]
+		if (!entity) {
+			errorBuilder.add('ACTIONS_UNDEFINED_ENTITY', `Entity ${trigger.entity} not found.`)
+			return
+		}
+
+		switch (trigger.type) {
+			case 'watch':
+				this.validateWatchTrigger(trigger, entity, errorBuilder)
+				break
+			case 'basic':
+				this.validateBasicTrigger(trigger, entity, errorBuilder)
+				break
+			default:
+				assertNever(trigger)
+		}
+	}
+
+	private validateWatchTrigger(trigger: Actions.WatchTrigger, entity: Model.Entity, errorBuilder: ErrorBuilder): void {
+		this.validateSelection(trigger.watch, entity, errorBuilder.for('watch'))
+		if (trigger.selection) {
+			this.validateSelection(trigger.selection, entity, errorBuilder.for('selection'))
+		}
+	}
+
+	private validateBasicTrigger(trigger: Actions.BasicTrigger, entity: Model.Entity, errorBuilder: ErrorBuilder): void {
+		if (trigger.selection) {
+			this.validateSelection(trigger.selection, entity, errorBuilder.for('selection'))
+		}
+
+		if (Array.isArray(trigger.update)) {
+			for (const field of trigger.update) {
+				if (!entity.fields[field]) {
+					errorBuilder.for('update').add('ACTIONS_UNDEFINED_FIELD', `Field ${field} of entity ${entity.name} not found.`)
+				}
+			}
+		}
+	}
+
+	private validateSelection(
+		selectionNode: Actions.SelectionNode,
+		entity: Model.Entity,
+		errorBuilder: ErrorBuilder,
+	): void {
+		for (const part of selectionNode) {
+			const [field, args, selection] = Array.isArray(part) ? part : [part, {}, []]
+			const fieldErrorBuilder = errorBuilder.for(field)
+			if (!entity.fields[field]) {
+				fieldErrorBuilder.add('ACTIONS_UNDEFINED_FIELD', `Undefined field ${field} on entity ${entity.name}`)
+				continue
+			}
+			acceptFieldVisitor(this.model, entity, field, {
+				visitColumn: () => {
+					if (selection.length) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Unexpected sub selection on a column.`)
+					}
+					if (Object.keys(args).length !== 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Unexpected args on a column.`)
+					}
+				},
+				visitHasMany: ({ targetEntity }) => {
+					if (selection.length === 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Sub-selection expected on a relation.`)
+					}
+					this.validateSelection(selection, targetEntity, fieldErrorBuilder)
+					try {
+						manyArgsSchema({ schema: this.model, entity: targetEntity })(args)
+					} catch (e: any) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Selection args are not valid: ` + e.message)
+					}
+				},
+				visitHasOne: ({ targetEntity }) => {
+					if (selection.length === 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Sub-selection expected on a relation.`)
+					}
+					this.validateSelection(selection, targetEntity, fieldErrorBuilder)
+				},
+			})
+		}
+	}
+}

package/src/validation/ModelValidator.ts

@@ -7,7 +7,7 @@ const RESERVED_WORDS = ['and', 'or', 'not']
 
 
 export class ModelValidator {
-	constructor(private readonly model: Model.Schema) {}
+	constructor(private readonly model: Model.Schema) { }
 
 	public validate(): ValidationError[] {
 		const errorBuilder = new ErrorBuilder([], [])
@@ -54,15 +54,10 @@ export class ModelValidator {
 	}
 
 	private validateUniqueConstraints(uniqueConstraints: Model.Entity['unique'], fields: Set<string>, errors: ErrorBuilder): void {
-		for (const [constraintName, constraint] of Object.entries(uniqueConstraints)) {
-			const uniqueErrors = errors.for(constraintName)
-			if (constraint.name !== constraintName) {
-				uniqueErrors.add('MODEL_NAME_MISMATCH', `Constraint name ${constraint.name} does not match the name in a map "${constraintName}"`)
-				continue
-			}
+		for (const constraint of uniqueConstraints) {
 			for (const field of constraint.fields) {
 				if (!fields.has(field)) {
-					uniqueErrors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in a constraint does not exists`)
+					errors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in a constraint does not exists`)
 				}
 			}
 		}
@@ -79,7 +74,7 @@ export class ModelValidator {
 		}
 	}
 
-	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder):  void {
+	private validateRelation(partialEntity: Model.Entity, field: Model.AnyRelation, errors: ErrorBuilder): void {
 		const entityName = partialEntity.name
 		const targetEntityName = field.target
 		const targetEntity = this.model.entities[targetEntityName] || undefined
@@ -94,7 +89,7 @@ export class ModelValidator {
 					const orderByField = entity.fields[it.path[i]]
 					const pathStr = it.path.slice(0, i + 1).join('.')
 					if (!orderByField) {
-						errors.add('ACL_UNDEFINED_FIELD', `Invalid orderBy of ${entityName}::${field.name}: field ${pathStr} is not defined`)
+						errors.add('MODEL_UNDEFINED_FIELD', `Invalid orderBy of ${entityName}::${field.name}: field ${pathStr} is not defined`)
 						return
 					}
 					if (i + 1 < it.path.length) {
@@ -148,7 +143,7 @@ export class ModelValidator {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} inverse relation is not set`)
 			}
 			if (targetField.inversedBy !== field.name) {
-				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.inversedBy} given`)
+				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.inversedBy} given`)
 			}
 			if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 				return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -185,7 +180,7 @@ export class ModelValidator {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} owning relation is not set`)
 				}
 				if (targetField.ownedBy !== field.name) {
-					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} exepcted, ${targetField.target}::${targetField.ownedBy} given`)
+					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} back reference ${entityName}::${field.name} expected, ${targetField.target}::${targetField.ownedBy} given`)
 				}
 				if (field.type === Model.RelationType.OneHasOne && targetField.type !== Model.RelationType.OneHasOne) {
 					return errors.add('MODEL_INVALID_RELATION_DEFINITION', `${relationDescription} "OneHasOne" type expected, "${targetField.type}" given`)
@@ -259,32 +254,13 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
-				visitManyHasManyInverse: () => {},
-				visitOneHasMany: () => {},
-				visitOneHasOneInverse: () => {},
-				visitOneHasOneOwning: () => {},
-				visitManyHasOne: () => {},
+				visitManyHasManyInverse: () => { },
+				visitOneHasMany: () => { },
+				visitOneHasOneInverse: () => { },
+				visitOneHasOneOwning: () => { },
+				visitManyHasOne: () => { },
 			})
 		}
-		for (const entity of entities) {
-			const entityErrorBuilder = errorBuilder.for(entity.name)
-			for (const index of Object.values(entity.indexes)) {
-				const description = `index name ${index.name} of entity ${entity.name}`
-				if (relationNames[index.name]) {
-					entityErrorBuilder.add('MODEL_NAME_COLLISION', `${description} collides with ${relationNames[index.name]}`)
-				} else {
-					relationNames[index.name] = description
-				}
-			}
-			for (const unique of Object.values(entity.unique)) {
-				const description = `unique index name ${unique.name} of entity ${entity.name}`
-				if (relationNames[unique.name]) {
-					entityErrorBuilder.add('MODEL_NAME_COLLISION', `${description} collides with ${relationNames[unique.name]}`)
-				} else {
-					relationNames[unique.name] = description
-				}
-			}
-		}
 	}
 }
 

package/src/validation/SchemaValidator.ts

@@ -3,6 +3,7 @@ import { ValidationError, ValidationErrorCode } from './errors'
 import { AclValidator } from './AclValidator'
 import { ModelValidator } from './ModelValidator'
 import { ValidationValidator } from './ValidationValidator'
+import { ActionsValidator } from './ActionsValidator'
 
 export interface SchemaValidatorSkippedErrors {
 	code: ValidationErrorCode
@@ -20,7 +21,11 @@ export class SchemaValidator {
 
 		const validationValidator = new ValidationValidator(schema.model)
 		const validationErrors = validationValidator.validate(schema.validation)
-		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors]
+
+		const actionsValidator = new ActionsValidator(schema.model)
+		const actionsErrors  = actionsValidator.validate(schema.actions)
+
+		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors, ...actionsErrors]
 		if (skippedErrors.length === 0) {
 			return allErrors
 		}

package/src/validation/errors.ts

@@ -16,6 +16,13 @@ export type ValidationErrorCode =
 	| 'ACL_UNDEFINED_ROLE'
 	| 'ACL_UNDEFINED_ENTITY'
 
+	| 'ACTIONS_NAME_MISMATCH'
+	| 'ACTIONS_INVALID_CONDITION'
+	| 'ACTIONS_UNDEFINED_FIELD'
+	| 'ACTIONS_UNDEFINED_ENTITY'
+	| 'ACTIONS_UNDEFINED_TRIGGER_TARGET'
+	| 'ACTIONS_INVALID_SELECTION'
+
 	| 'VALIDATION_UNDEFINED_ENTITY'
 	| 'VALIDATION_UNDEFINED_FIELD'
 	| 'VALIDATION_NOT_IMPLEMENTED'