@contember/schema-migrations 2.1.0-alpha.8 → 2.1.0-beta.1

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

@@ -5,82 +5,83 @@ import { SQL } from '../../src/tags'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { createDatabaseMetadata, ForeignKeyDeleteAction } from '@contember/database'
 
-describe('create inverse side relation (post with locales)', () => testMigrations({
-	original: {
-		model: new SchemaBuilder()
-			.entity('Post', e => e)
-			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Post', e => e)
-			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post').inversedBy('locales')))
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'createRelationInverseSide',
-			entityName: 'Post',
-			relation: {
-				name: 'locales',
-				type: Model.RelationType.OneHasMany,
-				target: 'PostLocale',
-				ownedBy: 'post',
-			},
+describe('create inverse side relation (post with locales)', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Post', e => e)
+				.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
+				.buildSchema(),
 		},
-	],
-	sql: SQL``,
-}))
-
-describe('create inverse side relation together with changing onDelete behaviour', () => testMigrations({
-	original: {
-		model: new SchemaBuilder()
-			.entity('Post', e => e)
-			.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
-			.buildSchema(),
-	},
-	updated: {
-		model: new SchemaBuilder()
-			.entity('Post', e => e)
-			.entity('PostLocale', e =>
-				e.manyHasOne('post', r => r.target('Post').inversedBy('locales').onDelete(Model.OnDelete.cascade)),
-			)
-			.buildSchema(),
-	},
-	diff: [
-		{
-			modification: 'updateRelationOnDelete',
-			entityName: 'PostLocale',
-			fieldName: 'post',
-			onDelete: 'cascade',
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Post', e => e)
+				.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post').inversedBy('locales')))
+				.buildSchema(),
 		},
-		{
-			modification: 'createRelationInverseSide',
-			entityName: 'Post',
-			relation: {
-				name: 'locales',
-				type: Model.RelationType.OneHasMany,
-				target: 'PostLocale',
-				ownedBy: 'post',
+		diff: [
+			{
+				modification: 'createRelationInverseSide',
+				entityName: 'Post',
+				relation: {
+					name: 'locales',
+					type: Model.RelationType.OneHasMany,
+					target: 'PostLocale',
+					ownedBy: 'post',
+				},
 			},
+		],
+		sql: SQL``,
+	}))
+
+describe('create inverse side relation together with changing onDelete behaviour', () =>
+	testMigrations({
+		original: {
+			model: new SchemaBuilder()
+				.entity('Post', e => e)
+				.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post')))
+				.buildSchema(),
+		},
+		updated: {
+			model: new SchemaBuilder()
+				.entity('Post', e => e)
+				.entity('PostLocale', e => e.manyHasOne('post', r => r.target('Post').inversedBy('locales').onDelete(Model.OnDelete.cascade)))
+				.buildSchema(),
 		},
-	],
-	sql: SQL`ALTER TABLE "post_locale" DROP CONSTRAINT "fk_post_locale_post_id_post_id"; ALTER TABLE "post_locale" ADD FOREIGN KEY ("post_id") REFERENCES "post"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [
+		diff: [
+			{
+				modification: 'updateRelationOnDelete',
+				entityName: 'PostLocale',
+				fieldName: 'post',
+				onDelete: 'cascade',
+			},
 			{
-				constraintName: 'fk_post_locale_post_id_post_id',
-				deleteAction: ForeignKeyDeleteAction.cascade,
-				fromColumn: 'post_id',
-				fromTable: 'post_locale',
-				toColumn: 'id',
-				toTable: 'post',
-				deferred: false,
-				deferrable: false,
+				modification: 'createRelationInverseSide',
+				entityName: 'Post',
+				relation: {
+					name: 'locales',
+					type: Model.RelationType.OneHasMany,
+					target: 'PostLocale',
+					ownedBy: 'post',
+				},
 			},
 		],
-		indexes: [],
-		uniqueConstraints: [],
-	}),
-}))
+		sql:
+			SQL`ALTER TABLE "post_locale" DROP CONSTRAINT "fk_post_locale_post_id_post_id"; ALTER TABLE "post_locale" ADD FOREIGN KEY ("post_id") REFERENCES "post"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [
+				{
+					constraintName: 'fk_post_locale_post_id_post_id',
+					deleteAction: ForeignKeyDeleteAction.cascade,
+					fromColumn: 'post_id',
+					fromTable: 'post_locale',
+					toColumn: 'id',
+					toTable: 'post',
+					deferred: false,
+					deferrable: false,
+				},
+			],
+			indexes: [],
+			uniqueConstraints: [],
+		}),
+	}))

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

@@ -5,148 +5,148 @@ import { testMigrations } from '../../src/tests'
 import { createUniqueConstraintModification, removeUniqueConstraintModification } from '../../../src'
 import { createDatabaseMetadata } from '@contember/database'
 
-describe('create unique (immediate)', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn()
-		},
-	}),
-	updated: createSchema({
-		Author: class Author {
-			email = c.stringColumn().unique()
-		},
-	}),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
+describe('create unique (immediate)', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
 			},
 		}),
-	],
-	sql: SQL`ALTER TABLE "author" ADD UNIQUE ("email");`,
-}))
-
-describe('create unique (deferrable)', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn()
-		},
-	}),
-	updated: createSchema({
-		Author: class Author {
-			email = c.stringColumn().unique({ timing: 'deferrable' })
-		},
-	}),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				timing: 'deferrable',
+		updated: createSchema({
+			Author: class Author {
+				email = c.stringColumn().unique()
 			},
 		}),
-	],
-	sql: SQL`ALTER TABLE "author"
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+				},
+			}),
+		],
+		sql: SQL`ALTER TABLE "author" ADD UNIQUE ("email");`,
+	}))
+
+describe('create unique (deferrable)', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
+			},
+		}),
+		updated: createSchema({
+			Author: class Author {
+				email = c.stringColumn().unique({ timing: 'deferrable' })
+			},
+		}),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					timing: 'deferrable',
+				},
+			}),
+		],
+		sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") DEFERRABLE;`,
-}))
-
-
-describe('create unique (deferred)', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn()
-		},
-	}),
-	updated: createSchema({
-		Author: class Author {
-			email = c.stringColumn().unique({ timing: 'deferred' })
-		},
-	}),
-	diff: [
-
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				timing: 'deferred',
+	}))
+
+describe('create unique (deferred)', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
 			},
 		}),
-	],
-	sql: SQL`ALTER TABLE "author"
+		updated: createSchema({
+			Author: class Author {
+				email = c.stringColumn().unique({ timing: 'deferred' })
+			},
+		}),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					timing: 'deferred',
+				},
+			}),
+		],
+		sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") INITIALLY DEFERRED;`,
-}))
-
-
-describe('change unique timing', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn().unique()
-		},
-	}),
-	updated: createSchema({
-		Author: class Author {
-			email = c.stringColumn().unique({ timing: 'deferrable' })
-		},
-	}),
-	diff: [
-		removeUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
+	}))
+
+describe('change unique timing', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn().unique()
 			},
 		}),
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				timing: 'deferrable',
+		updated: createSchema({
+			Author: class Author {
+				email = c.stringColumn().unique({ timing: 'deferrable' })
 			},
 		}),
-	],
-	sql: SQL`ALTER TABLE "author" DROP CONSTRAINT "uniq_author_email"; 
+		diff: [
+			removeUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+				},
+			}),
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					timing: 'deferrable',
+				},
+			}),
+		],
+		sql: SQL`ALTER TABLE "author" DROP CONSTRAINT "uniq_author_email";
 ALTER TABLE "author" ADD UNIQUE ("email") DEFERRABLE;`,
-	databaseMetadata: createDatabaseMetadata({
-		foreignKeys: [],
-		indexes: [],
-		uniqueConstraints: [{
-			constraintName: 'uniq_author_email',
-			columnNames: ['email'],
-			tableName: 'author',
-			deferred: false,
-			deferrable: false,
-		}],
-	}),
-}))
-
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [],
+			uniqueConstraints: [{
+				constraintName: 'uniq_author_email',
+				columnNames: ['email'],
+				tableName: 'author',
+				deferred: false,
+				deferrable: false,
+			}],
+		}),
+	}))
 
 namespace SchemaWithUniqueDecorator {
-
 	@c.Unique({ fields: ['email'], timing: 'deferred' })
 	export class Author {
 		email = c.stringColumn()
 	}
 }
 
-describe('create unique using decorator', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn()
-		},
-	}),
-	updated: createSchema(SchemaWithUniqueDecorator),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				timing: 'deferred',
+describe('create unique using decorator', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
 			},
 		}),
-	],
-	sql: SQL`ALTER TABLE "author"
+		updated: createSchema(SchemaWithUniqueDecorator),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					timing: 'deferred',
+				},
+			}),
+		],
+		sql: SQL`ALTER TABLE "author"
         ADD UNIQUE ("email") INITIALLY DEFERRED;`,
-}))
+	}))
 
 namespace AuthorWithUniqueIndex {
 	@c.Unique({ fields: ['email'], index: true, nulls: 'not distinct' })
@@ -155,25 +155,26 @@ namespace AuthorWithUniqueIndex {
 	}
 }
 
-describe('create unique index', () => testMigrations({
-	original: createSchema({
-		Author: class Author {
-			email = c.stringColumn()
-		},
-	}),
-	updated: createSchema(AuthorWithUniqueIndex),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				index: true,
-				nulls: 'not distinct',
+describe('create unique index', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
 			},
 		}),
-	],
-	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email") NULLS NOT DISTINCT;`,
-}))
+		updated: createSchema(AuthorWithUniqueIndex),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					nulls: 'not distinct',
+				},
+			}),
+		],
+		sql: SQL`CREATE UNIQUE INDEX ON "author" ("email") NULLS NOT DISTINCT;`,
+	}))
 
 namespace ViewWithUniqueIndexOriginal {
 	@c.View(`select 1 as id, 'foo@localhost' as email)`)
@@ -190,21 +191,21 @@ namespace ViewWithUniqueIndexUpdated {
 	}
 }
 
-describe('create unique index', () => testMigrations({
-	original: createSchema(ViewWithUniqueIndexOriginal),
-	updated: createSchema(ViewWithUniqueIndexUpdated),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				index: true,
-			},
-		}),
-	],
-	sql: SQL``,
-}))
-
+describe('create unique index', () =>
+	testMigrations({
+		original: createSchema(ViewWithUniqueIndexOriginal),
+		updated: createSchema(ViewWithUniqueIndexUpdated),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+				},
+			}),
+		],
+		sql: SQL``,
+	}))
 
 namespace MaterializedViewWithUniqueIndexOriginal {
 	@c.View(`select 1 as id, 'foo@localhost' as email)`, { materialized: true })
@@ -221,17 +222,175 @@ namespace MaterializedViewWithUniqueIndexUpdated {
 	}
 }
 
-describe('create unique index', () => testMigrations({
-	original: createSchema(MaterializedViewWithUniqueIndexOriginal),
-	updated: createSchema(MaterializedViewWithUniqueIndexUpdated),
-	diff: [
-		createUniqueConstraintModification.createModification({
-			entityName: 'Author',
-			unique: {
-				fields: ['email'],
-				index: true,
+describe('create unique index', () =>
+	testMigrations({
+		original: createSchema(MaterializedViewWithUniqueIndexOriginal),
+		updated: createSchema(MaterializedViewWithUniqueIndexUpdated),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+				},
+			}),
+		],
+		sql: SQL`CREATE UNIQUE INDEX ON "author" ("email");`,
+	}))
+
+namespace AuthorWithUniqueGinIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'gin' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+namespace AuthorWithUniqueGistIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'gist' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+namespace AuthorWithUniqueBtreeIndex {
+	@c.Unique({ fields: ['email'], index: true, method: 'btree', nulls: 'not distinct' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+describe('create unique index with GIN method', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
 			},
 		}),
-	],
-	sql: SQL`CREATE UNIQUE INDEX ON "author" ("email");`,
-}))
+		updated: createSchema(AuthorWithUniqueGinIndex),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'gin',
+				},
+			}),
+		],
+		sql: SQL`CREATE UNIQUE INDEX ON "author" USING gin ("email");`,
+	}))
+
+describe('create unique index with GiST method', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
+			},
+		}),
+		updated: createSchema(AuthorWithUniqueGistIndex),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'gist',
+				},
+			}),
+		],
+		sql: SQL`CREATE UNIQUE INDEX ON "author" USING gist ("email");`,
+	}))
+
+describe('create unique index with btree method and nulls not distinct', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+				email = c.stringColumn()
+			},
+		}),
+		updated: createSchema(AuthorWithUniqueBtreeIndex),
+		diff: [
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'btree',
+					nulls: 'not distinct',
+				},
+			}),
+		],
+		sql: SQL`CREATE UNIQUE INDEX ON "author" USING btree ("email") NULLS NOT DISTINCT;`,
+	}))
+
+describe('change unique index method from gin to gist', () =>
+	testMigrations({
+		original: createSchema(AuthorWithUniqueGinIndex),
+		updated: createSchema(AuthorWithUniqueGistIndex),
+		diff: [
+			removeUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'gin',
+				},
+			}),
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'gist',
+				},
+			}),
+		],
+		sql: SQL`DROP INDEX "uniq_author_email";
+CREATE UNIQUE INDEX ON "author" USING gist ("email");`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [{
+				tableName: 'author',
+				columnNames: ['email'],
+				indexName: 'uniq_author_email',
+				unique: true,
+			}],
+			uniqueConstraints: [],
+		}),
+	}))
+
+describe('change from regular unique index to method-specific unique index', () =>
+	testMigrations({
+		original: createSchema(AuthorWithUniqueIndex),
+		updated: createSchema(AuthorWithUniqueGinIndex),
+		diff: [
+			removeUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					nulls: 'not distinct',
+				},
+			}),
+			createUniqueConstraintModification.createModification({
+				entityName: 'Author',
+				unique: {
+					fields: ['email'],
+					index: true,
+					method: 'gin',
+				},
+			}),
+		],
+		sql: SQL`DROP INDEX "uniq_author_email";
+CREATE UNIQUE INDEX ON "author" USING gin ("email");`,
+		databaseMetadata: createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [{
+				tableName: 'author',
+				columnNames: ['email'],
+				indexName: 'uniq_author_email',
+				unique: true,
+			}],
+			uniqueConstraints: [],
+		}),
+	}))