@contember/schema-definition 1.3.6 → 1.4.0-alpha.2

package/src/model/definition/fieldDefinitions/ManyHasManyDefinition.ts

@@ -21,7 +21,7 @@ export class ManyHasManyDefinitionImpl extends FieldDefinition<ManyHasManyDefini
 		return this.withOption('orderBy', [...(this.options.orderBy || []), { path, direction: direction as Model.OrderDirection }])
 	}
 
-	createField({ name, conventions, entityName, entityRegistry }: CreateFieldContext): Model.AnyField {
+	createField({ name, conventions, entityName, entityRegistry, strictDefinitionValidator }: CreateFieldContext): Model.AnyField {
 		const options = this.options
 		const columnNames = conventions.getJoiningTableColumnNames(
 			entityName,
@@ -37,6 +37,8 @@ export class ManyHasManyDefinitionImpl extends FieldDefinition<ManyHasManyDefini
 			...options.joiningTable,
 		}
 
+		strictDefinitionValidator.validateInverseSide(entityName, name, options)
+
 		return {
 			type: Model.RelationType.ManyHasMany,
 			name,

package/src/model/definition/fieldDefinitions/ManyHasOneDefinition.ts

@@ -1,7 +1,6 @@
-import { EntityConstructor, Interface } from '../types'
+import { EntityConstructor, Interface, RelationTarget } from '../types'
 import { Model } from '@contember/schema'
 import { CreateFieldContext, FieldDefinition } from './FieldDefinition'
-import { RelationTarget } from '../types'
 
 export class ManyHasOneDefinitionImpl extends FieldDefinition<ManyHasOneDefinitionOptions> {
 	type = 'ManyHasOneDefinition' as const
@@ -26,13 +25,20 @@ export class ManyHasOneDefinitionImpl extends FieldDefinition<ManyHasOneDefiniti
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.setNull })
 	}
 
+	restrictOnDelete(): Interface<ManyHasOneDefinition> {
+		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.restrict })
+	}
+
 	notNull(): Interface<ManyHasOneDefinition> {
 		return this.withOption('nullable', false)
 	}
 
-	createField({ name, conventions, entityName, entityRegistry }: CreateFieldContext): Model.AnyField {
+	createField({ name, conventions, entityName, entityRegistry, strictDefinitionValidator }: CreateFieldContext): Model.AnyField {
 		const options = this.options
 		const joiningColumn = options.joiningColumn || {}
+		strictDefinitionValidator.validateInverseSide(entityName, name, options)
+		strictDefinitionValidator.validateOnCascade(entityName, name, joiningColumn)
+
 		return {
 			name: name,
 			...(typeof options.inversedBy === 'undefined' ? {} : { inversedBy: options.inversedBy }),

package/src/model/definition/fieldDefinitions/OneHasOneDefinition.ts

@@ -25,6 +25,10 @@ export class OneHasOneDefinitionImpl extends FieldDefinition<OneHasOneDefinition
 		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.setNull })
 	}
 
+	restrictOnDelete(): Interface<OneHasOneDefinition> {
+		return this.withOption('joiningColumn', { ...this.options.joiningColumn, onDelete: Model.OnDelete.restrict })
+	}
+
 	notNull(): Interface<OneHasOneDefinition> {
 		return this.withOption('nullable', false)
 	}
@@ -33,10 +37,13 @@ export class OneHasOneDefinitionImpl extends FieldDefinition<OneHasOneDefinition
 		return this.withOption('orphanRemoval', true)
 	}
 
-	createField({ name, conventions, entityRegistry }: CreateFieldContext): Model.AnyField {
+	createField({ name, conventions, entityRegistry, strictDefinitionValidator, entityName }: CreateFieldContext): Model.AnyField {
 		const options = this.options
 		const joiningColumn: Partial<Model.JoiningColumn> = options.joiningColumn || {}
 
+		strictDefinitionValidator.validateInverseSide(entityName, name, options)
+		strictDefinitionValidator.validateOnCascade(entityName, name, joiningColumn)
+
 		return {
 			name: name,
 			...(typeof options.inversedBy === 'undefined' ? {} : { inversedBy: options.inversedBy }),

package/src/model/definition/index.ts

@@ -6,6 +6,7 @@ import 'reflect-metadata'
 import { FieldDefinition } from './fieldDefinitions'
 import { isEntityConstructor } from '../../utils'
 import { DefaultNamingConventions } from '@contember/schema-utils'
+import { StrictOptions, StrictDefinitionValidator } from '../../strict'
 
 export * from './fieldDefinitions'
 export * from './EventLogDefinition'
@@ -24,8 +25,13 @@ export type ModelDefinition<M> = {
 	[K in keyof M]: unknown
 }
 
-export function createModel<M extends ModelDefinition<M>>(definitions: M): Model.Schema {
-	const schemaBuilder = new SchemaBuilder(new DefaultNamingConventions())
+export function createModel<M extends ModelDefinition<M>>(definitions: M, options: {
+	strictDefinitionValidator?: StrictDefinitionValidator
+} = {}): Model.Schema {
+	const schemaBuilder = new SchemaBuilder(
+		new DefaultNamingConventions(),
+		options.strictDefinitionValidator,
+	)
 	for (const [name, definition] of Object.entries(definitions)) {
 		if (definition instanceof EnumDefinition) {
 			schemaBuilder.addEnum(name, definition)

package/src/model/definition/internal/SchemaBuilder.ts

@@ -8,13 +8,17 @@ import { EntityRegistry } from './EntityRegistry'
 import { EnumRegistry } from './EnumRegistry'
 import { ColumnDefinition } from '../fieldDefinitions'
 import { applyEntityExtensions } from '../extensions'
+import { StrictOptions, StrictDefinitionValidator } from '../../../strict'
 
 export class SchemaBuilder {
 	private entityRegistry = new EntityRegistry()
 
 	private enumRegistry = new EnumRegistry()
 
-	constructor(private readonly conventions: NamingConventions) {}
+	constructor(
+		private readonly conventions: NamingConventions,
+		private readonly strictDefinitionValidator: StrictDefinitionValidator = new StrictDefinitionValidator({}),
+	) {}
 
 	public addEntity(name: string, entity: EntityConstructor): void {
 		this.entityRegistry.register(name, entity)
@@ -47,6 +51,7 @@ export class SchemaBuilder {
 							conventions: this.conventions,
 							enumRegistry: this.enumRegistry,
 							entityRegistry: this.entityRegistry,
+							strictDefinitionValidator: this.strictDefinitionValidator,
 						})
 					})
 					.reduce<Model.Entity['fields']>((acc, field) => {
@@ -67,6 +72,7 @@ export class SchemaBuilder {
 				entityRegistry: this.entityRegistry,
 				conventions: this.conventions,
 				enumRegistry: this.enumRegistry,
+				strictDefinitionValidator: this.strictDefinitionValidator,
 			})
 		})
 
@@ -87,7 +93,7 @@ export class SchemaBuilder {
 		const unique: Model.UniqueConstraint[] = []
 		for (const [fieldName, definition] of Object.entries(fieldDefinitions)) {
 			if (definition.options.unique) {
-				unique.push({ fields: [fieldName] })
+				unique.push({ fields: [fieldName], ...definition.options.unique })
 			}
 		}
 		return unique

package/src/presets.ts

@@ -6,6 +6,19 @@ const v1_3preset: Settings.Schema = {
 		inviteExpirationMinutes: 60 * 24 * 7, // 7 days
 	},
 }
+
+
+const v1_4preset: Settings.Schema = {
+	tenant: {
+		inviteExpirationMinutes: 60 * 24 * 7, // 7 days
+	},
+	content: {
+		shortDateResponse: true,
+		useExistsInHasManyFilter: true,
+	},
+}
+
 export const settingsPresets = {
 	'v1.3': v1_3preset,
+	'v1.4': v1_4preset,
 }

package/src/strict.ts

@@ -0,0 +1,40 @@
+import { Model } from '@contember/schema'
+
+export type StrictOptions = {
+	requireOnDelete?: boolean
+	requireInverseSide?: boolean
+}
+
+export const allStrict: StrictOptions = {
+	requireOnDelete: true,
+	requireInverseSide: true,
+}
+
+
+export type Warning = { message: string }
+
+export class StrictDefinitionValidator {
+	public readonly warnings: Warning[] = []
+
+	constructor(
+		private readonly options: StrictOptions,
+	) {
+	}
+
+	public validateInverseSide(entityName: string, field: string, definition: { inversedBy?: string }): void {
+		if (!definition.inversedBy && this.options.requireInverseSide) {
+			this.registerWarning(`${entityName}.${field}: inverse side of the relation is not defined.`)
+		}
+	}
+
+
+	public validateOnCascade(entityName: string, field: string, definition: { onDelete?: Model.OnDelete}): void {
+		if (!definition.onDelete && this.options.requireOnDelete) {
+			this.registerWarning(`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`)
+		}
+	}
+
+	public registerWarning(message: string): void {
+		this.warnings.push({ message })
+	}
+}

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

@@ -97,3 +97,26 @@ test('basic createSchema test', () => {
 		}
 	`)
 })
+
+
+namespace StrictModel {
+	export class Genre {
+		name = c.stringColumn()
+
+	}
+	export class Book {
+		title = c.stringColumn()
+		genre = c.manyHasOne(Genre)
+	}
+}
+
+test('strict test', () => {
+	const cb = () => createSchema(StrictModel, schema => ({
+		...schema,
+		settings: settingsPresets['v1.3'],
+	}), { strict: true })
+
+	expect(cb).toThrow(`Strict schema validation failed: 
+- Book.genre: inverse side of the relation is not defined.
+- Book.genre: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`)
+})

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

@@ -10,16 +10,14 @@ namespace ExtendedModel {
 	}
 
 	const addField = (name: string, field: FieldDefinition<any>): DecoratorFunction<any> => {
-		return extendEntity(({ entity, conventions, entityRegistry, enumRegistry }) => ({
+		return extendEntity(({ entity, ...context }) => ({
 			...entity,
 			fields: {
 				...entity.fields,
 				[name]: field.createField({
 					name,
-					enumRegistry,
-					entityRegistry,
-					conventions,
 					entityName: entity.name,
+					...context,
 				}),
 			},
 		}))