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

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

@@ -1,4 +1,4 @@
-import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 
@@ -24,8 +24,8 @@ namespace EventLogDisabled {
 }
 
 testMigrations('event log junction - disable', {
-	originalSchema: def.createModel(EventLogNoConfig),
-	updatedSchema: def.createModel(EventLogDisabled),
+	original: createSchema(EventLogNoConfig),
+	updated: createSchema(EventLogDisabled),
 	diff: [
 		{
 			modification: 'toggleJunctionEventLog',
@@ -39,8 +39,8 @@ testMigrations('event log junction - disable', {
 })
 
 testMigrations('event log junction - enable', {
-	originalSchema: def.createModel(EventLogDisabled),
-	updatedSchema: def.createModel(EventLogNoConfig),
+	original: createSchema(EventLogDisabled),
+	updated: createSchema(EventLogNoConfig),
 	diff: [
 		{
 			modification: 'toggleJunctionEventLog',

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

@@ -5,18 +5,22 @@ import { SQL } from '../../src/tags'
 import { updateColumnDefinitionModification } from '../../../src'
 
 testMigrations('update column definition', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e =>
-			e.column('name', c => c.type(Model.ColumnType.String)).column('registeredAt', c => c.type(Model.ColumnType.Date)),
-		)
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e =>
-			e
-				.column('name', c => c.type(Model.ColumnType.String))
-				.column('registeredAt', c => c.type(Model.ColumnType.DateTime)),
-		)
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e =>
+				e.column('name', c => c.type(Model.ColumnType.String)).column('registeredAt', c => c.type(Model.ColumnType.Date)),
+			)
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e =>
+				e
+					.column('name', c => c.type(Model.ColumnType.String))
+					.column('registeredAt', c => c.type(Model.ColumnType.DateTime)),
+			)
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateColumnDefinition',
@@ -44,8 +48,8 @@ namespace SeqUpdated {
 	}
 }
 testMigrations('add sequence to existing column', {
-	originalSchema: createSchema(SeqOrig).model,
-	updatedSchema: createSchema(SeqUpdated).model,
+	original: createSchema(SeqOrig),
+	updated: createSchema(SeqUpdated),
 	diff: [
 		updateColumnDefinitionModification.createModification({
 			entityName: 'Author',
@@ -108,8 +112,8 @@ namespace ViewColDepUpdated {
 }
 
 testMigrations('recreate view dependent on entity after changing column type', {
-	originalSchema: createSchema(ViewColDepOrig).model,
-	updatedSchema: createSchema(ViewColDepUpdated).model,
+	original: createSchema(ViewColDepOrig),
+	updated: createSchema(ViewColDepUpdated),
 	diff: [{ modification: 'removeEntity', entityName: 'AuthorMetaY' }, {
 		modification: 'removeEntity',
 		entityName: 'AuthorMetaX',
@@ -181,8 +185,8 @@ namespace NotNullUpdated {
 	}
 }
 testMigrations('set not null and fill', {
-	originalSchema: createSchema(NotNullOrig).model,
-	updatedSchema: createSchema(NotNullUpdated).model,
+	original: createSchema(NotNullOrig),
+	updated: createSchema(NotNullUpdated),
 	noDiff: true,
 	diff: [
 		updateColumnDefinitionModification.createModification({

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

@@ -1,17 +1,21 @@
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { SchemaBuilder, c, createSchema } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('rename entity without renaming a table', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.tableName('user').column('name', c => c.type(Model.ColumnType.String)))
-		.entity('Post', e => e.column('title').manyHasOne('author', r => r.target('Author')))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('User', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.entity('Post', e => e.column('title').manyHasOne('author', r => r.target('User')))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.tableName('user').column('name', c => c.type(Model.ColumnType.String)))
+			.entity('Post', e => e.column('title').manyHasOne('author', r => r.target('Author')))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('User', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.entity('Post', e => e.column('title').manyHasOne('author', r => r.target('User')))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateEntityName',
@@ -24,12 +28,16 @@ testMigrations('rename entity without renaming a table', {
 })
 
 testMigrations('rename entity and table', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('User', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('User', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateEntityName',
@@ -45,14 +53,18 @@ testMigrations('rename entity and table', {
 
 
 testMigrations('rename entity with one-has-one (constraint)', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.oneHasOne('content', r => r.target('Content')))
-		.entity('Content', e => e.column('foo'))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('User', e => e.tableName('author').oneHasOne('content', r => r.target('Content')))
-		.entity('Content', e => e.column('foo'))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.oneHasOne('content', r => r.target('Content')))
+			.entity('Content', e => e.column('foo'))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('User', e => e.tableName('author').oneHasOne('content', r => r.target('Content')))
+			.entity('Content', e => e.column('foo'))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateEntityName',
@@ -65,20 +77,22 @@ testMigrations('rename entity with one-has-one (constraint)', {
 })
 
 testMigrations('rename table with acl', {
-	originalSchema: new SchemaBuilder()
-		.entity('Site', entity => entity.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	originalAcl: {
-		roles: {
-			admin: {
-				variables: {},
-				stages: '*',
-				entities: {
-					Site: {
-						predicates: {},
-						operations: {
-							read: {
-								id: true,
+	original: {
+		model: new SchemaBuilder()
+			.entity('Site', entity => entity.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+		acl: {
+			roles: {
+				admin: {
+					variables: {},
+					stages: '*',
+					entities: {
+						Site: {
+							predicates: {},
+							operations: {
+								read: {
+									id: true,
+								},
 							},
 						},
 					},
@@ -86,20 +100,22 @@ testMigrations('rename table with acl', {
 			},
 		},
 	},
-	updatedSchema: new SchemaBuilder()
-		.entity('Website', entity => entity.column('name', c => c.type(Model.ColumnType.String)).tableName('site'))
-		.buildSchema(),
-	updatedAcl: {
-		roles: {
-			admin: {
-				variables: {},
-				stages: '*',
-				entities: {
-					Website: {
-						predicates: {},
-						operations: {
-							read: {
-								id: true,
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Website', entity => entity.column('name', c => c.type(Model.ColumnType.String)).tableName('site'))
+			.buildSchema(),
+		acl: {
+			roles: {
+				admin: {
+					variables: {},
+					stages: '*',
+					entities: {
+						Website: {
+							predicates: {},
+							operations: {
+								read: {
+									id: true,
+								},
 							},
 						},
 					},

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

@@ -1,5 +1,5 @@
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder, SchemaDefinition as def } from '@contember/schema-definition'
+import { createSchema, SchemaBuilder, SchemaDefinition as def } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
@@ -18,8 +18,8 @@ namespace SchemaWithOrderBy {
 }
 
 testMigrations('update entity add order by', {
-	originalSchema: def.createModel(SchemaWithoutOrderBy),
-	updatedSchema: def.createModel(SchemaWithOrderBy),
+	original: createSchema(SchemaWithoutOrderBy),
+	updated: createSchema(SchemaWithOrderBy),
 	diff: [
 		{
 			modification: 'updateEntityOrderBy',
@@ -31,8 +31,8 @@ testMigrations('update entity add order by', {
 })
 
 testMigrations('update entity remove order by', {
-	originalSchema: def.createModel(SchemaWithOrderBy),
-	updatedSchema: def.createModel(SchemaWithoutOrderBy),
+	original: createSchema(SchemaWithOrderBy),
+	updated: createSchema(SchemaWithoutOrderBy),
 	diff: [
 		{
 			modification: 'updateEntityOrderBy',

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

@@ -4,22 +4,26 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('update enum', {
-	originalSchema: 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', 'autodraft'])
-		.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))
+					.column('status', c => c.type(Model.ColumnType.Enum, { enumName: 'postStatus' })),
+			)
+			.enum('postStatus', ['publish', 'draft', 'autodraft'])
+			.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: 'updateEnum',

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

@@ -4,12 +4,16 @@ import { Acl, Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('rename a field', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String).columnName('name')))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String).columnName('name')))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateFieldName',
@@ -23,12 +27,16 @@ testMigrations('rename a field', {
 })
 
 testMigrations('rename a field with column', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateFieldName',
@@ -45,14 +53,18 @@ testMigrations('rename a field with column', {
 
 
 testMigrations('rename a field with one-has-one', {
-	originalSchema: new SchemaBuilder()
-		.entity('Author', e => e.oneHasOne('content', r => r.target('Content')))
-		.entity('Content', e => e.column('foo'))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Author', e => e.oneHasOne('description', r => r.target('Content').joiningColumn('content_id')))
-		.entity('Content', e => e.column('foo'))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.oneHasOne('content', r => r.target('Content')))
+			.entity('Content', e => e.column('foo'))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Author', e => e.oneHasOne('description', r => r.target('Content').joiningColumn('content_id')))
+			.entity('Content', e => e.column('foo'))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateFieldName',
@@ -66,16 +78,20 @@ testMigrations('rename a field with one-has-one', {
 })
 
 testMigrations('rename a relation', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts').joiningColumn('user_id')),
-		)
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts').joiningColumn('user_id')),
+			)
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateFieldName',
@@ -90,16 +106,20 @@ testMigrations('rename a relation', {
 
 
 testMigrations('rename a relation with joining column', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts')),
-		)
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts')),
+			)
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateFieldName',
@@ -115,39 +135,41 @@ testMigrations('rename a relation with joining column', {
 
 
 testMigrations('rename relation with acl', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
-		.entity('Comment', e => e.column('content').manyHasOne('post', r => r.target('Post')))
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
-	originalAcl: {
-		roles: {
-			admin: {
-				variables: {
-					authorId: {
-						type: Acl.VariableType.entity,
-						entityName: 'Author',
-					},
-				},
-				stages: '*',
-				entities: {
-					Post: {
-						predicates: {
-							author: { user: { id: 'authorId' } },
-						},
-						operations: {
-							read: {
-								title: 'author',
-							},
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', e => e.column('title').manyHasOne('user', r => r.target('Author').inversedBy('posts')))
+			.entity('Comment', e => e.column('content').manyHasOne('post', r => r.target('Post')))
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+		acl: {
+			roles: {
+				admin: {
+					variables: {
+						authorId: {
+							type: Acl.VariableType.entity,
+							entityName: 'Author',
 						},
 					},
-					Comment: {
-						predicates: {
-							postAuthor: { post: { user: { id: 'authorId' } } },
+					stages: '*',
+					entities: {
+						Post: {
+							predicates: {
+								author: { user: { id: 'authorId' } },
+							},
+							operations: {
+								read: {
+									title: 'author',
+								},
+							},
 						},
-						operations: {
-							read: {
-								content: 'postAuthor',
+						Comment: {
+							predicates: {
+								postAuthor: { post: { user: { id: 'authorId' } } },
+							},
+							operations: {
+								read: {
+									content: 'postAuthor',
+								},
 							},
 						},
 					},
@@ -155,41 +177,43 @@ testMigrations('rename relation with acl', {
 			},
 		},
 	},
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', e =>
-			e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts').joiningColumn('user_id')),
-		)
-		.entity('Comment', e => e.column('content').manyHasOne('post', r => r.target('Post')))
-		.entity('Author', e => e.column('name'))
-		.buildSchema(),
-	updatedAcl: {
-		roles: {
-			admin: {
-				variables: {
-					authorId: {
-						type: Acl.VariableType.entity,
-						entityName: 'Author',
-					},
-				},
-				stages: '*',
-				entities: {
-					Post: {
-						predicates: {
-							author: { author: { id: 'authorId' } },
-						},
-						operations: {
-							read: {
-								title: 'author',
-							},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', e =>
+				e.column('title').manyHasOne('author', r => r.target('Author').inversedBy('posts').joiningColumn('user_id')),
+			)
+			.entity('Comment', e => e.column('content').manyHasOne('post', r => r.target('Post')))
+			.entity('Author', e => e.column('name'))
+			.buildSchema(),
+		acl: {
+			roles: {
+				admin: {
+					variables: {
+						authorId: {
+							type: Acl.VariableType.entity,
+							entityName: 'Author',
 						},
 					},
-					Comment: {
-						predicates: {
-							postAuthor: { post: { author: { id: 'authorId' } } },
+					stages: '*',
+					entities: {
+						Post: {
+							predicates: {
+								author: { author: { id: 'authorId' } },
+							},
+							operations: {
+								read: {
+									title: 'author',
+								},
+							},
 						},
-						operations: {
-							read: {
-								content: 'postAuthor',
+						Comment: {
+							predicates: {
+								postAuthor: { post: { author: { id: 'authorId' } } },
+							},
+							operations: {
+								read: {
+									content: 'postAuthor',
+								},
 							},
 						},
 					},

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

@@ -4,20 +4,24 @@ import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
 testMigrations('update relation ondelete to cascade', {
-	originalSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity.column('name', c => c.type(Model.ColumnType.String)).manyHasOne('category', r => r.target('Category')),
-		)
-		.entity('Category', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
-	updatedSchema: new SchemaBuilder()
-		.entity('Post', entity =>
-			entity
-				.column('name', c => c.type(Model.ColumnType.String))
-				.manyHasOne('category', r => r.target('Category').onDelete(Model.OnDelete.cascade)),
-		)
-		.entity('Category', e => e.column('name', c => c.type(Model.ColumnType.String)))
-		.buildSchema(),
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.column('name', c => c.type(Model.ColumnType.String)).manyHasOne('category', r => r.target('Category')),
+			)
+			.entity('Category', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
+	updated: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity
+					.column('name', c => c.type(Model.ColumnType.String))
+					.manyHasOne('category', r => r.target('Category').onDelete(Model.OnDelete.cascade)),
+			)
+			.entity('Category', e => e.column('name', c => c.type(Model.ColumnType.String)))
+			.buildSchema(),
+	},
 	diff: [
 		{
 			modification: 'updateRelationOnDelete',