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

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

@@ -1,98 +1,102 @@
 import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
-import { SchemaBuilder, c, createSchema } from '@contember/schema-definition'
+import { c, createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-describe('rename entity without renaming a table', () => testMigrations({
-	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',
-			entityName: 'Author',
-			newEntityName: 'User',
+describe('rename entity without renaming a table', () =>
+	testMigrations({
+		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(),
 		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
+		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',
+				entityName: 'Author',
+				newEntityName: 'User',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))
 
-describe('rename entity and table', () => testMigrations({
-	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',
-			entityName: 'Author',
-			newEntityName: 'User',
-			tableName: 'user',
+describe('rename entity and table', () =>
+	testMigrations({
+		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(),
 		},
-	],
-	sql: SQL`ALTER TABLE "author"
+		diff: [
+			{
+				modification: 'updateEntityName',
+				entityName: 'Author',
+				newEntityName: 'User',
+				tableName: 'user',
+			},
+		],
+		sql: SQL`ALTER TABLE "author"
 		RENAME TO "user";`,
-	noDiff: true,
-}))
-
+		noDiff: true,
+	}))
 
-describe('rename entity with one-has-one (constraint)', () => 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('User', e => e.tableName('author').oneHasOne('content', r => r.target('Content')))
-			.entity('Content', e => e.column('foo'))
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'updateEntityName',
-			entityName: 'Author',
-			newEntityName: 'User',
+describe('rename entity with one-has-one (constraint)', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Author', e => e.oneHasOne('content', r => r.target('Content')))
+				.entity('Content', e => e.column('foo'))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
+		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',
+				entityName: 'Author',
+				newEntityName: 'User',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))
 
-describe('rename table with acl', () => testMigrations({
-	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,
+describe('rename table with acl', () =>
+	testMigrations({
+		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,
+									},
 								},
 							},
 						},
@@ -100,22 +104,22 @@ describe('rename table with acl', () => testMigrations({
 				},
 			},
 		},
-	},
-	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,
+		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,
+									},
 								},
 							},
 						},
@@ -123,14 +127,13 @@ describe('rename table with acl', () => testMigrations({
 				},
 			},
 		},
-	},
-	diff: [
-		{
-			modification: 'updateEntityName',
-			entityName: 'Site',
-			newEntityName: 'Website',
-		},
-	],
-	sql: SQL``,
-	noDiff: true,
-}))
+		diff: [
+			{
+				modification: 'updateEntityName',
+				entityName: 'Site',
+				newEntityName: 'Website',
+			},
+		],
+		sql: SQL``,
+		noDiff: true,
+	}))

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

@@ -4,43 +4,40 @@ 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()
 	}
@@ -50,30 +47,29 @@ 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'],
+describe('update enum if used in list', () =>
+	testMigrations({
+		original: {
+			model: createSchema(EnumModelOriginal).model,
+		},
+		updated: {
+			model: createSchema(EnumModelUpdated).model,
 		},
-	],
-	sql: SQL`ALTER DOMAIN "FooStatus" RENAME TO "FooStatus__old"; 
+		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";`,
-}))
+	}))