@contember/schema-migrations 1.0.0-alpha.0 → 1.0.0-alpha.4

package/src/modifications/entities/RemoveEntityModification.ts

@@ -1,5 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Schema } from '@contember/schema'
+import { Acl, Schema } from '@contember/schema'
 import {
 	removeField,
 	SchemaUpdater,
@@ -46,7 +46,9 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 						({ role }) => ({
 							...role,
 							variables: Object.fromEntries(
-								Object.entries(role.variables).filter(([, variable]) => variable.entityName !== this.data.entityName),
+								Object.entries(role.variables).filter(([, variable]) =>
+									variable.type !== Acl.VariableType.entity || variable.entityName !== this.data.entityName,
+								),
 							),
 						}),
 						updateAclEntities(({ entities }) => {

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -1,5 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
+import { Acl, Model, Schema } from '@contember/schema'
 import {
 	SchemaUpdater,
 	updateAcl,
@@ -82,13 +82,18 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 						({ role }) => ({
 							...role,
 							variables: Object.fromEntries(
-								Object.entries(role.variables).map(([key, variable]) => [
-									key,
-									{
-										...variable,
-										entityName: changeValue(this.data.entityName, this.data.newEntityName)(variable.entityName),
-									},
-								]),
+								Object.entries(role.variables).map(([key, variable]) => {
+									if (variable.type === Acl.VariableType.entity) {
+										return [
+											key,
+											{
+												...variable,
+												entityName: changeValue(this.data.entityName, this.data.newEntityName)(variable.entityName),
+											},
+										]
+									}
+									return [key, variable]
+								}),
 							),
 						}),
 						updateAclEntities(({ entities }) => {

package/src/modifications/entities/UpdateViewModification.ts

@@ -10,10 +10,11 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
-		builder.dropView(entity.tableName, { ifExists: true })
 		builder.createView(
 			entity.tableName,
-			{},
+			{
+				replace: true,
+			},
 			this.data.view.sql,
 		)
 	}
@@ -34,20 +35,6 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 	static createModification(data: UpdateViewModificationData) {
 		return { modification: this.id, ...data }
 	}
-
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		return Object.values(updatedSchema.model.entities)
-			.filter((it): it is Model.Entity & Required<Pick<Model.Entity, 'view'>> => {
-				const origView = originalSchema.model.entities[it.name]?.view
-				return !!it.view?.sql && !!origView && origView?.sql !== it.view.sql
-			})
-			.map(it =>
-				UpdateViewModification.createModification({
-					entityName: it.name,
-					view: it.view,
-				}),
-			)
-	}
 }
 
 export interface UpdateViewModificationData {

package/src/modifications/entities/index.ts

@@ -1,5 +1,5 @@
 export * from './CreateEntityModification'
+export * from './CreateViewModification'
 export * from './RemoveEntityModification'
 export * from './UpdateEntityNameModification'
 export * from './UpdateEntityTableNameModification'
-export * from './UpdateViewModification'

package/src/modifications/utils/viewDependencies.ts

@@ -0,0 +1,20 @@
+import { Model } from '@contember/schema'
+
+type ViewDependants = Map<string, Set<Model.Entity>>
+export const getViewDirectDependants = (model: Model.Schema): ViewDependants => {
+	const dependants: ViewDependants = new Map(Object.values(model.entities).filter(it => it.view).map(it => [it.name, new Set()]))
+	for (const entity of Object.values(model.entities)) {
+		if (!entity.view?.dependencies?.length) {
+			continue
+		}
+		for (const dependency of entity.view.dependencies) {
+			const entityDependants = dependants.get(dependency)
+			if (!entityDependants) {
+				// not a view
+				continue
+			}
+			entityDependants.add(entity)
+		}
+	}
+	return dependants
+}

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

@@ -111,7 +111,7 @@ testMigrations('create a view', {
 	updatedSchema: def.createModel(ViewEntityUpdatedSchema),
 	diff: [
 		{
-			modification: 'createEntity',
+			modification: 'createView',
 			entity: {
 				fields: {
 					id: {
@@ -121,6 +121,13 @@ testMigrations('create a view', {
 						type: Model.ColumnType.Uuid,
 						columnType: 'uuid',
 					},
+					name: {
+						columnName: 'name',
+						name: 'name',
+						nullable: true,
+						type: Model.ColumnType.String,
+						columnType: 'text',
+					},
 				},
 				name: 'Author',
 				primary: 'id',
@@ -130,17 +137,6 @@ testMigrations('create a view', {
 				view: { sql: "SELECT null as id, 'John' AS name" },
 			},
 		},
-		{
-			modification: 'createColumn',
-			entityName: 'Author',
-			field: {
-				columnName: 'name',
-				name: 'name',
-				nullable: true,
-				type: Model.ColumnType.String,
-				columnType: 'text',
-			},
-		},
 	],
 	sql: SQL`CREATE VIEW "author" AS SELECT null as id, 'John' AS name;`,
 })

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

@@ -1,44 +1,457 @@
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 import { SchemaDefinition as def } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
 
 namespace ViewEntityOriginalSchema {
 	@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 * FROM author2', { dependencies: [Author2] })
+	export class Author3 {
+		name = def.stringColumn()
+	}
 }
 
-namespace ViewEntityUpdatedSchema {
-	@def.View("SELECT null as id, 'John' AS name, 'root@localhost' as email")
+namespace ViewEntityUpdatedSchema1 {
+	@def.View("SELECT null as id, 'Jack' AS name")
 	export class Author {
 		name = def.stringColumn()
-		email = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author', { dependencies: [Author] })
+	export class Author2 {
+		name = def.stringColumn()
+	}
+
+	@def.View('SELECT * FROM author2', { dependencies: [Author2] })
+	export class Author3 {
+		name = def.stringColumn()
 	}
 }
-testMigrations('update a view', {
+
+
+testMigrations('update a view 1', {
 	originalSchema: def.createModel(ViewEntityOriginalSchema),
-	updatedSchema: def.createModel(ViewEntityUpdatedSchema),
+	updatedSchema: def.createModel(ViewEntityUpdatedSchema1),
 	diff: [
 		{
-			modification: 'updateView',
+			modification: 'removeEntity',
+			entityName: 'Author3',
+		},
+		{
+			modification: 'removeEntity',
+			entityName: 'Author2',
+		},
+		{
+			modification: 'removeEntity',
 			entityName: 'Author',
-			view: {
-				sql: "SELECT null as id, 'John' AS name, 'root@localhost' as email",
+		},
+		{
+			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",
+				},
+			},
+		},
+		{
+			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',
+					],
+				},
+			},
+		},
+		{
+			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 * FROM author2',
+					dependencies: [
+						'Author2',
+					],
+				},
+			},
+		},
+	],
+	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;`,
+})
+
+
+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()
+	}
+}
+
+testMigrations('update a view 2', {
+	originalSchema: def.createModel(ViewEntityOriginalSchema),
+	updatedSchema: def.createModel(ViewEntityUpdatedSchema2),
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Author3',
+		},
+		{
+			modification: 'removeEntity',
+			entityName: 'Author2',
+		},
+		{
+			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 id, name FROM author',
+					dependencies: [
+						'Author',
+					],
+				},
+			},
+		},
+		{
+			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 * FROM author2',
+					dependencies: [
+						'Author2',
+					],
+				},
 			},
 		},
+	],
+	sql: SQL`DROP VIEW "author3";
+DROP VIEW "author2";
+CREATE VIEW "author2" AS SELECT id, name FROM author;
+CREATE VIEW "author3" AS SELECT * FROM author2;
+`,
+})
+
+
+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()
+	}
+}
+
+testMigrations('update a view 3', {
+	originalSchema: def.createModel(ViewEntityOriginalSchema),
+	updatedSchema: def.createModel(ViewEntityUpdatedSchema3),
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Author3',
+		},
 		{
-			modification: 'createColumn',
+			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',
+					],
+				},
+			},
+		},
+	],
+	sql: SQL`DROP VIEW "author3";
+CREATE 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()
+	}
+}
+
+testMigrations('update a view 4', {
+	originalSchema: def.createModel(ViewEntityOriginalSchema),
+	updatedSchema: def.createModel(ViewEntityUpdatedSchema4),
+	diff: [
+		{
+			modification: 'removeEntity',
+			entityName: 'Author3',
+		},
+		{
+			modification: 'removeEntity',
+			entityName: 'Author2',
+		},
+		{
+			modification: 'removeEntity',
 			entityName: 'Author',
-			field: {
-				columnName: 'email',
-				name: 'email',
-				nullable: true,
-				type: Model.ColumnType.String,
-				columnType: 'text',
+		},
+		{
+			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",
+				},
+			},
+		},
+		{
+			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 id, name FROM author',
+					dependencies: [
+						'Author',
+					],
+				},
+			},
+		},
+		{
+			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',
+					],
+				},
 			},
 		},
 	],
-	sql: SQL`DROP VIEW IF EXISTS "author"; CREATE VIEW "author" AS SELECT null as id, 'John' AS name, 'root@localhost' as email;`,
+	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 id, name FROM author;
+CREATE VIEW "author3" AS SELECT id, name FROM author2;`,
 })