@contember/schema-migrations 1.3.6 → 1.4.0-alpha.2

package/package.json

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

package/src/SchemaDiffer.ts

@@ -43,6 +43,7 @@ import { CreateTargetDiffer } from './modifications/actions/CreateTargetModifica
 import { RemoveTargetDiffer } from './modifications/actions/RemoveTargetModification'
 import { UpdateSettingsDiffer } from './modifications/settings'
 import { RemoveIndexNamesDiffer } from './modifications/upgrade/RemoveIndexNamesModification'
+import { ConvertOneHasManyToOneHasOneRelationDiffer } from './modifications/relations/ConvertOneHasManyToOneHasOneRelationModification'
 
 type DiffOptions = { skipRecreateValidation?: boolean; skipInitialSchemaValidation?: boolean }
 
@@ -69,6 +70,7 @@ export class SchemaDiffer {
 			new UpdateSettingsDiffer(),
 			new ConvertOneToManyRelationDiffer(),
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
+			new ConvertOneHasManyToOneHasOneRelationDiffer(),
 			new RemoveUniqueConstraintDiffer(),
 			new RemoveIndexDiffer(),
 			new RemoveViewDiffer(),

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/ModificationHandlerFactory.ts

@@ -36,6 +36,7 @@ import { removeTargetModification } from './actions/RemoveTargetModification'
 import { updateTargetModification } from './actions/UpdateTargetModification'
 import { updateEntityOrderByModification } from './entities/UpdateEntityOrderByModification'
 import { removeIndexNamesModification } from './upgrade/RemoveIndexNamesModification'
+import { convertOneHasManyToOneHasOneRelationModification } from './relations/ConvertOneHasManyToOneHasOneRelationModification'
 
 
 class ModificationHandlerFactory {
@@ -86,6 +87,7 @@ namespace ModificationHandlerFactory {
 		updateValidationSchemaModification,
 		patchValidationSchemaModification,
 		convertOneToManyRelationModification,
+		convertOneHasManyToOneHasOneRelationModification,
 		toggleEventLogModification,
 		toggleJunctionEventLogModification,
 		convertOneHasManyToManyHasManyRelationModification,

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/ConvertOneHasManyToOneHasOneRelationModification.ts

@@ -0,0 +1,145 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
+import { isOwningRelation } from '@contember/schema-utils'
+import { updateRelations } from '../utils/diffUtils'
+import { NoopModification } from '../NoopModification'
+import { updateFieldNameModification } from '../fields'
+import { wrapIdentifier } from '../../utils/dbHelpers'
+
+export class ConvertOneHasManyToOneHasOneRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToOneHasOneRelationModificationData> {
+	private subModification: ModificationHandler<any>
+
+	constructor(
+		private readonly data: ConvertOneHasManyToOneHasOneRelationModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {
+		const { relation } = this.getRelation()
+		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
+			updateFieldNameModification.createHandler(
+				{
+					entityName: relation.target,
+					fieldName: relation.inversedBy,
+					newFieldName: data.newInverseSideFieldName,
+				},
+				schema,
+				this.options,
+			)
+			: new NoopModification()
+	}
+
+	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
+		const { entity, relation } = this.getRelation()
+		const columnName = relation.joiningColumn.columnName
+
+		const tableNameId = wrapIdentifier(entity.tableName)
+		const columnNameId = wrapIdentifier(columnName)
+
+		const uniqueConstraintNames = options.databaseMetadata.indexes.filter({
+			tableName: entity.tableName,
+			columnNames: [columnName],
+		}).getNames()
+
+		for (const name of uniqueConstraintNames) {
+			builder.sql(`DROP INDEX ${wrapIdentifier(name)}`)
+		}
+		builder.sql(`ALTER TABLE ${tableNameId} ADD UNIQUE (${columnNameId})`)
+
+		options.invalidateDatabaseMetadata()
+
+		this.subModification.createSql(builder, options)
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { relation } = this.getRelation()
+		const { entityName, fieldName } = this.data
+		const inverseFieldName = this.data.newInverseSideFieldName ?? relation.inversedBy
+		return updateSchema(
+			updateModel(
+				updateEntity(
+					entityName,
+					updateField<Model.ManyHasOneRelation, Model.OneHasOneOwningRelation>(
+						fieldName,
+						({ field: { type, ...field } }) => ({
+							type: Model.RelationType.OneHasOne,
+							...field,
+						}),
+					),
+				),
+			),
+			this.subModification.getSchemaUpdater(),
+			inverseFieldName ?
+				updateModel(
+					updateEntity(
+						relation.target,
+						updateField<Model.OneHasManyRelation, Model.OneHasOneInverseRelation>(
+							inverseFieldName,
+							({ field: { type, ...field } }) => ({
+								type: Model.RelationType.OneHasOne,
+								nullable: true,
+								...field,
+							}),
+						),
+					),
+				) : undefined,
+		)
+	}
+
+	describe() {
+		return {
+			message: `Converts ManyHasOne relation to OneHasOne on ${this.data.entityName}.${this.data.fieldName}`,
+			failureWarning: 'Make sure no conflicting rows exists, otherwise this may fail in runtime.',
+		}
+	}
+
+	private getRelation() {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (relation.type !== Model.RelationType.ManyHasOne) {
+			throw new Error()
+		}
+		return { entity, relation }
+	}
+}
+
+export interface ConvertOneHasManyToOneHasOneRelationModificationData {
+	entityName: string
+	fieldName: string
+	newInverseSideFieldName?: string
+}
+
+export const convertOneHasManyToOneHasOneRelationModification = createModificationType({
+	id: 'convertOneHasManyToOneHasOneRelation',
+	handler: ConvertOneHasManyToOneHasOneRelationModificationHandler,
+})
+
+export class ConvertOneHasManyToOneHasOneRelationDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
+			if (
+				isOwningRelation(originalRelation) &&
+				isOwningRelation(updatedRelation) &&
+				originalRelation.type === Model.RelationType.ManyHasOne &&
+				updatedRelation.type === Model.RelationType.OneHasOne
+			) {
+				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
+				return convertOneHasManyToOneHasOneRelationModification.createModification({
+					entityName: updatedEntity.name,
+					fieldName: updatedRelation.name,
+					...(isInverseSideRenamed ? {
+						newInverseSideFieldName: updatedRelation.inversedBy,
+					} : {}),
+				})
+			}
+			return undefined
+		})
+	}
+}

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)}`)
 		}
@@ -60,6 +61,7 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 		const { relation } = this.getRelation()
 		const { entityName, fieldName } = this.data
 
+		const inverseFieldName = this.data.newInverseSideFieldName ?? relation.inversedBy
 		return updateSchema(
 			updateModel(
 				updateEntity(
@@ -74,12 +76,12 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 				),
 			),
 			this.subModification.getSchemaUpdater(),
-			this.data.newInverseSideFieldName ?
+			inverseFieldName ?
 				updateModel(
 					updateEntity(
 						relation.target,
 						updateField<Model.OneHasOneInverseRelation, Model.OneHasManyRelation>(
-							this.data.newInverseSideFieldName,
+							inverseFieldName,
 							({ field: { type,  nullable, ...field } }) => ({
 								type: Model.RelationType.OneHasMany,
 								...field,

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/convertManyHasOneToOneHasOneRelation.test.ts

@@ -0,0 +1,48 @@
+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 ConvertMHOtoOHOSchemaOrig {
+	export class Article {
+		title = def.stringColumn()
+		reviews = def.oneHasMany(ArticleReview, 'article')
+	}
+
+	export class ArticleReview {
+		article = def.manyHasOne(Article, 'reviews')
+	}
+}
+
+namespace ConvertMHOtoOHOSchemaUpdated {
+	export class Article {
+		title = def.stringColumn()
+		review = def.oneHasOneInverse(ArticleReview, 'article')
+	}
+
+	export class ArticleReview {
+		article = def.oneHasOne(Article, 'review')
+	}
+}
+
+
+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',
+		}],
+		uniqueConstraints: [],
+	}),
+})

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,58 @@ 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,
+		}],
+	}),
+})
+
+testMigrations('convert one has one to many has one relation with inverse side, but not renamed', {
+	original: {
+		model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.oneHasOne('image', rel => rel.target('Image').inversedBy('posts')),
+			)
+			.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').inversedBy('posts')),
+			)
+			.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,
+		}],
+	}),
 })
 

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: [],
+	}),
 })