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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0-beta.2",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,19 +23,19 @@
     }
   },
   "dependencies": {
-    "@contember/database": "2.0.0-alpha.9",
-    "@contember/database-migrations": "2.0.0-alpha.9",
-    "@contember/engine-common": "2.0.0-alpha.9",
-    "@contember/schema": "2.0.0-alpha.9",
-    "@contember/schema-utils": "2.0.0-alpha.9",
+    "@contember/database": "2.0.0-beta.2",
+    "@contember/database-migrations": "2.0.0-beta.2",
+    "@contember/engine-common": "2.0.0-beta.2",
+    "@contember/schema": "2.0.0-beta.2",
+    "@contember/schema-utils": "2.0.0-beta.2",
     "fast-deep-equal": "^3.1.3",
-    "rfc6902": "^5.0.1"
+    "rfc6902": "^5.1.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.0.0-alpha.9"
+    "@contember/schema-definition": "2.0.0-beta.2"
   },
   "peerDependencies": {
     "pg": "^8.9.0"
   },
   "type": "module"
-}
+}

package/src/SchemaDiffer.ts

@@ -48,7 +48,12 @@ import { ConvertOneHasManyToOneHasOneRelationDiffer } from './modifications/rela
 type DiffOptions = { skipRecreateValidation?: boolean; skipInitialSchemaValidation?: boolean }
 
 export class SchemaDiffer {
-	constructor(private readonly schemaMigrator: SchemaMigrator) {}
+	constructor(
+		private readonly schemaMigrator: SchemaMigrator,
+		private readonly options?: {
+			maxPatchSize?: number
+		},
+	) {}
 
 	diffSchemas(originalSchema: Schema, updatedSchema: Schema, {
 		skipInitialSchemaValidation = false,
@@ -99,8 +104,8 @@ export class SchemaDiffer {
 			new CreateUniqueConstraintDiffer(),
 			new CreateIndexDiffer(),
 			new RemoveEnumDiffer(),
-			new UpdateAclSchemaDiffer(),
-			new UpdateValidationSchemaDiffer(),
+			new UpdateAclSchemaDiffer(this.options),
+			new UpdateValidationSchemaDiffer(this.options),
 			new UpdateEntityOrderByDiffer(),
 			new UpdateTargetDiffer(),
 			new CreateTargetDiffer(),

package/src/modifications/acl/UpdateAclSchemaModification.ts

@@ -32,12 +32,19 @@ export const updateAclSchemaModification = createModificationType({
 })
 
 export class UpdateAclSchemaDiffer implements Differ {
+	constructor(
+		private readonly options?: {
+			maxPatchSize?: number
+		},
+	) {
+	}
+
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		if (deepEqual(originalSchema.acl, updatedSchema.acl)) {
 			return []
 		}
 		const patch = createPatch(originalSchema.acl, updatedSchema.acl)
-		if (patch.length <= 100) {
+		if (patch.length <= (this.options?.maxPatchSize ?? 100)) {
 			return [patchAclSchemaModification.createModification({ patch })]
 		}
 		return [updateAclSchemaModification.createModification({ schema: updatedSchema.acl })]

package/src/modifications/columns/columnUtils.ts

@@ -36,7 +36,7 @@ export const formatSeedExpression = ({ model, entity, columnType, fillValue, cop
 	copyValue?: string
 }): string | null => {
 	if (fillValue !== undefined) {
-		return escapeValue(fillValue)
+		return escapeValue(fillValue).toString()
 	} else if (copyValue !== undefined) {
 		const copyFrom = getColumnName(model, entity, copyValue)
 		return `${wrapIdentifier(copyFrom)}::${columnType}`

package/src/modifications/entities/RemoveEntityModification.ts

@@ -1,5 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Acl, Schema } from '@contember/schema'
+import { Acl, Model, Schema } from '@contember/schema'
 import {
 	removeField,
 	SchemaUpdater,
@@ -18,7 +18,7 @@ import {
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_REFERENCING_RELATIONS } from '../ModificationVersions'
-import { isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, isInverseRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { removeFieldModification } from '../fields'
 
 export class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
@@ -40,6 +40,17 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 				removeFieldHandler.createSql(builder, options)
 			})
 		}
+		acceptEveryFieldVisitor(this.schema.model, entity, {
+			visitManyHasManyOwning: ({ relation }) => {
+				builder.dropTable(relation.joiningTable.tableName)
+			},
+			visitManyHasManyInverse: () => {},
+			visitColumn: () => {},
+			visitOneHasOneInverse: () => {},
+			visitOneHasOneOwning: () => {},
+			visitManyHasOne: () => {},
+			visitOneHasMany: () => {},
+		})
 		builder.dropTable(entity.tableName)
 	}
 
@@ -99,7 +110,8 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 	private getFieldsToRemove(schema: Schema): [entity: string, field: string][] {
 		return Object.values(schema.model.entities).flatMap(entity =>
 			Object.values(entity.fields)
-				.filter(field => isRelation(field) && field.target === this.data.entityName)
+				.filter((field): field is Model.AnyRelation => isRelation(field) && field.target === this.data.entityName)
+				.filter(field => !isInverseRelation(field) || entity.name !== this.data.entityName) // skip self-referencing inverse relations
 				.map((field): [string, string] => [entity.name, field.name]),
 		)
 	}

package/src/modifications/validation/UpdateValidationSchemaModification.ts

@@ -33,12 +33,19 @@ export const updateValidationSchemaModification = createModificationType({
 })
 
 export class UpdateValidationSchemaDiffer implements Differ {
+	constructor(
+		private readonly options?: {
+			maxPatchSize?: number
+		},
+	) {
+	}
+
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		if (deepEqual(originalSchema.validation, updatedSchema.validation)) {
 			return []
 		}
 		const patch = createPatch(originalSchema.validation, updatedSchema.validation)
-		if (patch.length <= 20) {
+		if (patch.length <= (this.options?.maxPatchSize ?? 100)) {
 			return [patchValidationSchemaModification.createModification({ patch })]
 		}
 		return [updateValidationSchemaModification.createModification({ schema: updatedSchema.validation })]

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

@@ -1,3 +1,4 @@
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -25,24 +26,27 @@ namespace ConvertMHOtoOHOSchemaUpdated {
 	}
 }
 
-
-testMigrations('convert one has many to one has one', {
-	original: createSchema(ConvertMHOtoOHOSchemaOrig),
-	updated: createSchema(ConvertMHOtoOHOSchemaUpdated),
-	diff: [{
-		entityName: 'ArticleReview',
-		fieldName: 'article',
-		modification: 'convertOneHasManyToOneHasOneRelation',
-		newInverseSideFieldName: 'review',
-	}],
-	sql: SQL`DROP INDEX "article_review_article_id_idx"; ALTER TABLE "article_review" ADD UNIQUE ("article_id");`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [],
-		indexes: [{
-			indexName: 'article_review_article_id_idx',
-			columnNames: ['article_id'],
-			tableName: 'article_review',
+describe('convert one has many to one has one', () => {
+	testMigrations({
+		original: createSchema(ConvertMHOtoOHOSchemaOrig),
+		updated: createSchema(ConvertMHOtoOHOSchemaUpdated),
+		diff: [{
+			entityName: 'ArticleReview',
+			fieldName: 'article',
+			modification: 'convertOneHasManyToOneHasOneRelation',
+			newInverseSideFieldName: 'review',
 		}],
-		uniqueConstraints: [],
-	}),
+		sql: SQL`DROP INDEX "article_review_article_id_idx";
+        ALTER TABLE "article_review"
+            ADD UNIQUE ("article_id");`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [{
+				indexName: 'article_review_article_id_idx',
+				columnNames: ['article_id'],
+				tableName: 'article_review',
+			}],
+			uniqueConstraints: [],
+		}),
+	})
 })

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

@@ -1,3 +1,4 @@
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -24,62 +25,63 @@ namespace ConvertOHMToMHMSchemaOrigUpdated {
 	}
 }
 
-
-testMigrations('convert one has many to many has many', {
-	original: createSchema(ConvertOHMToMHMSchemaOrig),
-	updated: createSchema(ConvertOHMToMHMSchemaOrigUpdated),
-	diff: [
-		{
-			modification: 'convertOneHasManyToManyHasManyRelation',
-			entityName: 'Article',
-			fieldName: 'category',
-			owningSide: {
-				type: 'ManyHasMany',
-				name: 'categories',
-				inversedBy: 'articles',
-				target: 'Category',
-				joiningTable: {
-					tableName: 'article_categories',
-					joiningColumn: {
-						columnName: 'article_id',
-						onDelete: 'cascade',
-					},
-					inverseJoiningColumn: {
-						columnName: 'category_id',
-						onDelete: 'cascade',
-					},
-					eventLog: {
-						enabled: true,
+describe('convert one has many to many has many', () => {
+	testMigrations({
+		original: createSchema(ConvertOHMToMHMSchemaOrig),
+		updated: createSchema(ConvertOHMToMHMSchemaOrigUpdated),
+		diff: [
+			{
+				modification: 'convertOneHasManyToManyHasManyRelation',
+				entityName: 'Article',
+				fieldName: 'category',
+				owningSide: {
+					type: 'ManyHasMany',
+					name: 'categories',
+					inversedBy: 'articles',
+					target: 'Category',
+					joiningTable: {
+						tableName: 'article_categories',
+						joiningColumn: {
+							columnName: 'article_id',
+							onDelete: 'cascade',
+						},
+						inverseJoiningColumn: {
+							columnName: 'category_id',
+							onDelete: 'cascade',
+						},
+						eventLog: {
+							enabled: true,
+						},
 					},
 				},
+				inverseSide: {
+					name: 'articles',
+					ownedBy: 'categories',
+					target: 'Article',
+					type: 'ManyHasMany',
+				},
 			},
-			inverseSide: {
-				name: 'articles',
-				ownedBy: 'categories',
-				target: 'Article',
-				type: 'ManyHasMany',
-			},
-		},
-	],
-	sql: SQL`
-	CREATE TABLE "article_categories" (
-		"article_id" uuid NOT NULL REFERENCES "article"("id") ON DELETE CASCADE,
-		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
-	);
-	ALTER TABLE "article_categories"
-		ADD PRIMARY KEY ("article_id", "category_id");
-
-	CREATE TRIGGER "log_event" AFTER INSERT OR UPDATE OR DELETE
-	    ON "article_categories" FOR EACH ROW
-	    EXECUTE PROCEDURE "system"."trigger_event"($pga$article_id$pga$, $pga$category_id$pga$);
-
-	CREATE CONSTRAINT TRIGGER "log_event_trx" AFTER INSERT OR UPDATE OR DELETE
-	    ON "article_categories" DEFERRABLE INITIALLY DEFERRED FOR EACH ROW
-	    EXECUTE PROCEDURE "system"."trigger_event_commit"();
-
-	INSERT INTO "article_categories" ( "article_id", "category_id" )
-	SELECT "id", "category_id" FROM "article" WHERE "category_id" IS NOT NULL;
-
-	ALTER TABLE "article" DROP "category_id";
-	`,
+		],
+		sql: SQL`
+		CREATE TABLE "article_categories" (
+			"article_id" uuid NOT NULL REFERENCES "article"("id") ON DELETE CASCADE,
+			"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
+		);
+		ALTER TABLE "article_categories"
+			ADD PRIMARY KEY ("article_id", "category_id");
+	
+		CREATE TRIGGER "log_event" AFTER INSERT OR UPDATE OR DELETE
+			ON "article_categories" FOR EACH ROW
+			EXECUTE PROCEDURE "system"."trigger_event"($pga$article_id$pga$, $pga$category_id$pga$);
+	
+		CREATE CONSTRAINT TRIGGER "log_event_trx" AFTER INSERT OR UPDATE OR DELETE
+			ON "article_categories" DEFERRABLE INITIALLY DEFERRED FOR EACH ROW
+			EXECUTE PROCEDURE "system"."trigger_event_commit"();
+	
+		INSERT INTO "article_categories" ( "article_id", "category_id" )
+		SELECT "id", "category_id" FROM "article" WHERE "category_id" IS NOT NULL;
+	
+		ALTER TABLE "article" DROP "category_id";
+		`,
+	})
 })

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

@@ -3,50 +3,54 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 import { createDatabaseMetadata } from '@contember/database'
+import { describe } from 'bun:test'
 
-testMigrations('convert one has one to many has one relation without inverse side', {
-	original: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.oneHasOne('image', rel => rel.target('Image')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Post', entity =>
-				entity.manyHasOne('image', rel => rel.target('Image')),
-			)
-			.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'convertOneToManyRelation',
-			entityName: 'Post',
-			fieldName: 'image',
+describe('convert one has one to many has one relation', () => {
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Post', entity =>
+					entity.oneHasOne('image', rel => rel.target('Image')),
+				)
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL`
-		CREATE INDEX ON "post" ("image_id");
-		ALTER TABLE "post" DROP CONSTRAINT "uniq_post_image_id";
-	`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [],
-		indexes: [],
-		uniqueConstraints: [{
-			constraintName: 'uniq_post_image_id',
-			columnNames: ['image_id'],
-			tableName: 'post',
-			deferred: false,
-			deferrable: false,
-		}],
-	}),
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Post', entity =>
+					entity.manyHasOne('image', rel => rel.target('Image')),
+				)
+				.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+				.buildSchema(),
+		},
+		diff: [
+			{
+				modification: 'convertOneToManyRelation',
+				entityName: 'Post',
+				fieldName: 'image',
+			},
+		],
+		sql: SQL`
+            CREATE INDEX ON "post" ("image_id");
+            ALTER TABLE "post"
+                DROP CONSTRAINT "uniq_post_image_id";
+		`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [],
+			uniqueConstraints: [{
+				constraintName: 'uniq_post_image_id',
+				columnNames: ['image_id'],
+				tableName: 'post',
+				deferred: false,
+				deferrable: false,
+			}],
+		}),
+	})
 })
 
 
-testMigrations('convert one has one to many has one relation with inverse side', {
+describe('convert one has one to many has one relation with inverse side', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', entity =>
@@ -86,9 +90,9 @@ testMigrations('convert one has one to many has one relation with inverse side',
 			deferrable: false,
 		}],
 	}),
-})
+}))
 
-testMigrations('convert one has one to many has one relation with inverse side, but not renamed', {
+describe('convert one has one to many has one relation with inverse side, but not renamed', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', entity =>
@@ -128,5 +132,5 @@ testMigrations('convert one has one to many has one relation with inverse side,
 			deferrable: false,
 		}],
 	}),
-})
+}))
 

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

@@ -1,3 +1,4 @@
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
@@ -17,7 +18,7 @@ namespace SchemaWithIndex {
 }
 
 
-testMigrations('create index', {
+describe('create index', () => testMigrations({
 	original: createSchema(SchemaWithoutIndex),
 	updated: createSchema(SchemaWithIndex),
 	diff: [
@@ -28,10 +29,10 @@ testMigrations('create index', {
 		},
 	],
 	sql: SQL`CREATE INDEX ON "article" ("title");`,
-})
+}))
 
 
-testMigrations('drop index', {
+describe('drop index', () => testMigrations({
 	original: createSchema(SchemaWithIndex),
 	updated: createSchema(SchemaWithoutIndex),
 	diff: [
@@ -51,4 +52,4 @@ testMigrations('drop index', {
 		}],
 		uniqueConstraints: [],
 	}),
-})
+}))

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

@@ -1,9 +1,10 @@
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 
-testMigrations('create a column with default value', {
+describe('create a column with default value', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = def.stringColumn().unique()
@@ -34,9 +35,9 @@ testMigrations('create a column with default value', {
 UPDATE "author" SET "name" = $pga$unnamed author$pga$;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
-})
+}))
 
-testMigrations('create a column with copy value', {
+describe('create a column with copy value', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = def.stringColumn().unique()
@@ -67,10 +68,10 @@ testMigrations('create a column with copy value', {
 UPDATE "author" SET "name" = "email"::text;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
-})
+}))
 
 
-testMigrations('create a column with default value with "using"', {
+describe('create a column with default value with "using"', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = def.stringColumn().unique()
@@ -79,6 +80,10 @@ testMigrations('create a column with default value with "using"', {
 	updated: createSchema({
 		Author: class Author {
 			name = def.stringColumn().default('unnamed author').notNull()
+			order = def.intColumn().default(0).notNull()
+			score = def.doubleColumn().default(1 / 3).notNull()
+			active = def.boolColumn().default(false).notNull()
+			createdAt = def.dateTimeColumn().default('2024-01-01 10:00').notNull()
 			email = def.stringColumn().unique()
 		},
 	}),
@@ -97,7 +102,73 @@ testMigrations('create a column with default value with "using"', {
 			fillValue: 'unnamed author',
 			valueMigrationStrategy: 'using',
 		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'order',
+				name: 'order',
+				nullable: false,
+				default: 0,
+				type: Model.ColumnType.Int,
+				columnType: 'integer',
+			},
+			fillValue: 0,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'score',
+				name: 'score',
+				nullable: false,
+				default: 0.3333333333333333,
+				type: Model.ColumnType.Double,
+				columnType: 'double precision',
+			},
+			fillValue: 0.3333333333333333,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'active',
+				name: 'active',
+				nullable: false,
+				default: false,
+				type: Model.ColumnType.Bool,
+				columnType: 'boolean',
+			},
+			fillValue: false,
+			valueMigrationStrategy: 'using',
+		},
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'created_at',
+				name: 'createdAt',
+				nullable: false,
+				default: '2024-01-01 10:00',
+				type: Model.ColumnType.DateTime,
+				columnType: 'timestamptz',
+			},
+			fillValue: '2024-01-01 10:00',
+			valueMigrationStrategy: 'using',
+		},
 	],
-	sql: SQL`ALTER TABLE "author" ADD "name" text;
-ALTER TABLE "author" ALTER "name" SET DATA TYPE text USING $pga$unnamed author$pga$, ALTER "name" SET NOT NULL;`,
-})
+	sql: SQL`
+ALTER TABLE "author" ADD "name" text;
+ALTER TABLE "author" ALTER "name" SET DATA TYPE text USING $pga$unnamed author$pga$, ALTER "name" SET NOT NULL;
+ALTER TABLE "author" ADD "order" integer;
+ALTER TABLE "author" ALTER "order" SET DATA TYPE integer USING 0, ALTER "order" SET NOT NULL;
+ALTER TABLE "author" ADD "score" double precision;
+ALTER TABLE "author" ALTER "score" SET DATA TYPE double precision USING 0.3333333333333333, ALTER "score" SET NOT NULL;
+ALTER TABLE "author" ADD "active" boolean; 
+ALTER TABLE "author" ALTER "active" SET DATA TYPE boolean USING false, 
+ALTER "active" SET NOT NULL; ALTER TABLE "author" ADD "created_at" timestamptz; 
+ALTER TABLE "author" ALTER "created_at" SET DATA TYPE timestamptz USING $pga$2024-01-01 10:00$pga$, ALTER "created_at" SET NOT NULL;
+`,
+}))

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

@@ -1,10 +1,11 @@
 import { createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 
-testMigrations('create a table (no relations, unique on column)', {
+describe('create a table (no relations, unique on column)', () => testMigrations({
 	original: {  },
 	updated: {
 		model: new SchemaBuilder()
@@ -101,7 +102,7 @@ testMigrations('create a table (no relations, unique on column)', {
 		ADD "registered_at" date;
 	ALTER TABLE "author"
 		ADD UNIQUE ("email");`,
-})
+}))
 
 namespace ViewEntityUpdatedSchema {
 	@def.View("SELECT null as id, 'John' AS name")
@@ -109,7 +110,7 @@ namespace ViewEntityUpdatedSchema {
 		name = def.stringColumn()
 	}
 }
-testMigrations('create a view', {
+describe('create a view', () => testMigrations({
 	original: {},
 	updated: createSchema(ViewEntityUpdatedSchema),
 	diff: [
@@ -146,4 +147,4 @@ testMigrations('create a view', {
 		},
 	],
 	sql: SQL`CREATE VIEW "author" AS SELECT null as id, 'John' AS name;`,
-})
+}))

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

@@ -1,9 +1,10 @@
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 
-testMigrations('create enum', {
+describe('create enum', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
@@ -40,4 +41,4 @@ testMigrations('create enum', {
 	sql: SQL`CREATE DOMAIN "postStatus" AS text CONSTRAINT "poststatus_check" CHECK (VALUE IN('publish','draft'));
 	ALTER TABLE "post"
 		ADD "status" "postStatus";`,
-})
+}))