@contember/schema-migrations 1.3.0-rc.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "1.3.0-rc.2",
+  "version": "1.3.0",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -12,15 +12,15 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/database-migrations": "1.3.0-rc.2",
-    "@contember/engine-common": "1.3.0-rc.2",
-    "@contember/schema": "1.3.0-rc.2",
-    "@contember/schema-utils": "1.3.0-rc.2",
+    "@contember/database-migrations": "1.3.0",
+    "@contember/engine-common": "1.3.0",
+    "@contember/schema": "1.3.0",
+    "@contember/schema-utils": "1.3.0",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.0.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "1.3.0-rc.2"
+    "@contember/schema-definition": "1.3.0"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/SchemaDiffer.ts

@@ -35,7 +35,7 @@ import {
 	UpdateValidationSchemaDiffer,
 	VERSION_LATEST,
 } from './modifications'
-import { ChangeViewNonViewDiffer, RemoveChangedFieldDiffer, RemoveChangedViewDiffer } from './modifications/differs'
+import { RemoveChangedFieldDiffer, RemoveViewDiffer } from './modifications/differs'
 import { CreateIndexDiffer, RemoveIndexDiffer } from './modifications/indexes'
 import { CreateTriggerDiffer, RemoveTriggerDiffer, UpdateTriggerDiffer } from './modifications/actions'
 import { UpdateTargetDiffer } from './modifications/actions/UpdateTargetModification'
@@ -71,8 +71,7 @@ export class SchemaDiffer {
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
 			new RemoveUniqueConstraintDiffer(),
 			new RemoveIndexDiffer(),
-			new ChangeViewNonViewDiffer(),
-			new RemoveChangedViewDiffer(),
+			new RemoveViewDiffer(),
 			new RemoveEntityDiffer(),
 			new RemoveFieldDiffer(),
 			new CreateEnumDiffer(),

package/src/modifications/differs/{RemoveChangedViewDiffer.ts → RemoveViewDiffer.ts}

@@ -4,26 +4,49 @@ import deepEqual from 'fast-deep-equal'
 import { cascadeRemoveDependantViews } from '../utils/viewDependencies'
 import { UpdateColumnDefinitionDiffer } from '../columns'
 
-export class RemoveChangedViewDiffer implements Differ {
+/**
+ * Remove changed or removed view.
+ */
+export class RemoveViewDiffer implements Differ {
 	constructor() {
 	}
 
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		const changedViews = Object.values(originalSchema.model.entities)
+		const changedOrRemovedViews = Object.values(originalSchema.model.entities)
 			.filter(it => {
 				const updatedEntity = updatedSchema.model.entities[it.name]
-				if (!updatedEntity || !it.view || !updatedEntity.view) {
-					return false
+
+				if (!updatedEntity && !!it.view) {
+					return true // view entity removed
+				}
+
+				if (!updatedEntity) {
+					return false // non-view entity removed
+				}
+
+				if (!updatedEntity.view && !it.view) {
+					return false // none is view
+				}
+
+				if (!!it.view !== !!updatedEntity.view) {
+					return true // change between regular entity and view entity
+				}
+
+				if (!deepEqual(updatedEntity.view, it.view)) {
+					return true // view is different
 				}
-				return !deepEqual(updatedEntity.view, it.view)
+
+				return false
 			})
+
 		const columnDiffer = new UpdateColumnDefinitionDiffer()
 		const columnChanges = columnDiffer.createDiff(originalSchema, updatedSchema)
-		if (changedViews.length === 0 && columnChanges.length === 0) {
+		if (changedOrRemovedViews.length === 0 && columnChanges.length === 0) {
 			return []
 		}
+
 		const changedColumnsEntities = Array.from(new Set(columnChanges.map(it => it.entityName)))
 			.map(it => originalSchema.model.entities[it])
-		return cascadeRemoveDependantViews(originalSchema.model, [...changedViews, ...changedColumnsEntities])
+		return cascadeRemoveDependantViews(originalSchema.model, [...changedOrRemovedViews, ...changedColumnsEntities])
 	}
 }

package/src/modifications/differs/index.ts

@@ -1,3 +1,2 @@
-export * from './ChangeViewNonViewDiffer'
 export * from './RemoveChangedFieldDiffer'
-export * from './RemoveChangedViewDiffer'
+export * from './RemoveViewDiffer'

package/src/modifications/utils/viewDependencies.ts

@@ -21,14 +21,14 @@ export const getEntityDependantViews = (model: Model.Schema): EntityDependantVie
 }
 
 export const cascadeRemoveDependantViews = (model: Model.Schema, entities: Model.Entity[]): Migration.Modification[] => {
-	const removed = new Set<string>()
+	const visited = new Set<string>()
 	const dependants = getEntityDependantViews(model)
 	const modifications: Migration.Modification[] = []
 	const removeCascade = (entity: Model.Entity) => {
-		if (removed.has(entity.name)) {
+		if (visited.has(entity.name)) {
 			return
 		}
-		removed.add(entity.name)
+		visited.add(entity.name)
 		for (const dependant of dependants.get(entity.name) ?? []) {
 			removeCascade(dependant)
 		}

package/tests/cases/integration/convertOneHasManyToManyHasManyRelation.test.ts

@@ -1,6 +1,6 @@
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 
 namespace ConvertOHMToMHMSchemaOrig {
 	export class Article {
@@ -26,8 +26,8 @@ namespace ConvertOHMToMHMSchemaOrigUpdated {
 
 
 testMigrations('convert one has many to many has many', {
-	originalSchema: def.createModel(ConvertOHMToMHMSchemaOrig),
-	updatedSchema: def.createModel(ConvertOHMToMHMSchemaOrigUpdated),
+	original: createSchema(ConvertOHMToMHMSchemaOrig),
+	updated: createSchema(ConvertOHMToMHMSchemaOrigUpdated),
 	diff: [
 		{
 			modification: 'convertOneHasManyToManyHasManyRelation',

package/tests/cases/integration/convertOneToManyRelation.test.ts

@@ -4,18 +4,22 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('convert one has one to many has one relation without inverse side', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.oneHasOne('image', rel => rel.target('Image')),
-		)
-		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.manyHasOne('image', rel => rel.target('Image')),
-		)
-		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.oneHasOne('image', rel => rel.target('Image')),
+			)
+			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.manyHasOne('image', rel => rel.target('Image')),
+			)
+			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'convertOneToManyRelation',
@@ -31,18 +35,22 @@ testMigrations('convert one has one to many has one relation without inverse sid
 
 
 testMigrations('convert one has one to many has one relation with inverse side', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.oneHasOne('image', rel => rel.target('Image').inversedBy('post')),
-		)
-		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')),
-		)
-		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.oneHasOne('image', rel => rel.target('Image').inversedBy('post')),
+			)
+			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')),
+			)
+			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'convertOneToManyRelation',

package/tests/cases/integration/createAndDropIndex.test.ts

@@ -1,6 +1,6 @@
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 
 namespace SchemaWithoutIndex {
 	export class Article {
@@ -17,8 +17,8 @@ namespace SchemaWithIndex {
 
 
 testMigrations('create index', {
-	originalSchema: def.createModel(SchemaWithoutIndex),
-	updatedSchema: def.createModel(SchemaWithIndex),
+	original: createSchema(SchemaWithoutIndex),
+	updated: createSchema(SchemaWithIndex),
 	diff: [
 		{
 			modification: 'createIndex',
@@ -31,8 +31,8 @@ testMigrations('create index', {
 
 
 testMigrations('drop index', {
-	originalSchema: def.createModel(SchemaWithIndex),
-	updatedSchema: def.createModel(SchemaWithoutIndex),
+	original: createSchema(SchemaWithIndex),
+	updated: createSchema(SchemaWithoutIndex),
 	diff: [
 		{
 			modification: 'removeIndex',

package/tests/cases/integration/createColumn.test.ts

@@ -1,15 +1,15 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 import { testMigrations } from '../../src/tests'
 
 testMigrations('create a column with default value', {
-	originalSchema: def.createModel({
+	original: createSchema({
 		Author: class Author {
 			email = def.stringColumn().unique()
 		},
 	}),
-	updatedSchema: def.createModel({
+	updated: createSchema({
 		Author: class Author {
 			name = def.stringColumn().default('unnamed author').notNull()
 			email = def.stringColumn().unique()
@@ -37,12 +37,12 @@ ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
 })
 
 testMigrations('create a column with copy value', {
-	originalSchema: def.createModel({
+	original: createSchema({
 		Author: class Author {
 			email = def.stringColumn().unique()
 		},
 	}),
-	updatedSchema: def.createModel({
+	updated: createSchema({
 		Author: class Author {
 			name = def.stringColumn().notNull()
 			email = def.stringColumn().unique()

package/tests/cases/integration/createEntity.test.ts

@@ -1,19 +1,21 @@
-import { SchemaBuilder } from '@contember/schema-definition'
+import { createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 import { testMigrations } from '../../src/tests'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 
 testMigrations('create a table (no relations, unique on column)', {
-	originalSchema: new SchemaBuilder().buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e =>
-			e
-				.column('name', c => c.type(Model.ColumnType.String))
-				.column('email', c => c.type(Model.ColumnType.String).unique())
-				.column('registeredAt', c => c.type(Model.ColumnType.Date)),
-		)
-		.buildSchema(),
+	original: {  },
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e =>
+				e
+					.column('name', c => c.type(Model.ColumnType.String))
+					.column('email', c => c.type(Model.ColumnType.String).unique())
+					.column('registeredAt', c => c.type(Model.ColumnType.Date)),
+			)
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEntity',
@@ -108,8 +110,8 @@ namespace ViewEntityUpdatedSchema {
 	}
 }
 testMigrations('create a view', {
-	originalSchema: new SchemaBuilder().buildSchema(),
-	updatedSchema: def.createModel(ViewEntityUpdatedSchema),
+	original: {},
+	updated: createSchema(ViewEntityUpdatedSchema),
 	diff: [
 		{
 			modification: 'createView',

package/tests/cases/integration/createEnum.test.ts

@@ -4,17 +4,21 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('create enum', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e
-				.column('title', c => c.type(Model.ColumnType.String))
-				.column('status', c => c.type(Model.ColumnType.Enum, { enumName: 'postStatus' })),
-		)
-		.enum('postStatus', ['publish', 'draft'])
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e
+					.column('title', c => c.type(Model.ColumnType.String))
+					.column('status', c => c.type(Model.ColumnType.Enum, { enumName: 'postStatus' })),
+			)
+			.enum('postStatus', ['publish', 'draft'])
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEnum',

package/tests/cases/integration/createManyHasMany.test.ts

@@ -4,15 +4,19 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('create many has many relation (post with categories)', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e.column('title', c => c.type(Model.ColumnType.String)).manyHasMany('categories', r => r.target('Category')),
-		)
-		.entity('Category', e => e.column('title', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e.column('title', c => c.type(Model.ColumnType.String)).manyHasMany('categories', r => r.target('Category')),
+			)
+			.entity('Category', e => e.column('title', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEntity',

package/tests/cases/integration/createManyHasOne.test.ts

@@ -4,17 +4,21 @@ import { SQL } from '../../src/tags'
 import { testMigrations } from '../../src/tests'
 
 testMigrations('create many has one relation (post with author)', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.entity('Post', e =>
-			e
-				.column('title', c => c.type(Model.ColumnType.String))
-				.manyHasOne('author', r => r.target('Author').onDelete(Model.OnDelete.cascade)),
-		)
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.entity('Post', e =>
+				e
+					.column('title', c => c.type(Model.ColumnType.String))
+					.manyHasOne('author', r => r.target('Author').onDelete(Model.OnDelete.cascade)),
+			)
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEntity',

package/tests/cases/integration/createOneHasMany.test.ts

@@ -4,18 +4,20 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('create one has many relation (post with locales)', {
-	originalSchema: new SchemaBuilder().entity('Post', e => e).buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e.oneHasMany('locales', r => r.target('PostLocale').ownerNotNull().ownedBy('post').orderBy('title')),
-		)
-		.entity('PostLocale', e =>
-			e
-				.unique(['post', 'locale'])
-				.column('title', c => c.type(Model.ColumnType.String))
-				.column('locale', c => c.type(Model.ColumnType.String)),
-		)
-		.buildSchema(),
+	original: { model: new SchemaBuilder().entity('Post', e => e).buildSchema() },
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e.oneHasMany('locales', r => r.target('PostLocale').ownerNotNull().ownedBy('post').orderBy('title')),
+			)
+			.entity('PostLocale', e =>
+				e
+					.unique(['post', 'locale'])
+					.column('title', c => c.type(Model.ColumnType.String))
+					.column('locale', c => c.type(Model.ColumnType.String)),
+			)
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEntity',

package/tests/cases/integration/createOneHasOne.test.ts

@@ -4,15 +4,17 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('create one has one relation (site with settings)', {
-	originalSchema: new SchemaBuilder().buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Site', entity =>
-			entity
-				.column('name', c => c.type(Model.ColumnType.String))
-				.oneHasOne('setting', r => r.target('SiteSetting').inversedBy('site')),
-		)
-		.entity('SiteSetting', e => e.column('url', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Site', entity =>
+				entity
+					.column('name', c => c.type(Model.ColumnType.String))
+					.oneHasOne('setting', r => r.target('SiteSetting').inversedBy('site')),
+			)
+			.entity('SiteSetting', e => e.column('url', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createEntity',

package/tests/cases/integration/createRelationInverseSide.test.ts

@@ -4,14 +4,18 @@ import { SQL } from '../../src/tags'
 import { SchemaBuilder } from '@contember/schema-definition'
 
 testMigrations('create inverse side relation (post with locales)', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e)
-		.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e => e)
-		.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post').inversedBy('locales')))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e)
+			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e)
+			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post').inversedBy('locales')))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'createRelationInverseSide',
@@ -28,16 +32,20 @@ testMigrations('create inverse side relation (post with locales)', {
 })
 
 testMigrations('create inverse side relation together with changing onDelete behaviour', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e)
-		.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e => e)
-		.entity('PostLocale', e =>
-			e.manyHasOne('post', r => r.target('Post').inversedBy('locales').onDelete(Model.OnDelete.cascade)),
-		)
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e)
+			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e)
+			.entity('PostLocale', e =>
+				e.manyHasOne('post', r => r.target('Post').inversedBy('locales').onDelete(Model.OnDelete.cascade)),
+			)
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateRelationOnDelete',

package/tests/cases/integration/createView.test.ts

@@ -1,6 +1,6 @@
 import { testMigrations } from '../../src/tests.js'
 import { SQL } from '../../src/tags.js'
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 
 namespace ViewEntityOriginalSchema {
 
@@ -24,8 +24,8 @@ namespace ViewEntityUpdatedSchema {
 
 
 testMigrations('create view', {
-	originalSchema: def.createModel(ViewEntityOriginalSchema),
-	updatedSchema: def.createModel(ViewEntityUpdatedSchema),
+	original: createSchema(ViewEntityOriginalSchema),
+	updated: createSchema(ViewEntityUpdatedSchema),
 	diff: [
 		{
 			modification: 'createView',
@@ -118,7 +118,7 @@ namespace ViewAddRelationUpdateSchema {
 
 
 testMigrations('create a relation and a view', {
-	originalSchema: def.createModel(ViewAddRelationOriginalSchema), updatedSchema: def.createModel(ViewAddRelationUpdateSchema), diff: [
+	original: createSchema(ViewAddRelationOriginalSchema), updated: createSchema(ViewAddRelationUpdateSchema), diff: [
 		{
 			modification: 'createRelation',
 			entityName: 'Article',

package/tests/cases/integration/disableOrphanRemoval.test.ts

@@ -4,20 +4,24 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('disable orphan removal', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity
-				.column('name', c => c.type(Model.ColumnType.String))
-				.oneHasOne('content', r => r.target('Content').removeOrphan()),
-		)
-		.entity('Content', e => e.column('text', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.column('name', c => c.type(Model.ColumnType.String)).oneHasOne('content', r => r.target('Content')),
-		)
-		.entity('Content', e => e.column('text', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity
+					.column('name', c => c.type(Model.ColumnType.String))
+					.oneHasOne('content', r => r.target('Content').removeOrphan()),
+			)
+			.entity('Content', e => e.column('text', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.column('name', c => c.type(Model.ColumnType.String)).oneHasOne('content', r => r.target('Content')),
+			)
+			.entity('Content', e => e.column('text', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'disableOrphanRemoval',