@contember/schema-migrations 1.3.4 → 1.4.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "1.3.4",
+  "version": "1.4.0-alpha.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -12,15 +12,16 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/database-migrations": "1.3.4",
-    "@contember/engine-common": "1.3.4",
-    "@contember/schema": "1.3.4",
-    "@contember/schema-utils": "1.3.4",
+    "@contember/database": "1.4.0-alpha.1",
+    "@contember/database-migrations": "1.4.0-alpha.1",
+    "@contember/engine-common": "1.4.0-alpha.1",
+    "@contember/schema": "1.4.0-alpha.1",
+    "@contember/schema-utils": "1.4.0-alpha.1",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.0.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "1.3.4"
+    "@contember/schema-definition": "1.4.0-alpha.1"
   },
   "peerDependencies": {
     "pg": "^8.9.0"

package/src/modifications/ModificationHandler.ts

@@ -2,7 +2,7 @@ import { MigrationBuilder } from '@contember/database-migrations'
 import { SchemaUpdater } from './utils/schemaUpdateUtils'
 import { Schema } from '@contember/schema'
 import { Migration } from '../Migration'
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { DatabaseMetadata } from '@contember/database'
 
 export interface ModificationDescription {
 	message: string
@@ -23,7 +23,7 @@ export interface ModificationHandler<Data> {
 
 export interface ModificationHandlerCreateSqlOptions {
 	systemSchema: string
-	databaseMetadata: SchemaDatabaseMetadata
+	databaseMetadata: DatabaseMetadata
 	invalidateDatabaseMetadata: () => void
 }
 

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -30,7 +30,14 @@ export class CreateUniqueConstraintModificationHandler implements ModificationHa
 		const tableNameId = wrapIdentifier(entity.tableName)
 		const columnNameIds = columns.map(wrapIdentifier)
 
-		builder.sql(`ALTER TABLE ${tableNameId} ADD UNIQUE (${columnNameIds.join(', ')})`)
+		let checkModifier = ''
+		if (this.data.unique.timing === 'deferred') {
+			checkModifier = ' INITIALLY DEFERRED'
+		} else if (this.data.unique.timing === 'deferrable') {
+			checkModifier = ' DEFERRABLE'
+		}
+
+		builder.sql(`ALTER TABLE ${tableNameId} ADD UNIQUE (${columnNameIds.join(', ')})${checkModifier}`)
 
 		invalidateDatabaseMetadata()
 	}

package/src/modifications/constraints/RemoveUniqueConstraintModification.ts

@@ -29,7 +29,7 @@ export class RemoveUniqueConstraintModificationHandler implements ModificationHa
 			model: this.schema.model,
 		})
 
-		const constraintNames = databaseMetadata.getUniqueConstraintNames({ tableName: entity.tableName, columnNames: columns })
+		const constraintNames = databaseMetadata.uniqueConstraints.filter({ tableName: entity.tableName, columnNames: columns }).getNames()
 
 		for (const name of constraintNames) {
 			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
@@ -91,15 +91,13 @@ export class RemoveUniqueConstraintDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
 			entity.unique
-				.filter(
-					it => {
-						const updatedEntity = updatedSchema.model.entities[entity.name]
-						if (!updatedEntity) {
-							return false
-						}
-						return !updatedEntity.unique.find(uniq => deepEqual(uniq.fields, it.fields))
-					},
-				)
+				.filter(it => {
+					const updatedEntity = updatedSchema.model.entities[entity.name]
+					if (!updatedEntity) {
+						return false
+					}
+					return !updatedEntity.unique.find(uniq => deepEqual(uniq.fields, it.fields) && it.timing === uniq.timing)
+				})
 				.map(unique =>
 					removeUniqueConstraintModification.createModification({
 						entityName: entity.name,

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -27,7 +27,7 @@ export class RemoveIndexModificationHandler implements ModificationHandler<Remov
 			model: this.schema.model,
 		})
 
-		const indexNames = databaseMetadata.getIndexNames({ tableName: entity.tableName, columnNames: columns })
+		const indexNames = databaseMetadata.indexes.filter({ tableName: entity.tableName, columnNames: columns }).getNames()
 
 		for (const name of indexNames) {
 			builder.sql(`DROP INDEX ${wrapIdentifier(name)}`)

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -44,10 +44,11 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 		const columnNameId = wrapIdentifier(columnName)
 		builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameId})`)
 
-		const uniqueConstraintNames = options.databaseMetadata.getUniqueConstraintNames({
+		const uniqueConstraintNames = options.databaseMetadata.uniqueConstraints.filter({
 			tableName: entity.tableName,
-			columnNames: [relation.joiningColumn.columnName],
-		})
+			columnNames: [columnName],
+		}).getNames()
+
 		for (const name of uniqueConstraintNames) {
 			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
 		}

package/src/modifications/relations/helpers.ts

@@ -1,7 +1,7 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model } from '@contember/schema'
 import { wrapIdentifier } from '../../utils/dbHelpers'
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { DatabaseMetadata } from '@contember/database'
 
 export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntity, recreate = false, databaseMetadata, invalidateDatabaseMetadata }: {
 	recreate?: boolean
@@ -9,18 +9,18 @@ export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntit
 	entity: Model.Entity
 	targetEntity: Model.Entity
 	relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation
-	databaseMetadata: SchemaDatabaseMetadata
+	databaseMetadata: DatabaseMetadata
 	invalidateDatabaseMetadata: () => void
 }) => {
 	if (recreate) {
-		const fkNames = databaseMetadata.getForeignKeyConstraintNames(
+		const fkNames = databaseMetadata.foreignKeys.filter(
 			{
 				fromTable: entity.tableName,
 				fromColumn: relation.joiningColumn.columnName,
 				toTable: targetEntity.tableName,
 				toColumn: targetEntity.primaryColumn,
 			},
-		)
+		).getNames()
 		for (const name of fkNames) {
 			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
 		}

package/src/tsconfig.json

@@ -7,6 +7,7 @@
 	},
 	"references": [
 		{ "path": "../../database-migrations/src" },
+		{ "path": "../../database/src" },
 		{ "path": "../../engine-common/src" },
 		{ "path": "../../schema/src" },
 		{ "path": "../../schema-utils/src" }

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

@@ -2,6 +2,7 @@ import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { createDatabaseMetadata } from '@contember/database'
 
 testMigrations('convert one has one to many has one relation without inverse side', {
 	original: {
@@ -31,6 +32,17 @@ testMigrations('convert one has one to many has one relation without inverse sid
 		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,
+		}],
+	}),
 })
 
 
@@ -63,5 +75,16 @@ testMigrations('convert one has one to many has one relation with inverse side',
 	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,
+		}],
+	}),
 })
 

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

@@ -1,6 +1,7 @@
 import { testMigrations } from '../../src/tests'
 import { SQL } from '../../src/tags'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { createDatabaseMetadata } from '@contember/database'
 
 namespace SchemaWithoutIndex {
 	export class Article {
@@ -41,4 +42,13 @@ testMigrations('drop index', {
 		},
 	],
 	sql: SQL`DROP INDEX "idx_article_title";`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [{
+			tableName: 'article',
+			columnNames: ['title'],
+			indexName: 'idx_article_title',
+		}],
+		uniqueConstraints: [],
+	}),
 })

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

@@ -2,6 +2,7 @@ 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)', {
 	original: {
@@ -65,4 +66,20 @@ testMigrations('create inverse side relation together with changing onDelete beh
 		},
 	],
 	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

@@ -0,0 +1,146 @@
+import { c, createSchema } from '@contember/schema-definition'
+import { SQL } from '../../src/tags'
+import { testMigrations } from '../../src/tests'
+import { createUniqueConstraintModification, removeUniqueConstraintModification } from '../../../src'
+import { createDatabaseMetadata } from '@contember/database'
+
+testMigrations('create unique (immediate)', {
+	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'],
+			},
+		}),
+	],
+	sql: SQL`ALTER TABLE "author" ADD UNIQUE ("email");`,
+})
+
+testMigrations('create unique (deferrable)', {
+	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;`,
+})
+
+
+testMigrations('create unique (deferred)', {
+	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',
+			},
+		}),
+	],
+	sql: SQL`ALTER TABLE "author"
+        ADD UNIQUE ("email") INITIALLY DEFERRED;`,
+})
+
+
+testMigrations('change unique timing', {
+	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',
+			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,
+		}],
+	}),
+})
+
+
+namespace SchemaWithUniqueDecorator {
+
+	@c.Unique({ fields: ['email'], timing: 'deferred' })
+	export class Author {
+		email = c.stringColumn()
+	}
+}
+
+testMigrations('create unique using decorator', {
+	original: createSchema({
+		Author: class Author {
+			email = c.stringColumn()
+		},
+	}),
+	updated: createSchema(SchemaWithUniqueDecorator),
+	diff: [
+		createUniqueConstraintModification.createModification({
+			entityName: 'Author',
+			unique: {
+				fields: ['email'],
+				timing: 'deferred',
+			},
+		}),
+	],
+	sql: SQL`ALTER TABLE "author"
+        ADD UNIQUE ("email") INITIALLY DEFERRED;`,
+})

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

@@ -3,6 +3,7 @@ import { createSchema, SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
 import { SchemaDefinition as def } from '@contember/schema-definition'
+import { createDatabaseMetadata } from '@contember/database'
 
 
 testMigrations('remove relation (many has one)', {
@@ -67,6 +68,17 @@ testMigrations('remove relation (one has many)', {
 	],
 	sql: SQL`ALTER TABLE "post_locale" DROP CONSTRAINT "uniq_post_locale_post_id_locale";
 						ALTER TABLE "post_locale" DROP "post_id";`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [],
+		indexes: [],
+		uniqueConstraints: [{
+			constraintName: 'uniq_post_locale_post_id_locale',
+			columnNames: ['post_id', 'locale'],
+			tableName: 'post_locale',
+			deferrable: false,
+			deferred: false,
+		}],
+	}),
 })
 
 testMigrations('remove relation (many has many)', {

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

@@ -2,6 +2,7 @@ import { testMigrations } from '../../src/tests'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { SQL } from '../../src/tags'
+import { ForeignKeyDeleteAction, createDatabaseMetadata } from '@contember/database'
 
 testMigrations('update relation ondelete to cascade', {
 	original: {
@@ -32,4 +33,20 @@ testMigrations('update relation ondelete to cascade', {
 	],
 	sql: SQL`ALTER TABLE "post" DROP CONSTRAINT "fk_post_category_id_category_id"; 
 ALTER TABLE "post" ADD FOREIGN KEY ("category_id") REFERENCES "category"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;`,
+	databaseMetadata: createDatabaseMetadata({
+		foreignKeys: [
+			{
+				constraintName: 'fk_post_category_id_category_id',
+				deleteAction: ForeignKeyDeleteAction.cascade,
+				fromColumn: 'category_id',
+				fromTable: 'post',
+				toColumn: 'id',
+				toTable: 'category',
+				deferred: false,
+				deferrable: false,
+			},
+		],
+		indexes: [],
+		uniqueConstraints: [],
+	}),
 })

package/tests/src/tests.ts

@@ -2,7 +2,8 @@ import { Migration, ModificationHandlerFactory, SchemaDiffer, SchemaMigrator, VE
 import { Schema } from '@contember/schema'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { assert, describe, it } from 'vitest'
-import { dummySchemaDatabaseMetadata, emptySchema } from '@contember/schema-utils'
+import { emptySchema } from '@contember/schema-utils'
+import { DatabaseMetadata, emptyDatabaseMetadata } from '@contember/database'
 
 const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
 const schemaMigrator = new SchemaMigrator(modificationFactory)
@@ -14,6 +15,7 @@ export interface TestContext {
 	updated: Partial<Schema>
 	sql: string
 	noDiff?: boolean
+	databaseMetadata?: DatabaseMetadata
 }
 
 export function testDiffSchemas(
@@ -61,7 +63,12 @@ export function testApplyDiff(
 	})
 }
 
-export function testGenerateSql(original: Partial<Schema>, diff: Migration.Modification[], expectedSql: string) {
+export function testGenerateSql(
+	original: Partial<Schema>,
+	diff: Migration.Modification[],
+	expectedSql: string,
+	databaseMetadata: DatabaseMetadata = emptyDatabaseMetadata,
+) {
 	let schema = { ...emptySchema, ...original }
 	const builder = createMigrationBuilder()
 	for (let { modification, ...data } of diff) {
@@ -70,7 +77,7 @@ export function testGenerateSql(original: Partial<Schema>, diff: Migration.Modif
 		})
 		modificationHandler.createSql(builder, {
 			systemSchema: 'system',
-			databaseMetadata: dummySchemaDatabaseMetadata,
+			databaseMetadata,
 			invalidateDatabaseMetadata: () => null,
 		})
 		schema = modificationHandler.getSchemaUpdater()({ schema })
@@ -79,7 +86,7 @@ export function testGenerateSql(original: Partial<Schema>, diff: Migration.Modif
 	assert.equal(actual, expectedSql)
 }
 
-export function testMigrations(title: string, { original, updated, diff, noDiff, sql }: TestContext) {
+export function testMigrations(title: string, { original, updated, diff, noDiff, sql, databaseMetadata }: TestContext) {
 	describe(title, () => {
 		it('diff schemas', () => {
 			if (noDiff) {
@@ -91,7 +98,7 @@ export function testMigrations(title: string, { original, updated, diff, noDiff,
 			testApplyDiff(original, updated, diff)
 		})
 		it('generate sql', () => {
-			testGenerateSql(original, diff, sql)
+			testGenerateSql(original, diff, sql, databaseMetadata)
 		})
 	})
 }