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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "1.4.0-alpha.1",
+  "version": "1.4.0-alpha.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -12,16 +12,16 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@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",
+    "@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.4.0-alpha.1"
+    "@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/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/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

@@ -61,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(
@@ -75,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/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

@@ -88,3 +88,45 @@ testMigrations('convert one has one to many has one relation with inverse side',
 	}),
 })
 
+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,
+		}],
+	}),
+})
+