@contember/schema-migrations 2.0.0-alpha.32 → 2.0.0-alpha.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.0.0-alpha.32",
+  "version": "2.0.0-alpha.35",
   "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.32",
-    "@contember/database-migrations": "2.0.0-alpha.32",
-    "@contember/engine-common": "2.0.0-alpha.32",
-    "@contember/schema": "2.0.0-alpha.32",
-    "@contember/schema-utils": "2.0.0-alpha.32",
+    "@contember/database": "2.0.0-alpha.35",
+    "@contember/database-migrations": "2.0.0-alpha.35",
+    "@contember/engine-common": "2.0.0-alpha.35",
+    "@contember/schema": "2.0.0-alpha.35",
+    "@contember/schema-utils": "2.0.0-alpha.35",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.1.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.0.0-alpha.32"
+    "@contember/schema-definition": "2.0.0-alpha.35"
   },
   "peerDependencies": {
     "pg": "^8.9.0"
   },
   "type": "module"
-}
+}

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()
@@ -170,4 +171,4 @@ 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";`,
-})
+}))

package/tests/cases/integration/createManyHasMany.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 many has many relation (post with categories)', {
+describe('create many has many relation (post with categories)', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', e => e.column('title', c => c.type(Model.ColumnType.String)))
@@ -109,4 +110,4 @@ testMigrations('create many has many relation (post with categories)', {
 		DEFERRABLE INITIALLY DEFERRED
 		FOR EACH ROW
 	EXECUTE PROCEDURE "system"."trigger_event_commit"();`,
-})
+}))

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

@@ -1,9 +1,10 @@
 import { 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'
 
-testMigrations('create many has one relation (post with author)', {
+describe('create many has one relation (post with author)', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Author', e => e.column('name', c => c.type(Model.ColumnType.String)))
@@ -90,4 +91,4 @@ testMigrations('create many has one relation (post with author)', {
 	ALTER TABLE "post"
 		ADD FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;
 	CREATE INDEX ON "post" ("author_id");`,
-})
+}))

package/tests/cases/integration/createOneHasMany.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 one has many relation (post with locales)', {
+describe('create one has many relation (post with locales)', () => testMigrations({
 	original: { model: new SchemaBuilder().entity('Post', e => e).buildSchema() },
 	updated: {
 		model: new SchemaBuilder()
@@ -122,4 +123,4 @@ testMigrations('create one has many relation (post with locales)', {
 	CREATE INDEX ON "post_locale" ("post_id");
 	ALTER TABLE "post_locale"
 		ADD UNIQUE ("post_id", "locale");`,
-})
+}))

package/tests/cases/integration/createOneHasOne.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 one has one relation (site with settings)', {
+describe('create one has one relation (site with settings)', () => testMigrations({
 	original: {},
 	updated: {
 		model: new SchemaBuilder()
@@ -146,4 +147,4 @@ testMigrations('create one has one relation (site with settings)', {
 	ALTER TABLE "site"
 		ADD UNIQUE ("setting_id");
 		`,
-})
+}))

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

@@ -1,10 +1,11 @@
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { createDatabaseMetadata, ForeignKeyDeleteAction } from '@contember/database'
 
-testMigrations('create inverse side relation (post with locales)', {
+describe('create inverse side relation (post with locales)', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', e => e)
@@ -30,9 +31,9 @@ testMigrations('create inverse side relation (post with locales)', {
 		},
 	],
 	sql: SQL``,
-})
+}))
 
-testMigrations('create inverse side relation together with changing onDelete behaviour', {
+describe('create inverse side relation together with changing onDelete behaviour', () => testMigrations({
 	original: {
 		model: new SchemaBuilder()
 			.entity('Post', e => e)
@@ -82,4 +83,4 @@ testMigrations('create inverse side relation together with changing onDelete beh
 		indexes: [],
 		uniqueConstraints: [],
 	}),
-})
+}))

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

@@ -1,10 +1,11 @@
 import { c, createSchema } from '@contember/schema-definition'
 import { SQL } from '../../src/tags'
+import { describe } from 'bun:test'
 import { testMigrations } from '../../src/tests'
 import { createUniqueConstraintModification, removeUniqueConstraintModification } from '../../../src'
 import { createDatabaseMetadata } from '@contember/database'
 
-testMigrations('create unique (immediate)', {
+describe('create unique (immediate)', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = c.stringColumn()
@@ -24,9 +25,9 @@ testMigrations('create unique (immediate)', {
 		}),
 	],
 	sql: SQL`ALTER TABLE "author" ADD UNIQUE ("email");`,
-})
+}))
 
-testMigrations('create unique (deferrable)', {
+describe('create unique (deferrable)', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = c.stringColumn()
@@ -48,10 +49,10 @@ testMigrations('create unique (deferrable)', {
 	],
 	sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") DEFERRABLE;`,
-})
+}))
 
 
-testMigrations('create unique (deferred)', {
+describe('create unique (deferred)', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = c.stringColumn()
@@ -74,10 +75,10 @@ testMigrations('create unique (deferred)', {
 	],
 	sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") INITIALLY DEFERRED;`,
-})
+}))
 
 
-testMigrations('change unique timing', {
+describe('change unique timing', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = c.stringColumn().unique()
@@ -114,7 +115,7 @@ ALTER TABLE "author" ADD UNIQUE ("email") DEFERRABLE;`,
 			deferrable: false,
 		}],
 	}),
-})
+}))
 
 
 namespace SchemaWithUniqueDecorator {
@@ -125,7 +126,7 @@ namespace SchemaWithUniqueDecorator {
 	}
 }
 
-testMigrations('create unique using decorator', {
+describe('create unique using decorator', () => testMigrations({
 	original: createSchema({
 		Author: class Author {
 			email = c.stringColumn()
@@ -143,4 +144,4 @@ testMigrations('create unique using decorator', {
 	],
 	sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") INITIALLY DEFERRED;`,
-})
+}))