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

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

@@ -4,7 +4,6 @@ import { createSchema, SchemaBuilder, SchemaDefinition as def } from '@contember
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-
 namespace SchemaWithoutOrderBy {
 	export class Article {
 		title = def.stringColumn()
@@ -18,27 +17,29 @@ namespace SchemaWithOrderBy {
 	}
 }
 
-describe('update entity add order by', () => testMigrations({
-	original: createSchema(SchemaWithoutOrderBy),
-	updated: createSchema(SchemaWithOrderBy),
-	diff: [
-		{
-			modification: 'updateEntityOrderBy',
-			entityName: 'Article',
-			orderBy: [{ path: ['title'], direction: 'asc' }],
-		},
-	],
-	sql: SQL``,
-}))
+describe('update entity add order by', () =>
+	testMigrations({
+		original: createSchema(SchemaWithoutOrderBy),
+		updated: createSchema(SchemaWithOrderBy),
+		diff: [
+			{
+				modification: 'updateEntityOrderBy',
+				entityName: 'Article',
+				orderBy: [{ path: ['title'], direction: 'asc' }],
+			},
+		],
+		sql: SQL``,
+	}))
 
-describe('update entity remove order by', () => testMigrations({
-	original: createSchema(SchemaWithOrderBy),
-	updated: createSchema(SchemaWithoutOrderBy),
-	diff: [
-		{
-			modification: 'updateEntityOrderBy',
-			entityName: 'Article',
-		},
-	],
-	sql: SQL``,
-}))
+describe('update entity remove order by', () =>
+	testMigrations({
+		original: createSchema(SchemaWithOrderBy),
+		updated: createSchema(SchemaWithoutOrderBy),
+		diff: [
+			{
+				modification: 'updateEntityOrderBy',
+				entityName: 'Article',
+			},
+		],
+		sql: SQL``,
+	}))

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

@@ -1,37 +1,75 @@
 import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { c, createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-describe('update enum', () => testMigrations({
-	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',
-			enumName: 'postStatus',
-			values: ['publish', 'draft'],
+describe('update enum', () =>
+	testMigrations({
+		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(),
 		},
-	],
-	sql: SQL`ALTER DOMAIN "postStatus" DROP CONSTRAINT poststatus_check;
+		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',
+				enumName: 'postStatus',
+				values: ['publish', 'draft'],
+			},
+		],
+		sql: SQL`ALTER DOMAIN "postStatus" DROP CONSTRAINT poststatus_check;
 	ALTER DOMAIN "postStatus" ADD CONSTRAINT poststatus_check CHECK (VALUE IN('publish','draft'));`,
-}))
+	}))
+
+namespace EnumModelOriginal {
+	export const FooStatus = c.createEnum('foo', 'bar')
+	export class Foo {
+		status = c.enumColumn(FooStatus).notNull()
+		statusList = c.enumColumn(FooStatus).notNull().list()
+	}
+}
+
+namespace EnumModelUpdated {
+	export const FooStatus = c.createEnum('foo', 'bar', 'baz')
+
+	export class Foo {
+		status = c.enumColumn(FooStatus).notNull()
+		statusList = c.enumColumn(FooStatus).notNull().list()
+	}
+}
+
+describe('update enum if used in list', () =>
+	testMigrations({
+		original: {
+			model: createSchema(EnumModelOriginal).model,
+		},
+		updated: {
+			model: createSchema(EnumModelUpdated).model,
+		},
+		diff: [
+			{
+				modification: 'updateEnum',
+				enumName: 'FooStatus',
+				values: ['foo', 'bar', 'baz'],
+			},
+		],
+		sql: SQL`ALTER DOMAIN "FooStatus" RENAME TO "FooStatus__old"; 
+CREATE DOMAIN "FooStatus" AS text CONSTRAINT "foostatus_check" CHECK (VALUE IN('foo','bar','baz')); 
+ALTER TABLE "foo" ALTER "status" SET DATA TYPE "FooStatus"; 
+ALTER TABLE "foo" ALTER "status_list" SET DATA TYPE "FooStatus"[]; 
+DROP DOMAIN "FooStatus__old";`,
+	}))

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,
+	}))