@contember/schema-migrations 2.1.0-beta.2 → 2.2.0-alpha.2

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

@@ -1,6 +1,6 @@
 import { describe } from 'bun:test'
-import { testMigrations } from '../../src/tests'
-import { SQL } from '../../src/tags'
+import { testMigrations } from '../../src/tests.js'
+import { SQL } from '../../src/tags.js'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 
 namespace ViewEntityOriginalSchema {
@@ -37,99 +37,181 @@ namespace ViewEntityUpdatedSchema1 {
 	}
 }
 
-describe('update a view 1', () =>
+describe('update a view 1 - replace sql in-place, no dependant cascade', () =>
 	testMigrations({
 		original: createSchema(ViewEntityOriginalSchema),
 		updated: createSchema(ViewEntityUpdatedSchema1),
 		diff: [
 			{
-				modification: 'removeEntity',
-				entityName: 'Author3',
+				modification: 'updateView',
+				entityName: 'Author',
+				view: {
+					sql: "SELECT null as id, 'Jack' AS name",
+				},
 			},
+		],
+		sql: SQL`CREATE OR REPLACE VIEW "author" AS SELECT null as id, 'Jack' AS name;`,
+	}))
+
+namespace ViewEntityUpdatedSchema2 {
+	@def.View("SELECT null as id, 'John' AS name")
+	export class Author {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT id, name FROM author', { dependencies: [Author] })
+	export class Author2 {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author2', { dependencies: [Author2] })
+	export class Author3 {
+		name = def.stringColumn()
+	}
+}
+
+describe('update a view 2 - replace dependency in-place', () =>
+	testMigrations({
+		original: createSchema(ViewEntityOriginalSchema),
+		updated: createSchema(ViewEntityUpdatedSchema2),
+		diff: [
 			{
-				modification: 'removeEntity',
+				modification: 'updateView',
 				entityName: 'Author2',
+				view: {
+					sql: 'SELECT id, name FROM author',
+					dependencies: [
+						'Author',
+					],
+				},
 			},
+		],
+		sql: SQL`CREATE OR REPLACE VIEW "author2" AS SELECT id, name FROM author;`,
+	}))
+
+namespace ViewEntityUpdatedSchema3 {
+	@def.View("SELECT null as id, 'John' AS name")
+	export class Author {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author', { dependencies: [Author] })
+	export class Author2 {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT id, name FROM author2', { dependencies: [Author2] })
+	export class Author3 {
+		name = def.stringColumn()
+	}
+}
+
+describe('update a view 3 - replace leaf view in-place', () =>
+	testMigrations({
+		original: createSchema(ViewEntityOriginalSchema),
+		updated: createSchema(ViewEntityUpdatedSchema3),
+		diff: [
 			{
-				modification: 'removeEntity',
+				modification: 'updateView',
+				entityName: 'Author3',
+				view: {
+					sql: 'SELECT id, name FROM author2',
+					dependencies: [
+						'Author2',
+					],
+				},
+			},
+		],
+		sql: SQL`CREATE OR REPLACE VIEW "author3" AS SELECT id, name FROM author2;`,
+	}))
+
+namespace ViewEntityUpdatedSchema4 {
+	@def.View("SELECT null as id, 'Jack' AS name")
+	export class Author {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT id, name FROM author', { dependencies: [Author] })
+	export class Author2 {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT id, name FROM author2', { dependencies: [Author2] })
+	export class Author3 {
+		name = def.stringColumn()
+	}
+}
+
+describe('update a view 4 - replace whole chain in dependency order', () =>
+	testMigrations({
+		original: createSchema(ViewEntityOriginalSchema),
+		updated: createSchema(ViewEntityUpdatedSchema4),
+		diff: [
+			{
+				modification: 'updateView',
 				entityName: 'Author',
+				view: {
+					sql: "SELECT null as id, 'Jack' AS name",
+				},
 			},
 			{
-				modification: 'createView',
-				entity: {
-					name: 'Author',
-					primary: 'id',
-					primaryColumn: 'id',
-					unique: [],
-					fields: {
-						id: {
-							name: 'id',
-							columnName: 'id',
-							nullable: false,
-							type: 'Uuid',
-							columnType: 'uuid',
-						},
-						name: {
-							name: 'name',
-							columnName: 'name',
-							nullable: true,
-							type: 'String',
-							columnType: 'text',
-						},
-					},
-					tableName: 'author',
-					view: {
-						sql: "SELECT null as id, 'Jack' AS name",
-					},
-					eventLog: {
-						enabled: true,
-					},
-					indexes: [],
+				modification: 'updateView',
+				entityName: 'Author2',
+				view: {
+					sql: 'SELECT id, name FROM author',
+					dependencies: [
+						'Author',
+					],
 				},
 			},
 			{
-				modification: 'createView',
-				entity: {
-					name: 'Author2',
-					primary: 'id',
-					primaryColumn: 'id',
-					unique: [],
-					fields: {
-						id: {
-							name: 'id',
-							columnName: 'id',
-							nullable: false,
-							type: 'Uuid',
-							columnType: 'uuid',
-						},
-						name: {
-							name: 'name',
-							columnName: 'name',
-							nullable: true,
-							type: 'String',
-							columnType: 'text',
-						},
-					},
-					tableName: 'author2',
-					view: {
-						sql: 'SELECT * FROM author',
-						dependencies: [
-							'Author',
-						],
-					},
-					eventLog: {
-						enabled: true,
-					},
-					indexes: [],
+				modification: 'updateView',
+				entityName: 'Author3',
+				view: {
+					sql: 'SELECT id, name FROM author2',
+					dependencies: [
+						'Author2',
+					],
 				},
 			},
+		],
+		sql: SQL`CREATE OR REPLACE VIEW "author" AS SELECT null as id, 'Jack' AS name;
+CREATE OR REPLACE VIEW "author2" AS SELECT id, name FROM author;
+CREATE OR REPLACE VIEW "author3" AS SELECT id, name FROM author2;`,
+	}))
+
+namespace MaterializedViewOriginalSchema {
+	@def.View("SELECT null as id, 'John' AS name", { materialized: true })
+	export class MatAuthor {
+		name = def.stringColumn()
+	}
+}
+
+namespace MaterializedViewUpdatedSchema {
+	@def.View("SELECT null as id, 'Jack' AS name", { materialized: true })
+	export class MatAuthor {
+		name = def.stringColumn()
+	}
+}
+
+// materialized views cannot be replaced in-place (no CREATE OR REPLACE MATERIALIZED VIEW) -> drop & recreate
+describe('update a materialized view - still drops & recreates', () =>
+	testMigrations({
+		original: createSchema(MaterializedViewOriginalSchema),
+		updated: createSchema(MaterializedViewUpdatedSchema),
+		diff: [
+			{
+				modification: 'removeEntity',
+				entityName: 'MatAuthor',
+			},
 			{
 				modification: 'createView',
 				entity: {
-					name: 'Author3',
+					name: 'MatAuthor',
 					primary: 'id',
 					primaryColumn: 'id',
 					unique: [],
+					indexes: [],
 					fields: {
 						id: {
 							name: 'id',
@@ -146,65 +228,68 @@ describe('update a view 1', () =>
 							columnType: 'text',
 						},
 					},
-					tableName: 'author3',
-					view: {
-						sql: 'SELECT * FROM author2',
-						dependencies: [
-							'Author2',
-						],
-					},
+					tableName: 'mat_author',
 					eventLog: {
 						enabled: true,
 					},
-					indexes: [],
+					view: {
+						sql: "SELECT null as id, 'Jack' AS name",
+						materialized: true,
+					},
 				},
 			},
 		],
-		sql: SQL`DROP VIEW "author3";
-DROP VIEW "author2";
-DROP VIEW "author";
-CREATE VIEW "author" AS SELECT null as id, 'Jack' AS name;
-CREATE VIEW "author2" AS SELECT * FROM author;
-CREATE VIEW "author3" AS SELECT * FROM author2;`,
+		sql: SQL`DROP MATERIALIZED VIEW "mat_author";
+CREATE MATERIALIZED VIEW "mat_author" AS SELECT null as id, 'Jack' AS name WITH DATA;`,
 	}))
 
-namespace ViewEntityUpdatedSchema2 {
+namespace AddViewColumnOriginalSchema {
 	@def.View("SELECT null as id, 'John' AS name")
 	export class Author {
 		name = def.stringColumn()
 	}
 
-	@def.View('SELECT id, name FROM author', { dependencies: [Author] })
+	@def.View('SELECT * FROM author', { dependencies: [Author] })
 	export class Author2 {
 		name = def.stringColumn()
 	}
+}
 
-	@def.View('SELECT * FROM author2', { dependencies: [Author2] })
-	export class Author3 {
+namespace AddViewColumnUpdatedSchema {
+	@def.View("SELECT null as id, 'John' AS name, 0 AS age")
+	export class Author {
+		name = def.stringColumn()
+		age = def.intColumn()
+	}
+
+	@def.View('SELECT * FROM author', { dependencies: [Author] })
+	export class Author2 {
 		name = def.stringColumn()
 	}
 }
 
-describe('update a view 2', () =>
+// changing the output columns of a view requires a drop & recreate of it and its dependants
+describe('add a column to a view - still cascades drop & recreate', () =>
 	testMigrations({
-		original: createSchema(ViewEntityOriginalSchema),
-		updated: createSchema(ViewEntityUpdatedSchema2),
+		original: createSchema(AddViewColumnOriginalSchema),
+		updated: createSchema(AddViewColumnUpdatedSchema),
 		diff: [
 			{
 				modification: 'removeEntity',
-				entityName: 'Author3',
+				entityName: 'Author2',
 			},
 			{
 				modification: 'removeEntity',
-				entityName: 'Author2',
+				entityName: 'Author',
 			},
 			{
 				modification: 'createView',
 				entity: {
-					name: 'Author2',
+					name: 'Author',
 					primary: 'id',
 					primaryColumn: 'id',
 					unique: [],
+					indexes: [],
 					fields: {
 						id: {
 							name: 'id',
@@ -220,27 +305,31 @@ describe('update a view 2', () =>
 							type: 'String',
 							columnType: 'text',
 						},
+						age: {
+							name: 'age',
+							columnName: 'age',
+							nullable: true,
+							type: 'Integer',
+							columnType: 'integer',
+						},
 					},
-					tableName: 'author2',
-					view: {
-						sql: 'SELECT id, name FROM author',
-						dependencies: [
-							'Author',
-						],
-					},
+					tableName: 'author',
 					eventLog: {
 						enabled: true,
 					},
-					indexes: [],
+					view: {
+						sql: "SELECT null as id, 'John' AS name, 0 AS age",
+					},
 				},
 			},
 			{
 				modification: 'createView',
 				entity: {
-					name: 'Author3',
+					name: 'Author2',
 					primary: 'id',
 					primaryColumn: 'id',
 					unique: [],
+					indexes: [],
 					fields: {
 						id: {
 							name: 'id',
@@ -257,28 +346,26 @@ describe('update a view 2', () =>
 							columnType: 'text',
 						},
 					},
-					tableName: 'author3',
+					tableName: 'author2',
+					eventLog: {
+						enabled: true,
+					},
 					view: {
-						sql: 'SELECT * FROM author2',
+						sql: 'SELECT * FROM author',
 						dependencies: [
-							'Author2',
+							'Author',
 						],
 					},
-					eventLog: {
-						enabled: true,
-					},
-					indexes: [],
 				},
 			},
 		],
-		sql: SQL`DROP VIEW "author3";
-DROP VIEW "author2";
-CREATE VIEW "author2" AS SELECT id, name FROM author;
-CREATE VIEW "author3" AS SELECT * FROM author2;
-`,
+		sql: SQL`DROP VIEW "author2";
+DROP VIEW "author";
+CREATE VIEW "author" AS SELECT null as id, 'John' AS name, 0 AS age;
+CREATE VIEW "author2" AS SELECT * FROM author;`,
 	}))
 
-namespace ViewEntityUpdatedSchema3 {
+namespace RecreateViewsOriginalSchema {
 	@def.View("SELECT null as id, 'John' AS name")
 	export class Author {
 		name = def.stringColumn()
@@ -288,89 +375,28 @@ namespace ViewEntityUpdatedSchema3 {
 	export class Author2 {
 		name = def.stringColumn()
 	}
-
-	@def.View('SELECT id, name FROM author2', { dependencies: [Author2] })
-	export class Author3 {
-		name = def.stringColumn()
-	}
 }
 
-describe('update a view 3', () =>
-	testMigrations({
-		original: createSchema(ViewEntityOriginalSchema),
-		updated: createSchema(ViewEntityUpdatedSchema3),
-		diff: [
-			{
-				modification: 'removeEntity',
-				entityName: 'Author3',
-			},
-			{
-				modification: 'createView',
-				entity: {
-					name: 'Author3',
-					primary: 'id',
-					primaryColumn: 'id',
-					unique: [],
-					fields: {
-						id: {
-							name: 'id',
-							columnName: 'id',
-							nullable: false,
-							type: 'Uuid',
-							columnType: 'uuid',
-						},
-						name: {
-							name: 'name',
-							columnName: 'name',
-							nullable: true,
-							type: 'String',
-							columnType: 'text',
-						},
-					},
-					tableName: 'author3',
-					view: {
-						sql: 'SELECT id, name FROM author2',
-						dependencies: [
-							'Author2',
-						],
-					},
-					eventLog: {
-						enabled: true,
-					},
-					indexes: [],
-				},
-			},
-		],
-		sql: SQL`DROP VIEW "author3";
-CREATE VIEW "author3" AS SELECT id, name FROM author2;`,
-	}))
-
-namespace ViewEntityUpdatedSchema4 {
+namespace RecreateViewsUpdatedSchema {
 	@def.View("SELECT null as id, 'Jack' AS name")
 	export class Author {
 		name = def.stringColumn()
 	}
 
-	@def.View('SELECT id, name FROM author', { dependencies: [Author] })
+	@def.View('SELECT * FROM author', { dependencies: [Author] })
 	export class Author2 {
 		name = def.stringColumn()
 	}
-
-	@def.View('SELECT id, name FROM author2', { dependencies: [Author2] })
-	export class Author3 {
-		name = def.stringColumn()
-	}
 }
 
-describe('update a view 4', () =>
+// escape hatch: with `recreateViews`, even an SQL-only change (which is replaceable in-place)
+// drops & recreates the whole dependant cascade instead of emitting a single updateView
+describe('recreate views opt-out - SQL-only change drops & recreates instead of CREATE OR REPLACE', () =>
 	testMigrations({
-		original: createSchema(ViewEntityOriginalSchema),
-		updated: createSchema(ViewEntityUpdatedSchema4),
+		diffOptions: { recreateViews: true },
+		original: createSchema(RecreateViewsOriginalSchema),
+		updated: createSchema(RecreateViewsUpdatedSchema),
 		diff: [
-			{
-				modification: 'removeEntity',
-				entityName: 'Author3',
-			},
 			{
 				modification: 'removeEntity',
 				entityName: 'Author2',
@@ -386,6 +412,7 @@ describe('update a view 4', () =>
 					primary: 'id',
 					primaryColumn: 'id',
 					unique: [],
+					indexes: [],
 					fields: {
 						id: {
 							name: 'id',
@@ -403,13 +430,12 @@ describe('update a view 4', () =>
 						},
 					},
 					tableName: 'author',
-					view: {
-						sql: "SELECT null as id, 'Jack' AS name",
-					},
 					eventLog: {
 						enabled: true,
 					},
-					indexes: [],
+					view: {
+						sql: "SELECT null as id, 'Jack' AS name",
+					},
 				},
 			},
 			{
@@ -419,6 +445,7 @@ describe('update a view 4', () =>
 					primary: 'id',
 					primaryColumn: 'id',
 					unique: [],
+					indexes: [],
 					fields: {
 						id: {
 							name: 'id',
@@ -436,59 +463,20 @@ describe('update a view 4', () =>
 						},
 					},
 					tableName: 'author2',
-					view: {
-						sql: 'SELECT id, name FROM author',
-						dependencies: [
-							'Author',
-						],
-					},
 					eventLog: {
 						enabled: true,
 					},
-					indexes: [],
-				},
-			},
-			{
-				modification: 'createView',
-				entity: {
-					name: 'Author3',
-					primary: 'id',
-					primaryColumn: 'id',
-					unique: [],
-					fields: {
-						id: {
-							name: 'id',
-							columnName: 'id',
-							nullable: false,
-							type: 'Uuid',
-							columnType: 'uuid',
-						},
-						name: {
-							name: 'name',
-							columnName: 'name',
-							nullable: true,
-							type: 'String',
-							columnType: 'text',
-						},
-					},
-					tableName: 'author3',
 					view: {
-						sql: 'SELECT id, name FROM author2',
+						sql: 'SELECT * FROM author',
 						dependencies: [
-							'Author2',
+							'Author',
 						],
 					},
-					eventLog: {
-						enabled: true,
-					},
-					indexes: [],
 				},
 			},
 		],
-		sql: SQL`DROP VIEW "author3";
-DROP VIEW "author2";
+		sql: SQL`DROP VIEW "author2";
 DROP VIEW "author";
 CREATE VIEW "author" AS SELECT null as id, 'Jack' AS name;
-CREATE VIEW "author2" AS SELECT id, name FROM author;
-CREATE VIEW "author3" AS SELECT id, name FROM author2;`,
+CREATE VIEW "author2" AS SELECT * FROM author;`,
 	}))

package/tests/src/tests.ts

@@ -1,4 +1,4 @@
-import { Migration, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VERSION_LATEST } from '../../src'
+import { DiffOptions, Migration, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VERSION_LATEST } from '../../src/index.js'
 import { Schema } from '@contember/schema'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { describe, expect, it, test } from 'bun:test'
@@ -16,17 +16,19 @@ export interface TestContext {
 	sql: string
 	noDiff?: boolean
 	databaseMetadata?: DatabaseMetadata
+	diffOptions?: DiffOptions
 }
 
 export function testDiffSchemas(
 	original: Partial<Schema>,
 	updated: Partial<Schema>,
 	expectedDiff: Migration.Modification[],
+	diffOptions: DiffOptions = {},
 ) {
 	const actualDiff = schemaDiffer.diffSchemas(
 		{ ...emptySchema, ...original },
 		{ ...emptySchema, ...updated },
-		{ skipRecreateValidation: true },
+		{ skipRecreateValidation: true, ...diffOptions },
 	)
 	try {
 		expect(actualDiff).toStrictEqual(expectedDiff)
@@ -85,12 +87,12 @@ export function testGenerateSql(
 	expect(actual).toEqual(expectedSql)
 }
 
-export function testMigrations({ original, updated, diff, noDiff, sql, databaseMetadata }: TestContext) {
+export function testMigrations({ original, updated, diff, noDiff, sql, databaseMetadata, diffOptions }: TestContext) {
 	test('diff schemas', () => {
 		if (noDiff) {
 			return
 		}
-		testDiffSchemas(original, updated, diff)
+		testDiffSchemas(original, updated, diff, diffOptions)
 	})
 	test('apply diff', () => {
 		testApplyDiff(original, updated, diff)