@contember/schema-migrations 2.1.0-alpha.30 → 2.1.0-alpha.35

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

@@ -4,172 +4,171 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-describe('rename a field', () => testMigrations({
-	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',
-			entityName: 'Author',
-			fieldName: 'firstName',
-			newFieldName: 'name',
+describe('rename a field', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String).columnName('name')))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
-
-describe('rename a field with column', () => testMigrations({
-	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',
-			entityName: 'Author',
-			fieldName: 'firstName',
-			newFieldName: 'name',
-			columnName: 'name',
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL`ALTER TABLE "author" RENAME "first_name" TO "name";`,
-	noDiff: true,
-}))
-
-
+		diff: [
+			{
+				modification: 'updateFieldName',
+				entityName: 'Author',
+				fieldName: 'firstName',
+				newFieldName: 'name',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))
 
-describe('rename a field with one-has-one', () => testMigrations({
-	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',
-			entityName: 'Author',
-			fieldName: 'content',
-			newFieldName: 'description',
+describe('rename a field with column', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Author', e => e.column('firstName', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
-
-describe('rename a relation', () => testMigrations({
-	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',
-			entityName: 'Post',
-			fieldName: 'user',
-			newFieldName: 'author',
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
+		diff: [
+			{
+				modification: 'updateFieldName',
+				entityName: 'Author',
+				fieldName: 'firstName',
+				newFieldName: 'name',
+				columnName: 'name',
+			},
+		],
+		sql: SQL`ALTER TABLE "author" RENAME "first_name" TO "name";`,
+		noDiff: true,
+	}))
 
+describe('rename a field with one-has-one', () =>
+	testMigrations({
+		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',
+				entityName: 'Author',
+				fieldName: 'content',
+				newFieldName: 'description',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))
 
-describe('rename a relation with joining column', () => testMigrations({
-	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',
-			entityName: 'Post',
-			fieldName: 'user',
-			newFieldName: 'author',
-			columnName: 'author_id',
+describe('rename a relation', () =>
+	testMigrations({
+		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(),
 		},
-	],
-	sql: SQL`ALTER TABLE "post" RENAME "user_id" TO "author_id";`,
-	noDiff: true,
-}))
+		diff: [
+			{
+				modification: 'updateFieldName',
+				entityName: 'Post',
+				fieldName: 'user',
+				newFieldName: 'author',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))
 
+describe('rename a relation with joining column', () =>
+	testMigrations({
+		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',
+				entityName: 'Post',
+				fieldName: 'user',
+				newFieldName: 'author',
+				columnName: 'author_id',
+			},
+		],
+		sql: SQL`ALTER TABLE "post" RENAME "user_id" TO "author_id";`,
+		noDiff: true,
+	}))
 
-describe('rename relation with acl', () => testMigrations({
-	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',
-						},
-					},
-					stages: '*',
-					entities: {
-						Post: {
-							predicates: {
-								author: { user: { id: 'authorId' } },
-							},
-							operations: {
-								read: {
-									title: 'author',
-								},
+describe('rename relation with acl', () =>
+	testMigrations({
+		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',
+									},
 								},
 							},
 						},
@@ -177,43 +176,41 @@ describe('rename relation with acl', () => testMigrations({
 				},
 			},
 		},
-	},
-	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',
-						},
-					},
-					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',
+									},
 								},
 							},
 						},
@@ -221,15 +218,14 @@ describe('rename relation with acl', () => testMigrations({
 				},
 			},
 		},
-	},
-	diff: [
-		{
-			modification: 'updateFieldName',
-			entityName: 'Post',
-			fieldName: 'user',
-			newFieldName: 'author',
-		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
+		diff: [
+			{
+				modification: 'updateFieldName',
+				entityName: 'Post',
+				fieldName: 'user',
+				newFieldName: 'author',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))

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

@@ -3,52 +3,50 @@ import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
-import { ForeignKeyDeleteAction, createDatabaseMetadata } from '@contember/database'
-import { } from 'bun:test'
+import { createDatabaseMetadata, ForeignKeyDeleteAction } from '@contember/database'
+import {} from 'bun:test'
 
-describe('update relation ondelete to cascade', () => testMigrations({
-	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',
-			entityName: 'Post',
-			fieldName: 'category',
-			onDelete: Model.OnDelete.cascade,
+describe('update relation ondelete to cascade', () =>
+	testMigrations({
+		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(),
 		},
-	],
-	sql: SQL`ALTER TABLE "post" DROP CONSTRAINT "fk_post_category_id_category_id"; 
-ALTER TABLE "post" ADD FOREIGN KEY ("category_id") REFERENCES "category"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [
+		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: [
 			{
-				constraintName: 'fk_post_category_id_category_id',
-				deleteAction: ForeignKeyDeleteAction.cascade,
-				fromColumn: 'category_id',
-				fromTable: 'post',
-				toColumn: 'id',
-				toTable: 'category',
-				deferred: false,
-				deferrable: false,
+				modification: 'updateRelationOnDelete',
+				entityName: 'Post',
+				fieldName: 'category',
+				onDelete: Model.OnDelete.cascade,
 			},
 		],
-		indexes: [],
-		uniqueConstraints: [],
-	}),
-}))
+		sql: SQL`ALTER TABLE "post" DROP CONSTRAINT "fk_post_category_id_category_id"; 
+ALTER TABLE "post" ADD FOREIGN KEY ("category_id") REFERENCES "category"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [
+				{
+					constraintName: 'fk_post_category_id_category_id',
+					deleteAction: ForeignKeyDeleteAction.cascade,
+					fromColumn: 'category_id',
+					fromTable: 'post',
+					toColumn: 'id',
+					toTable: 'category',
+					deferred: false,
+					deferrable: false,
+				},
+			],
+			indexes: [],
+			uniqueConstraints: [],
+		}),
+	}))

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

@@ -4,42 +4,39 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-describe('update relation order by', () => testMigrations({
-	original: {
-		model: new SchemaBuilder()
-			.entity('Menu', e =>
-				e.oneHasMany('items', r =>
-					r
-						.ownedBy('menu')
-						.target('MenuItem', e => e.column('heading').column('order', c => c.type(Model.ColumnType.Int))),
-				),
-			)
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Menu', e =>
-				e.oneHasMany('items', r =>
-					r
-						.ownedBy('menu')
-						.orderBy('order')
-						.target('MenuItem', e => e.column('heading').column('order', c => c.type(Model.ColumnType.Int))),
-				),
-			)
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'updateRelationOrderBy',
-			entityName: 'Menu',
-			fieldName: 'items',
-			orderBy: [
-				{
-					path: ['order'],
-					direction: 'asc',
-				},
-			],
+describe('update relation order by', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Menu', e =>
+					e.oneHasMany('items', r =>
+						r
+							.ownedBy('menu')
+							.target('MenuItem', e => e.column('heading').column('order', c => c.type(Model.ColumnType.Int)))))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-}))
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Menu', e =>
+					e.oneHasMany('items', r =>
+						r
+							.ownedBy('menu')
+							.orderBy('order')
+							.target('MenuItem', e => e.column('heading').column('order', c => c.type(Model.ColumnType.Int)))))
+				.buildSchema(),
+		},
+		diff: [
+			{
+				modification: 'updateRelationOrderBy',
+				entityName: 'Menu',
+				fieldName: 'items',
+				orderBy: [
+					{
+						path: ['order'],
+						direction: 'asc',
+					},
+				],
+			},
+		],
+		sql: SQL``,
+	}))