@contember/schema-migrations 1.2.0-alpha.9 → 1.2.0-beta.2

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

@@ -86,3 +86,73 @@ testMigrations('create view', {
 	sql: SQL`CREATE VIEW "author_stats" AS SELECT 1;`,
 })
 
+
+namespace ViewAddRelationOriginalSchema {
+	export class Article {
+		title = def.stringColumn()
+	}
+
+
+	export class Category {
+		name = def.stringColumn()
+	}
+}
+
+namespace ViewAddRelationUpdateSchema {
+	export class Article {
+		title = def.stringColumn()
+		category = def.manyHasOne(Category)
+		stats = def.oneHasOneInverse(ArticleStats, 'article')
+	}
+
+	export class Category {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT 1')
+	export class ArticleStats {
+		article = def.oneHasOne(Article, 'stats')
+		visitCount = def.intColumn()
+	}
+}
+
+
+testMigrations('create a relation and a view', {
+	originalSchema: def.createModel(ViewAddRelationOriginalSchema), updatedSchema: def.createModel(ViewAddRelationUpdateSchema), diff: [
+		{
+			modification: 'createRelation',
+			entityName: 'Article',
+			owningSide: { name: 'category', nullable: true, type: 'ManyHasOne', target: 'Category', joiningColumn: { columnName: 'category_id', onDelete: 'restrict' } },
+		},
+		{
+			modification: 'createView',
+			entity: { name: 'ArticleStats',
+				primary: 'id',
+				primaryColumn: 'id',
+				unique: {},
+				indexes: {},
+				fields: { id: { name: 'id', columnName: 'id', nullable: false, type: 'Uuid', columnType: 'uuid' },
+					article: { name: 'article', inversedBy: 'stats', nullable: true, type: 'OneHasOne', target: 'Article', joiningColumn: { columnName: 'article_id', onDelete: 'restrict' } },
+					visitCount: { name: 'visitCount', columnName: 'visit_count', nullable: true, type: 'Integer', columnType: 'integer' } },
+				tableName: 'article_stats',
+				eventLog: { enabled: true },
+				view: { sql: 'SELECT 1' } },
+		},
+		{
+			modification: 'createRelationInverseSide',
+			entityName: 'Article',
+			relation: {
+				name: 'stats',
+				ownedBy: 'article',
+				target: 'ArticleStats',
+				type: 'OneHasOne',
+				nullable: true,
+			},
+		},
+	],
+	sql: SQL`ALTER TABLE "article" ADD "category_id" uuid; 
+ALTER TABLE "article" ADD CONSTRAINT "fk_article_category_id_703b8b" FOREIGN KEY ("category_id") REFERENCES "category"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE; 
+CREATE INDEX "article_category_id_index" ON "article" ("category_id"); 
+CREATE VIEW "article_stats" AS SELECT 1;`,
+})
+

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

@@ -2,6 +2,8 @@ import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
 
 testMigrations('remove relation (many has one)', {
 	originalSchema: new SchemaBuilder()
@@ -128,3 +130,59 @@ testMigrations('remove relation inverse side', {
 	],
 	sql: SQL``,
 })
+
+
+namespace DropIndexOrigSchema {
+
+	@def.Unique('title', 'author')
+	@def.Index('title', 'author')
+	export class Article {
+		title = def.stringColumn()
+		author = def.manyHasOne(Author)
+	}
+
+	export class Author {
+		name = def.stringColumn()
+	}
+}
+
+namespace DropIndexUpSchema {
+	@def.Unique('title', 'author')
+	@def.Index('title', 'author')
+	export class Article {
+		title = def.stringColumn()
+		author = def.stringColumn()
+	}
+
+	export class Author {
+		name = def.stringColumn()
+	}
+}
+
+
+testMigrations('test drop index / unique when removing a field', {
+	originalSchema: def.createModel(DropIndexOrigSchema),
+	updatedSchema: def.createModel(DropIndexUpSchema),
+	diff: [{
+		modification: 'removeField',
+		entityName: 'Article',
+		fieldName: 'author',
+	}, {
+		modification: 'createColumn',
+		entityName: 'Article',
+		field: { name: 'author', columnName: 'author', nullable: true, type: 'String', columnType: 'text' },
+	}, {
+		modification: 'createUniqueConstraint',
+		entityName: 'Article',
+		unique: { name: 'unique_Article_title_author_7157ea', fields: ['title', 'author'] },
+	}, {
+		modification: 'createIndex',
+		entityName: 'Article',
+		index: { name: 'idx_Article_title_author_7157ea', fields: ['title', 'author'] },
+	}],
+	sql: SQL`ALTER TABLE "article" DROP "author_id";
+ALTER TABLE "article" ADD "author" text;
+ALTER TABLE "article" ADD CONSTRAINT "unique_Article_title_author_7157ea" UNIQUE ("title", "author");
+CREATE INDEX "idx_Article_title_author_7157ea" ON "article" ("title", "author");`,
+})
+

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

@@ -0,0 +1,314 @@
+import { test } from 'vitest'
+import { testGenerateSql } from '../../src/tests'
+import {
+	createEntityModification,
+	createRelationModification,
+	removeFieldModification,
+	updateEntityNameModification,
+} from '../../../src'
+import { emptyModelSchema } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { SQL } from '../../src/tags'
+
+test('taken fk index name', () => {
+	testGenerateSql(emptyModelSchema, [
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Author',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'author',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'author',
+				type: Model.RelationType.ManyHasOne,
+				target: 'Author',
+				joiningColumn: {
+					columnName: 'author_id',
+					onDelete: Model.OnDelete.cascade,
+				},
+				nullable: true,
+			},
+
+		}),
+		updateEntityNameModification.createModification({
+			entityName: 'Post',
+			newEntityName: 'Article',
+			tableName: 'article',
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'author',
+				type: Model.RelationType.ManyHasOne,
+				target: 'Author',
+				joiningColumn: {
+					columnName: 'author_id',
+					onDelete: Model.OnDelete.cascade,
+				},
+				nullable: true,
+			},
+
+		}),
+	], SQL`CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "author" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+ALTER TABLE "post"
+  ADD "author_id" uuid;
+ALTER TABLE "post"
+  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
+CREATE INDEX "post_author_id_index" ON "post" ("author_id");
+ALTER TABLE "post" RENAME TO "article";
+CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+ALTER TABLE "post"
+  ADD "author_id" uuid;
+ALTER TABLE "post"
+  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
+CREATE INDEX "post_author_id_index1" ON "post" ("author_id");`)
+})
+
+
+test('taken junction table index name', () => {
+	testGenerateSql(emptyModelSchema, [
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Post',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'post',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createEntityModification.createModification({
+			entity: {
+				fields: {
+					id: {
+						columnName: 'id',
+						name: 'id',
+						nullable: false,
+						type: Model.ColumnType.Uuid,
+						columnType: 'uuid',
+					},
+				},
+				name: 'Author',
+				primary: 'id',
+				primaryColumn: 'id',
+				tableName: 'author',
+				unique: {},
+				eventLog: {
+					enabled: true,
+				},
+				indexes: {},
+			},
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'authors',
+				type: Model.RelationType.ManyHasMany,
+				target: 'Author',
+				joiningTable: {
+					tableName: 'post_authors',
+					joiningColumn: {
+						columnName: 'post_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					inverseJoiningColumn: {
+						columnName: 'author_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					eventLog: {
+						enabled: true,
+					},
+				},
+			},
+		}),
+		removeFieldModification.createModification({
+			entityName: 'Post',
+			fieldName: 'authors',
+		}),
+		createRelationModification.createModification({
+			entityName: 'Post',
+			owningSide: {
+				name: 'authors',
+				type: Model.RelationType.ManyHasMany,
+				target: 'Author',
+				joiningTable: {
+					tableName: 'post_authors',
+					joiningColumn: {
+						columnName: 'post_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					inverseJoiningColumn: {
+						columnName: 'author_id',
+						onDelete: Model.OnDelete.cascade,
+					},
+					eventLog: {
+						enabled: true,
+					},
+				},
+			},
+		}),
+	], SQL`CREATE TABLE "post" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "author" (
+  "id" uuid PRIMARY KEY NOT NULL
+);
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "author"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+CREATE TABLE "post_authors" (
+  "post_id" uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
+  "author_id" uuid NOT NULL REFERENCES "author"("id") ON DELETE CASCADE
+);
+ALTER TABLE "post_authors"
+  ADD CONSTRAINT "post_authors_pkey" PRIMARY KEY ("post_id", "author_id");
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$post_id$pga$, $pga$author_id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+DROP TABLE "post_authors";
+CREATE TABLE "post_authors" (
+  "post_id" uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
+  "author_id" uuid NOT NULL REFERENCES "author"("id") ON DELETE CASCADE
+);
+ALTER TABLE "post_authors"
+  ADD CONSTRAINT "post_authors_pkey1" PRIMARY KEY ("post_id", "author_id");
+CREATE TRIGGER "log_event"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event"($pga$post_id$pga$, $pga$author_id$pga$);
+CREATE CONSTRAINT TRIGGER "log_event_trx"
+  AFTER INSERT OR UPDATE OR DELETE ON "post_authors"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE PROCEDURE "system"."trigger_event_commit"();
+`)
+})

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

@@ -1,7 +1,8 @@
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { SchemaBuilder, SchemaDefinition as def, createSchema } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { updateColumnDefinitionModification } from '../../../src'
 
 testMigrations('update column definition', {
 	originalSchema: new SchemaBuilder()
@@ -31,3 +32,139 @@ testMigrations('update column definition', {
 	sql: SQL`ALTER TABLE "author"
 		ALTER "registered_at" SET DATA TYPE timestamptz USING "registered_at"::timestamptz;`,
 })
+
+namespace SeqOrig {
+	export class Author {
+		idSeq = def.intColumn()
+	}
+}
+namespace SeqUpdated {
+	export class Author {
+		idSeq = def.intColumn().notNull().sequence({ start: 10 })
+	}
+}
+testMigrations('add sequence to existing column', {
+	originalSchema: createSchema(SeqOrig).model,
+	updatedSchema: createSchema(SeqUpdated).model,
+	diff: [
+		updateColumnDefinitionModification.createModification({
+			entityName: 'Author',
+			fieldName: 'idSeq',
+			definition: {
+				type: Model.ColumnType.Int,
+				columnType: 'integer',
+				nullable: false,
+				sequence: {
+					precedence: 'BY DEFAULT',
+					start: 10,
+				},
+			},
+		}),
+	],
+	sql: SQL`
+ALTER TABLE "author"
+		ALTER "id_seq" SET DATA TYPE integer USING COALESCE("id_seq"::integer, nextval(PG_GET_SERIAL_SEQUENCE($pga$author$pga$, $pga$id_seq$pga$))),
+		ALTER "id_seq" SET NOT NULL,
+		ALTER "id_seq" ADD GENERATED BY DEFAULT AS IDENTITY (START WITH 10);`,
+})
+
+
+namespace ViewColDepOrig {
+	export class Author {
+		val = def.intColumn()
+	}
+
+	@def.View('SELECT * FROM author', {
+		dependencies: [Author],
+	})
+	export class AuthorMetaX {
+
+	}
+
+	@def.View('SELECT * FROM author_meta_x', {
+		dependencies: [AuthorMetaX],
+	})
+	export class AuthorMetaY {
+	}
+}
+
+namespace ViewColDepUpdated {
+	export class Author {
+		val = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author', {
+		dependencies: [Author],
+	})
+	export class AuthorMetaX {
+
+	}
+
+	@def.View('SELECT * FROM author_meta_x', {
+		dependencies: [AuthorMetaX],
+	})
+	export class AuthorMetaY {
+	}
+}
+
+testMigrations('recreate view dependent on entity after changing column type', {
+	originalSchema: createSchema(ViewColDepOrig).model,
+	updatedSchema: createSchema(ViewColDepUpdated).model,
+	diff: [{ modification: 'removeEntity', entityName: 'AuthorMetaY' }, {
+		modification: 'removeEntity',
+		entityName: 'AuthorMetaX',
+	}, {
+		modification: 'updateColumnDefinition',
+		entityName: 'Author',
+		fieldName: 'val',
+		definition: { nullable: true, type: 'String', columnType: 'text' },
+	}, {
+		modification: 'createView',
+		entity: {
+			name: 'AuthorMetaX',
+			primary: 'id',
+			primaryColumn: 'id',
+			unique: {},
+			indexes: {},
+			fields: {
+				id: {
+					name: 'id',
+					columnName: 'id',
+					nullable: false,
+					type: 'Uuid',
+					columnType: 'uuid',
+				},
+			},
+			tableName: 'author_meta_x',
+			eventLog: { enabled: true },
+			view: { sql: 'SELECT * FROM author', dependencies: ['Author'] },
+		},
+	}, {
+		modification: 'createView',
+		entity: {
+			name: 'AuthorMetaY',
+			primary: 'id',
+			primaryColumn: 'id',
+			unique: {},
+			indexes: {},
+			fields: {
+				id: {
+					name: 'id',
+					columnName: 'id',
+					nullable: false,
+					type: 'Uuid',
+					columnType: 'uuid',
+				},
+			},
+			tableName: 'author_meta_y',
+			eventLog: { enabled: true },
+			view: { sql: 'SELECT * FROM author_meta_x', dependencies: ['AuthorMetaX'] },
+		},
+	}],
+	sql: SQL`DROP VIEW "author_meta_y";
+DROP VIEW "author_meta_x";
+ALTER TABLE "author"
+  ALTER "val" SET DATA TYPE text USING "val"::text;
+CREATE VIEW "author_meta_x" AS SELECT * FROM author;
+CREATE VIEW "author_meta_y" AS SELECT * FROM author_meta_x;`,
+})

package/tests/scripts/checkCreateConsistentMigrations.ts

@@ -1,4 +1,4 @@
-import { relative } from 'path'
+import { relative } from 'node:path'
 import {
 	MigrationFilesManager,
 	MigrationsResolver,
@@ -18,7 +18,8 @@ import { emptySchema, schemaType } from '@contember/schema-utils'
 	for (const migration of await migrationsResolver.getMigrations()) {
 		const nextSchema = migrator.applyModifications(schema, migration.modifications, migration.formatVersion)
 		schemaType(nextSchema)
-		differ.diffSchemas(schema, nextSchema)
+		const { meta, ...nextSchemaWithoutMeta } = nextSchema
+		differ.diffSchemas(schema, nextSchemaWithoutMeta)
 
 		schema = nextSchema
 	}

package/tests/src/tests.ts

@@ -2,6 +2,8 @@ import { Migration, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VE
 import { Acl, Model } from '@contember/schema'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { assert, describe, it } from 'vitest'
+import { SchemaWithMeta } from '../../src/modifications/utils/schemaMeta'
+import { emptySchema } from '@contember/schema-utils'
 
 const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
 const schemaMigrator = new SchemaMigrator(modificationFactory)
@@ -27,17 +29,24 @@ export function testDiffSchemas(
 	updatedAcl: Acl.Schema = emptyAcl,
 ) {
 	const actualDiff = schemaDiffer.diffSchemas(
-		{ model: originalModel, acl: originalAcl, validation: {} },
-		{ model: updatedModel, acl: updatedAcl, validation: {} },
-		false,
+		{ ...emptySchema, model: originalModel, acl: originalAcl, validation: {} },
+		{ ...emptySchema, model: updatedModel, acl: updatedAcl, validation: {} },
+		{ skipRecreateValidation: true },
 	)
-	assert.deepStrictEqual(actualDiff, expectedDiff)
-	const schema = schemaMigrator.applyModifications(
-		{ model: originalModel, acl: originalAcl, validation: {} },
+	try {
+		assert.deepStrictEqual(actualDiff, expectedDiff)
+	} catch (e) {
+		// eslint-disable-next-line no-console
+		console.log(JSON.stringify(actualDiff))
+		throw e
+	}
+	const { meta, ...schema } = schemaMigrator.applyModifications(
+		{ ...emptySchema, model: originalModel, acl: originalAcl, validation: {} },
 		actualDiff,
 		VERSION_LATEST,
-	)
+	) as SchemaWithMeta
 	assert.deepStrictEqual(schema, {
+		...emptySchema,
 		model: updatedModel,
 		acl: updatedAcl,
 		validation: {},
@@ -51,13 +60,14 @@ export function testApplyDiff(
 	originalAcl: Acl.Schema = emptyAcl,
 	expectedAcl: Acl.Schema = emptyAcl,
 ) {
-	const actualSchema = schemaMigrator.applyModifications(
-		{ model: originalModel, acl: originalAcl, validation: {} },
+	const { meta, ...actualSchema } = schemaMigrator.applyModifications(
+		{ ...emptySchema, model: originalModel, acl: originalAcl, validation: {} },
 		diff,
 		VERSION_LATEST,
-	)
+	) as SchemaWithMeta
 
 	assert.deepStrictEqual(actualSchema, {
+		...emptySchema,
 		model: expectedModel,
 		acl: expectedAcl,
 		validation: {},
@@ -65,7 +75,7 @@ export function testApplyDiff(
 }
 
 export function testGenerateSql(originalSchema: Model.Schema, diff: Migration.Modification[], expectedSql: string) {
-	let schema = { model: originalSchema, acl: emptyAcl, validation: {} }
+	let schema = { ...emptySchema, model: originalSchema, acl: emptyAcl, validation: {} }
 	const builder = createMigrationBuilder()
 	for (let { modification, ...data } of diff) {
 		const modificationHandler = modificationFactory.create(modification, data, schema, { formatVersion: VERSION_LATEST, systemSchema: 'system' })