@contember/schema-definition 2.1.0-beta.2 → 2.1.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-definition",
-  "version": "2.1.0-beta.2",
+  "version": "2.1.0-rc.2",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",

package/src/createSchema.ts

@@ -17,13 +17,14 @@ export const createSchema = (definitions: Record<string, any>, modifyCallback?:
 		strictDefinitionValidator: strictDefinitionValidator,
 		defaultCollation: options?.defaultCollation,
 	})
+	strictDefinitionValidator.validateModel(model)
 	const validation = InputValidation.parseDefinition(definitions)
 	const acl = AclDefinition.createAcl(definitions, model)
 	const actions = ActionsDefinition.createActions(definitions)
 	const schema = { ...emptySchema, model, validation, acl, actions }
 
 	if (strictDefinitionValidator.warnings.length > 0) {
-		throw `Strict schema validation failed: \n${strictDefinitionValidator.warnings.map(it => `- ${it.message}`).join('\n')}`
+		throw `Strict schema validation failed:\n${strictDefinitionValidator.warnings.map(it => `- ${it.message}`).join('\n')}`
 	}
 
 	return modifyCallback ? modifyCallback(schema) : schema

package/src/strict.ts

@@ -12,9 +12,17 @@ export const allStrict: StrictOptions = {
 
 export type Warning = { message: string }
 
+type OnDeleteValidation = {
+	entityName: string
+	field: string
+	hasOnDelete: boolean
+}
+
 export class StrictDefinitionValidator {
 	public readonly warnings: Warning[] = []
 
+	private readonly onDeleteValidations: OnDeleteValidation[] = []
+
 	constructor(
 		private readonly options: StrictOptions,
 	) {
@@ -27,10 +35,27 @@ export class StrictDefinitionValidator {
 	}
 
 	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().`,
-			)
+		// View entities are read-only and have no real delete semantics, so onDelete validation is
+		// deferred to validateModel() where we know which entities are views.
+		this.onDeleteValidations.push({ entityName, field, hasOnDelete: definition.onDelete !== undefined })
+	}
+
+	public validateModel(model: Model.Schema): void {
+		for (const { entityName, field, hasOnDelete } of this.onDeleteValidations) {
+			const isView = model.entities[entityName]?.view !== undefined
+			if (isView) {
+				if (hasOnDelete) {
+					this.registerWarning(
+						`${entityName}.${field}: onDelete behaviour must not be set on a relation of a view entity. Views are read-only and have no delete semantics.`,
+					)
+				}
+				continue
+			}
+			if (!hasOnDelete && this.options.requireOnDelete) {
+				this.registerWarning(
+					`${entityName}.${field}: onDelete behaviour is not set. Use one of cascadeOnDelete(), setNullOnDelete() or restrictOnDelete().`,
+				)
+			}
 		}
 	}
 

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

@@ -113,7 +113,56 @@ test('strict test', () => {
 			settings: settingsPresets['v1.3'],
 		}), { strict: true })
 
-	expect(cb).toThrow(`Strict schema validation failed: 
+	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().`)
 })
+
+namespace StrictViewModel {
+	export class Author {
+		name = c.stringColumn()
+		stats = c.oneHasOneInverse(AuthorStats, 'author')
+	}
+
+	@c.View('SELECT 1')
+	export class AuthorStats {
+		author = c.oneHasOne(Author, 'stats')
+		postCount = c.intColumn().notNull()
+	}
+}
+
+test('strict test: onDelete is not required on a view entity relation', () => {
+	const cb = () =>
+		createSchema(StrictViewModel, schema => ({
+			...schema,
+			settings: settingsPresets['v1.3'],
+		}), { strict: true })
+
+	// AuthorStats.author has an inverse side defined and is a view relation, so neither the
+	// inverse-side nor the onDelete strict checks should fire.
+	expect(cb).not.toThrow()
+})
+
+namespace StrictViewWithOnDeleteModel {
+	export class Author {
+		name = c.stringColumn()
+		stats = c.oneHasOneInverse(AuthorStats, 'author')
+	}
+
+	@c.View('SELECT 1')
+	export class AuthorStats {
+		author = c.oneHasOne(Author, 'stats').cascadeOnDelete()
+		postCount = c.intColumn().notNull()
+	}
+}
+
+test('strict test: onDelete must not be set on a view entity relation', () => {
+	const cb = () =>
+		createSchema(StrictViewWithOnDeleteModel, schema => ({
+			...schema,
+			settings: settingsPresets['v1.3'],
+		}), { strict: true })
+
+	expect(cb).toThrow(`Strict schema validation failed:
+- AuthorStats.author: onDelete behaviour must not be set on a relation of a view entity. Views are read-only and have no delete semantics.`)
+})