@contember/schema-utils 1.3.0-beta.4 → 1.3.0-rc.2

package/src/validation/ModelValidator.ts

@@ -13,7 +13,7 @@ export class ModelValidator {
 		const errorBuilder = new ErrorBuilder([], [])
 		this.validateEnums(this.model.enums, errorBuilder.for('enums'))
 		this.validateEntities(this.model.entities, errorBuilder.for('entities'))
-		this.validateCollisions(Object.values(this.model.entities), errorBuilder.for('entities'))
+
 		return errorBuilder.errors
 	}
 
@@ -34,10 +34,15 @@ export class ModelValidator {
 			}
 			this.validateEntity(entity, entityErrors)
 		}
+		const entitiesArr = Object.values(this.model.entities)
+		this.validateMetaSuffixCollisions(entitiesArr, errors)
+		this.validateTableNameCollisions(entitiesArr, errors)
+		this.validateAliasedTypesCollision(entitiesArr, errors)
 	}
 
 	private validateEntity(entity: Model.Entity, errors: ErrorBuilder): void {
 		this.validateIdentifier(entity.name, errors)
+		this.validateEntityName(entity.name, errors)
 
 		for (const [fieldName, field] of Object.entries(entity.fields)) {
 			const fieldErrors = errors.for(fieldName)
@@ -51,6 +56,7 @@ export class ModelValidator {
 			new Set(Object.keys(entity.fields)),
 			errors.for('unique'),
 		)
+		this.validateColumnNamesCollision(entity, errors)
 	}
 
 	private validateUniqueConstraints(uniqueConstraints: Model.Entity['unique'], fields: Set<string>, errors: ErrorBuilder): void {
@@ -63,6 +69,34 @@ export class ModelValidator {
 		}
 	}
 
+	private validateColumnNamesCollision(entity: Model.Entity, errors: ErrorBuilder): void {
+		const existingColumnNames = new Map<string, string>()
+		const addColumnName = (fieldName: string, columnName: string) => {
+			if (existingColumnNames.has(columnName)) {
+				const exitingName = existingColumnNames.get(columnName)
+				errors
+					.for(fieldName)
+					.add('MODEL_NAME_COLLISION', `Column name "${columnName}" on field "${fieldName}" collides with a column name on field "${exitingName}".`)
+			}
+			existingColumnNames.set(columnName, fieldName)
+		}
+		acceptEveryFieldVisitor(this.model, entity, {
+			visitColumn: ({ column }) => {
+				addColumnName(column.name, column.columnName)
+			},
+			visitOneHasOneOwning: ({ relation }) => {
+				addColumnName(relation.name, relation.joiningColumn.columnName)
+			},
+			visitManyHasOne: ({ relation }) => {
+				addColumnName(relation.name, relation.joiningColumn.columnName)
+			},
+			visitOneHasOneInverse: () => {},
+			visitOneHasMany: () => {},
+			visitManyHasManyInverse: () => {},
+			visitManyHasManyOwning: () => {},
+		})
+	}
+
 	private validateField(partialEntity: Model.Entity, field: Model.AnyField, errors: ErrorBuilder): void {
 		this.validateIdentifier(field.name, errors)
 		if (isRelation(field)) {
@@ -204,10 +238,29 @@ export class ModelValidator {
 		}
 	}
 
-	private validateCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
-		const relationNames: Record<string, string> = {}
-		const aliasedTypes = new Map<string, Model.ColumnType>()
+	private validateEntityName(value: string, errorBuilder: ErrorBuilder) {
+		if (['Query', 'Mutation'].includes(value)) {
+			errorBuilder.add('MODEL_INVALID_ENTITY_NAME', `${value} is reserved word`)
+		}
+	}
+
+
+	private validateMetaSuffixCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
 		const entityNames = new Set(entities.map(it => it.name))
+		for (const entity of entities) {
+			if (entity.name.endsWith('Meta')) {
+				const baseName = entity.name.substring(0, entity.name.length - 4)
+				if (entityNames.has(baseName)) {
+					errorBuilder.for(entity.name)
+						.add('MODEL_NAME_COLLISION', `entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`)
+				}
+			}
+		}
+	}
+
+
+	private validateTableNameCollisions(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
+		const relationNames: Record<string, string> = {}
 		for (const entity of entities) {
 			const description = `table name ${entity.tableName} of entity ${entity.name}`
 			if (relationNames[entity.tableName]) {
@@ -217,14 +270,6 @@ export class ModelValidator {
 			} else {
 				relationNames[entity.tableName] = description
 			}
-
-			if (entity.name.endsWith('Meta')) {
-				const baseName = entity.name.substring(0, entity.name.length - 4)
-				if (entityNames.has(baseName)) {
-					errorBuilder.for(entity.name)
-						.add('MODEL_NAME_COLLISION', `entity ${entity.name} collides with entity ${baseName}, because a GraphQL type with "Meta" suffix is created for every entity`)
-				}
-			}
 		}
 		for (const entity of entities) {
 			const entityErrorBuilder = errorBuilder.for(entity.name)
@@ -243,7 +288,22 @@ export class ModelValidator {
 						relationNames[joiningTable.tableName] = description
 					}
 				},
-				visitColumn: ({ entity, column }) => {
+				visitColumn: () => {},
+				visitManyHasManyInverse: () => { },
+				visitOneHasMany: () => { },
+				visitOneHasOneInverse: () => { },
+				visitOneHasOneOwning: () => { },
+				visitManyHasOne: () => { },
+			})
+		}
+	}
+
+
+	private validateAliasedTypesCollision(entities: Model.Entity[], errorBuilder: ErrorBuilder) {
+		const aliasedTypes = new Map<string, Model.ColumnType>()
+		for (const entity of entities) {
+			acceptEveryFieldVisitor(this.model, entity, {
+				visitColumn: ({ column }) => {
 					if (!column.typeAlias) {
 						return
 					}
@@ -254,6 +314,7 @@ export class ModelValidator {
 					}
 					aliasedTypes.set(column.typeAlias, column.type)
 				},
+				visitManyHasManyOwning: () => { },
 				visitManyHasManyInverse: () => { },
 				visitOneHasMany: () => { },
 				visitOneHasOneInverse: () => { },

package/src/validation/errors.ts

@@ -7,6 +7,7 @@ export type ValidationErrorCode =
 	| 'MODEL_INVALID_COLUMN_DEFINITION'
 	| 'MODEL_INVALID_VIEW_USAGE'
 	| 'MODEL_INVALID_IDENTIFIER'
+	| 'MODEL_INVALID_ENTITY_NAME'
 	| 'MODEL_NAME_COLLISION'
 
 	| 'ACL_INVALID_CONDITION'

package/tests/cases/unit/modelValidator.test.ts

@@ -1,9 +1,7 @@
 import { assert, test } from 'vitest'
 import { Model } from '@contember/schema'
 import { ModelValidator } from '../../../src'
-
-
-
+import { c, createSchema } from '@contember/schema-definition'
 
 test('"meta" collision', () => {
 	const model: Model.Schema = {
@@ -74,3 +72,22 @@ test('"meta" collision', () => {
 		},
 	])
 })
+
+namespace ColumnNameCollision {
+	export class Bar {
+		rel = c.oneHasOne(Bar)
+		relId = c.intColumn()
+	}
+}
+
+test('column name collision', () => {
+	const schema = createSchema(ColumnNameCollision)
+	const validator = new ModelValidator(schema.model)
+	assert.deepStrictEqual(validator.validate(), [
+		{
+			code: 'MODEL_NAME_COLLISION',
+			message: 'Column name "rel_id" on field "relId" collides with a column name on field "rel".',
+			path: ['entities', 'Bar', 'relId'],
+		},
+	])
+})