@contember/schema-migrations 2.1.0-rc.3 → 2.2.0-alpha.10

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -1,10 +1,19 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler.js'
 import deepEqual from 'fast-deep-equal'
-import { getIndexColumns } from './utils'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+import { getIndexColumns } from './utils.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
+
+type IndexIdentity = Pick<Model.Index, 'fields' | 'where' | 'include' | 'columnOptions' | 'method' | 'opClass'>
+const indexIdentityEquals = (a: IndexIdentity, b: IndexIdentity) =>
+	deepEqual(a.fields, b.fields)
+	&& (a.where ?? undefined) === (b.where ?? undefined)
+	&& deepEqual(a.include ?? undefined, b.include ?? undefined)
+	&& deepEqual(a.columnOptions ?? undefined, b.columnOptions ?? undefined)
+	&& (a.method ?? undefined) === (b.method ?? undefined)
+	&& (a.opClass ?? undefined) === (b.opClass ?? undefined)
 
 export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData> {
 	constructor(private readonly data: RemoveIndexModificationData, private readonly schema: Schema) {}
@@ -14,16 +23,38 @@ export class RemoveIndexModificationHandler implements ModificationHandler<Remov
 		if (entity.view && !entity.view.materialized) {
 			return
 		}
-		const fields = this.getFields()
+		const index = this.getIndex()
 
-		const columns = getIndexColumns({
-			entity,
-			fields,
-			model: this.schema.model,
-		})
+		// The DB-metadata layer (DatabaseMetadataResolver) exposes only table + columns (as an unordered
+		// set) + uniqueness, so the physical DROP is matched by table + columns. Postgres' pg_index.indkey
+		// includes the INCLUDE columns alongside the key columns, so a covering index's metadata lists both —
+		// we match the same combined set here. Everything else that distinguishes two indexes on the same
+		// column set — the partial WHERE predicate, per-column options (sort order / NULLS / operator class),
+		// key-column ORDER (the set comparison is order-insensitive), the index method, and the index-level
+		// operator class — is invisible to the metadata, so such siblings are indistinguishable here. We
+		// detect that ambiguity below and fail loudly rather than DROP a sibling the schema still expects to
+		// keep. Schema-level identity (see getSchemaUpdater) IS fully aware of these discriminators, so the
+		// diff itself never conflates them.
+		const columns = [
+			...getIndexColumns({ entity, fields: index.fields, model: this.schema.model }),
+			...(index.include ? getIndexColumns({ entity, fields: index.include, model: this.schema.model }) : []),
+		]
 
 		const indexNames = databaseMetadata.indexes.filter({ tableName: entity.tableName, columnNames: columns, unique: false }).getNames()
 
+		// If more than one physical index matches these columns we cannot tell which one this modification
+		// targets (the metadata hides the predicate / per-column options / column order / index method /
+		// index-level operator class that distinguish them). Dropping every match would silently take out an
+		// index the schema still expects — refuse instead, so the obsolete one can be dropped by hand.
+		if (indexNames.length > 1) {
+			throw new Error(
+				`Cannot unambiguously drop index on entity ${this.data.entityName} (${index.fields.join(', ')}): `
+					+ `${indexNames.length} indexes match these columns and the database metadata does not expose the predicate (where), `
+					+ `per-column options (sort order / NULLS / operator class), column order, index method or index-level operator class that distinguish them. `
+					+ `Drop the obsolete index manually.`,
+			)
+		}
+
 		for (const name of indexNames) {
 			builder.sql(`DROP INDEX ${wrapIdentifier(name)}`)
 		}
@@ -31,10 +62,10 @@ export class RemoveIndexModificationHandler implements ModificationHandler<Remov
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		const fields = this.getFields()
+		const index = this.getIndex()
 		return updateModel(
 			updateEntity(this.data.entityName, ({ entity }) => {
-				const indexes = entity.indexes.filter(it => !deepEqual(it.fields, fields))
+				const indexes = entity.indexes.filter(it => !indexIdentityEquals(it, index))
 				return {
 					...entity,
 					indexes,
@@ -44,19 +75,38 @@ export class RemoveIndexModificationHandler implements ModificationHandler<Remov
 	}
 
 	describe() {
-		const fields = this.getFields()
-		return { message: `Remove index (${fields.join(', ')}) on entity ${this.data.entityName}` }
+		const index = this.getIndex()
+		return { message: `Remove index (${index.fields.join(', ')}) on entity ${this.data.entityName}` }
 	}
 
-	getFields() {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const fields = 'indexName' in this.data
-			? entity.indexes.find(it => it.name === this.data.indexName)?.fields
-			: this.data.fields
-		if (!fields) {
-			throw new Error()
+	private getIndex(): IndexIdentity {
+		const { entityName } = this.data
+		const entity = this.schema.model.entities[entityName]
+		if ('indexName' in this.data && this.data.indexName !== undefined) {
+			const index = entity.indexes.find(it => it.name === this.data.indexName)
+			if (!index) {
+				throw new Error(`Index named "${this.data.indexName}" not found on entity ${entityName}`)
+			}
+			return {
+				fields: index.fields,
+				where: index.where,
+				include: index.include,
+				columnOptions: index.columnOptions,
+				method: index.method,
+				opClass: index.opClass,
+			}
+		}
+		if (!this.data.fields) {
+			throw new Error(`removeIndex modification on entity ${entityName} requires either "indexName" or "fields"`)
+		}
+		return {
+			fields: this.data.fields,
+			where: this.data.where,
+			include: this.data.include,
+			columnOptions: this.data.columnOptions,
+			method: this.data.method,
+			opClass: this.data.opClass,
 		}
-		return fields
 	}
 }
 
@@ -70,10 +120,20 @@ export type RemoveIndexModificationData =
 		entityName: string
 		indexName: string
 		fields?: never
+		where?: never
+		include?: never
+		columnOptions?: never
+		method?: never
+		opClass?: never
 	}
 	| {
 		entityName: string
 		fields: readonly string[]
+		where?: string
+		include?: readonly string[]
+		columnOptions?: { readonly [field: string]: Model.IndexColumnOptions }
+		method?: Model.IndexMethod
+		opClass?: string
 		indexName?: never
 	}
 
@@ -94,6 +154,15 @@ export class RemoveIndexDiffer implements Differ {
 					removeIndexModification.createModification({
 						entityName: entity.name,
 						fields: index.fields,
+						// keep every identity-bearing option (WHERE/INCLUDE/columnOptions/method/opClass) in the
+						// modification so indexes that share the same key columns but differ by any of them are
+						// removed individually; omit the keys when absent to keep legacy migration JSON
+						// byte-for-byte identical.
+						...(index.where !== undefined ? { where: index.where } : {}),
+						...(index.include !== undefined ? { include: index.include } : {}),
+						...(index.columnOptions !== undefined ? { columnOptions: index.columnOptions } : {}),
+						...(index.method !== undefined ? { method: index.method } : {}),
+						...(index.opClass !== undefined ? { opClass: index.opClass } : {}),
 					})
 				)
 		)

package/src/modifications/indexes/index.ts

@@ -1,2 +1,2 @@
-export * from './CreateIndexModification'
-export * from './RemoveIndexModification'
+export * from './CreateIndexModification.js'
+export * from './RemoveIndexModification.js'

package/src/modifications/relations/ConvertManyHasManyToJoiningEntityModification.ts

@@ -0,0 +1,218 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { addField, removeField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils.js'
+import {
+	createModificationType,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+	ModificationHandlerOptions,
+} from '../ModificationHandler.js'
+import { createEventTrigger, createEventTrxTrigger, dropEventTrigger, dropEventTrxTrigger } from '../utils/sqlUpdateUtils.js'
+import { getColumnSqlType } from '../utils/columnUtils.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
+import { VERSION_LATEST } from '../ModificationVersions.js'
+import { PossibleEntityShapeInMigrations } from '../../utils/PartialEntity.js'
+
+/**
+ * Promotes an implicit many-has-many relation (backed by a junction table with a composite primary key)
+ * into an explicit joining entity, while preserving all existing rows in the junction table.
+ *
+ * The junction table is reused in place — no data is copied:
+ *  - a surrogate `id` (uuid) primary key column is added and back-filled (see {@link uuidGenerator}),
+ *  - the original composite primary key is dropped and the new `id` becomes the primary key,
+ *  - both foreign-key columns are kept and become two many-has-one relations of the new entity,
+ *  - the `log_event` trigger is re-pointed from the two foreign-key columns onto the new `id` column
+ *    (both event-log triggers are dropped up-front and re-created afterwards).
+ *
+ * The original many-has-many owning relation (and its inverse side, if any) is removed from the schema.
+ *
+ * Limitations / requirements:
+ *  - The junction table is assumed to use the standard composite primary key produced by Contember.
+ *  - UUID back-filling uses a pure-SQL `uuid_generate_v4()` function in the project's system schema,
+ *    which the migration creates on the fly if missing (see {@link ensureUuidGenerator}). No
+ *    PostgreSQL extension is created by this migration.
+ */
+export class ConvertManyHasManyToJoiningEntityModificationHandler implements ModificationHandler<ConvertManyHasManyToJoiningEntityModificationData> {
+	constructor(
+		private readonly data: ConvertManyHasManyToJoiningEntityModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {}
+
+	public createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void {
+		const { relation } = this.getRelation()
+		const joiningTable = relation.joiningTable
+		const tableName = joiningTable.tableName
+		const tableNameId = wrapIdentifier(tableName)
+
+		const joiningEntity = this.data.joiningEntity
+		const primaryColumn = joiningEntity.fields[joiningEntity.primary] as Model.AnyColumn
+		const primaryColumnName = primaryColumn.columnName
+		const primaryColumnNameId = wrapIdentifier(primaryColumnName)
+		const primaryColumnType = getColumnSqlType(primaryColumn)
+
+		// Drop BOTH event-log triggers before touching the table.
+		// The deferred `log_event_trx` constraint trigger must go too: otherwise the back-fill UPDATE
+		// below queues pending deferred trigger events, and PostgreSQL then rejects the subsequent
+		// `ALTER TABLE` with "cannot ALTER TABLE because it has pending trigger events". Both are
+		// re-created at the end, so there is no duplicate-trigger conflict either.
+		if (joiningTable.eventLog.enabled) {
+			dropEventTrigger(builder, tableName)
+			dropEventTrxTrigger(builder, tableName)
+		}
+
+		// Add the surrogate primary key and back-fill it for existing rows.
+		builder.sql(`ALTER TABLE ${tableNameId} ADD COLUMN ${primaryColumnNameId} ${primaryColumnType}`)
+		builder.sql(ensureUuidGenerator(systemSchema))
+		builder.sql(`UPDATE ${tableNameId} SET ${primaryColumnNameId} = ${uuidGenerator(systemSchema)}`)
+		builder.sql(`ALTER TABLE ${tableNameId} ALTER COLUMN ${primaryColumnNameId} SET NOT NULL`)
+
+		// Replace the composite primary key with the surrogate one.
+		builder.sql(`ALTER TABLE ${tableNameId} DROP CONSTRAINT ${wrapIdentifier(`${tableName}_pkey`)}`)
+		builder.sql(`ALTER TABLE ${tableNameId} ADD PRIMARY KEY (${primaryColumnNameId})`)
+
+		// The original join uniqueness is no longer enforced by the (now surrogate) primary key.
+		builder.sql(
+			`ALTER TABLE ${tableNameId} ADD UNIQUE (${wrapIdentifier(joiningTable.joiningColumn.columnName)}, ${
+				wrapIdentifier(joiningTable.inverseJoiningColumn.columnName)
+			})`,
+		)
+
+		// Re-create both triggers: `log_event` is now re-pointed onto the surrogate primary key,
+		// `log_event_trx` is restored unchanged (it takes no column params).
+		if (joiningEntity.eventLog?.enabled !== false) {
+			createEventTrigger(builder, systemSchema, tableName, [primaryColumnName])
+			createEventTrxTrigger(builder, systemSchema, tableName)
+		}
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { entity, relation } = this.getRelation()
+		const version = this.options.formatVersion ?? VERSION_LATEST
+		const joiningEntity = this.data.joiningEntity
+		const joinUniqueConstraint = this.getJoinUniqueConstraint()
+
+		return updateSchema(
+			// remove the original many-has-many (owning side + inverse side)
+			removeField(entity.name, relation.name, version),
+			// register the new joining entity reusing the junction table
+			updateModel(({ model }) => ({
+				...model,
+				entities: {
+					...model.entities,
+					[joiningEntity.name]: {
+						eventLog: { enabled: true },
+						...joiningEntity,
+						// Keep the schema in sync with the join-uniqueness constraint emitted by createSql.
+						unique: [...Object.values(joiningEntity.unique ?? []), joinUniqueConstraint],
+						indexes: Object.values(joiningEntity.indexes ?? []),
+					},
+				},
+			})),
+			// add inverse one-has-many relations on both connected entities
+			this.data.sourceInverseSide
+				? updateModel(updateEntity(entity.name, addField(this.data.sourceInverseSide)))
+				: undefined,
+			this.data.targetInverseSide
+				? updateModel(updateEntity(relation.target, addField(this.data.targetInverseSide)))
+				: undefined,
+		)
+	}
+
+	describe() {
+		return {
+			message: `Converts ManyHasMany relation ${this.data.entityName}.${this.data.fieldName} to a joining entity ${this.data.joiningEntity.name}`,
+		}
+	}
+
+	/**
+	 * The join-uniqueness constraint (relationA, relationB) that replaces the dropped composite
+	 * primary key. The field names are resolved from the joining entity's two many-has-one relations
+	 * by matching their joining columns against the original junction columns, so the constraint
+	 * references schema field names (not raw column names).
+	 */
+	private getJoinUniqueConstraint(): Model.UniqueConstraint {
+		const { relation } = this.getRelation()
+		const joiningTable = relation.joiningTable
+		const joiningEntity = this.data.joiningEntity
+
+		const findRelationField = (columnName: string): string => {
+			const field = Object.values(joiningEntity.fields).find((it): it is Model.AnyRelation & Model.JoiningColumnRelation =>
+				'joiningColumn' in it && (it as Model.JoiningColumnRelation).joiningColumn.columnName === columnName
+			)
+			if (!field) {
+				throw new Error(
+					`Joining entity ${joiningEntity.name} has no many-has-one relation mapped to column ${columnName}`,
+				)
+			}
+			return field.name
+		}
+
+		return {
+			fields: [
+				findRelationField(joiningTable.joiningColumn.columnName),
+				findRelationField(joiningTable.inverseJoiningColumn.columnName),
+			],
+		}
+	}
+
+	private getRelation(): { entity: Model.Entity; relation: Model.ManyHasManyOwningRelation } {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (!relation || relation.type !== Model.RelationType.ManyHasMany || !('joiningTable' in relation)) {
+			throw new Error(`${this.data.entityName}.${this.data.fieldName} is not a many-has-many owning relation`)
+		}
+		return { entity, relation: relation as Model.ManyHasManyOwningRelation }
+	}
+}
+
+/**
+ * UUIDs are back-filled with a pure-SQL `uuid_generate_v4()` function kept in the project's system
+ * schema, so no PostgreSQL extension is ever created. The function cannot be assumed to exist:
+ * Contember's system migrations only materialize it on databases where `pg_catalog.gen_random_uuid`
+ * is unavailable (i.e. PostgreSQL < 13), so on modern servers `system.uuid_generate_v4()` is absent.
+ * {@link ensureUuidGenerator} therefore (idempotently) creates it in the system schema up-front. It
+ * must be referenced through the system schema — it is not in `public` nor on the stage search_path.
+ */
+const uuidGenerator = (systemSchema: string) => `${wrapIdentifier(systemSchema)}."uuid_generate_v4"()`
+
+/**
+ * Idempotently materialize the pure-SQL `uuid_generate_v4()` function in the system schema. The body
+ * matches the one Contember's `trigger-event-function` system migration installs, so the same
+ * extension-free UUID generator is reused everywhere. Wrapped in a guard so re-running (or running on
+ * a database where it already exists) is a no-op.
+ */
+const ensureUuidGenerator = (systemSchema: string) => {
+	const systemSchemaId = wrapIdentifier(systemSchema)
+	return `DO $ensure_uuid$
+BEGIN
+	IF NOT EXISTS(
+		SELECT FROM pg_proc
+		JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid
+		WHERE pg_namespace.nspname = ${quoteLiteral(systemSchema)} AND pg_proc.proname = 'uuid_generate_v4'
+	) THEN
+		CREATE FUNCTION ${systemSchemaId}."uuid_generate_v4"() RETURNS "uuid"
+		LANGUAGE "sql"
+		AS $ensure_uuid_body$
+			SELECT OVERLAY(OVERLAY(md5(random()::TEXT || ':' || clock_timestamp()::TEXT) PLACING '4' FROM 13) PLACING
+				to_hex(floor(random() * (11 - 8 + 1) + 8)::INT)::TEXT FROM 17)::UUID;
+		$ensure_uuid_body$;
+	END IF;
+END
+$ensure_uuid$;`
+}
+
+const quoteLiteral = (value: string) => `'${value.replace(/'/g, "''")}'`
+
+export const convertManyHasManyToJoiningEntityModification = createModificationType({
+	id: 'convertManyHasManyToJoiningEntity',
+	handler: ConvertManyHasManyToJoiningEntityModificationHandler,
+})
+
+export interface ConvertManyHasManyToJoiningEntityModificationData {
+	entityName: string
+	fieldName: string
+	joiningEntity: PossibleEntityShapeInMigrations
+	sourceInverseSide?: Model.OneHasManyRelation
+	targetInverseSide?: Model.OneHasManyRelation
+}

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -1,19 +1,19 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils.js'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
 	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
-} from '../ModificationHandler'
+} from '../ModificationHandler.js'
 import { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
-import { createJunctionTableSql } from '../utils/createJunctionTable'
-import { wrapIdentifier } from '../../utils/dbHelpers'
-import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
-import { updateFieldNameModification } from '../fields'
+import { updateRelations } from '../utils/diffUtils.js'
+import { createJunctionTableSql } from '../utils/createJunctionTable.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
+import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization.js'
+import { updateFieldNameModification } from '../fields/index.js'
 
 export class ConvertOneHasManyToManyHasManyRelationModificationHandler
 	implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData>

package/src/modifications/relations/ConvertOneHasManyToOneHasOneRelationModification.ts

@@ -1,18 +1,18 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils.js'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
 	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
-} from '../ModificationHandler'
+} from '../ModificationHandler.js'
 import { isOwningRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
-import { NoopModification } from '../NoopModification'
-import { updateFieldNameModification } from '../fields'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+import { updateRelations } from '../utils/diffUtils.js'
+import { NoopModification } from '../NoopModification.js'
+import { updateFieldNameModification } from '../fields/index.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 
 export class ConvertOneHasManyToOneHasOneRelationModificationHandler
 	implements ModificationHandler<ConvertOneHasManyToOneHasOneRelationModificationData>

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,18 +1,18 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils.js'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
 	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
-} from '../ModificationHandler'
+} from '../ModificationHandler.js'
 import { isOwningRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
-import { NoopModification } from '../NoopModification'
-import { updateFieldNameModification } from '../fields'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+import { updateRelations } from '../utils/diffUtils.js'
+import { NoopModification } from '../NoopModification.js'
+import { updateFieldNameModification } from '../fields/index.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 
 export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>

package/src/modifications/relations/CreateRelationInverseSideModification.ts

@@ -1,7 +1,7 @@
 import { Model, Schema } from '@contember/schema'
-import { addField, SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
-import { createFields } from '../utils/diffUtils'
+import { addField, SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
+import { createFields } from '../utils/diffUtils.js'
 import { isInverseRelation, isRelation } from '@contember/schema-utils'
 
 export class CreateRelationInverseSideModificationHandler implements ModificationHandler<CreateRelationInverseSideModificationData> {

package/src/modifications/relations/CreateRelationModification.ts

@@ -1,21 +1,21 @@
 import { Model, Schema } from '@contember/schema'
 import { acceptRelationTypeVisitor, isInverseRelation, isOwningRelation, isRelation } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils.js'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
 	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
-} from '../ModificationHandler'
-import { isIt } from '../../utils/isIt'
-import { createFields } from '../utils/diffUtils'
-import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
-import { createJunctionTableSql } from '../utils/createJunctionTable'
-import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
-import { addForeignKeyConstraint } from './helpers'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+} from '../ModificationHandler.js'
+import { isIt } from '../../utils/isIt.js'
+import { createFields } from '../utils/diffUtils.js'
+import { getPrimaryColumnType } from '../utils/getPrimaryColumnType.js'
+import { createJunctionTableSql } from '../utils/createJunctionTable.js'
+import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization.js'
+import { addForeignKeyConstraint } from './helpers.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
 	constructor(

package/src/modifications/relations/DisableOrphanRemovalModification.ts

@@ -1,8 +1,8 @@
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import { isOwningRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
+import { updateRelations } from '../utils/diffUtils.js'
 
 export class DisableOrphanRemovalModificationHandler implements ModificationHandler<DisableOrphanRemovalModificationData> {
 	constructor(private readonly data: DisableOrphanRemovalModificationData, private readonly schema: Schema) {}

package/src/modifications/relations/EnableOrphanRemovalModification.ts

@@ -1,8 +1,8 @@
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import { isOwningRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
+import { updateRelations } from '../utils/diffUtils.js'
 
 export class EnableOrphanRemovalModificationHandler implements ModificationHandler<EnableOrphanRemovalModificationData> {
 	constructor(private readonly data: EnableOrphanRemovalModificationData, private readonly schema: Schema) {}

package/src/modifications/relations/MakeRelationNotNullModification.ts

@@ -1,10 +1,10 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
-import { isIt } from '../../utils/isIt'
-import { updateRelations } from '../utils/diffUtils'
+import { isIt } from '../../utils/isIt.js'
+import { updateRelations } from '../utils/diffUtils.js'
 
 export class MakeRelationNotNullModificationHandler implements ModificationHandler<MakeRelationNotNullModificationData> {
 	constructor(private readonly data: MakeRelationNotNullModificationData, private readonly schema: Schema) {}

package/src/modifications/relations/MakeRelationNullableModification.ts

@@ -1,10 +1,10 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
-import { isIt } from '../../utils/isIt'
-import { updateRelations } from '../utils/diffUtils'
+import { isIt } from '../../utils/isIt.js'
+import { updateRelations } from '../utils/diffUtils.js'
 
 export class MakeRelationNullableModificationHandler implements ModificationHandler<MakeRelationNullableModificationData> {
 	constructor(private readonly data: MakeRelationNullableModificationData, private readonly schema: Schema) {}

package/src/modifications/relations/ToggleJunctionEventLogModification.ts

@@ -1,11 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
-import { createEventTrigger, createEventTrxTrigger, dropEventTrigger, dropEventTrxTrigger } from '../utils/sqlUpdateUtils'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler.js'
+import { createEventTrigger, createEventTrxTrigger, dropEventTrigger, dropEventTrxTrigger } from '../utils/sqlUpdateUtils.js'
 import { isOwningRelation, isRelation } from '@contember/schema-utils'
-import { updateRelations } from '../utils/diffUtils'
-import { isIt } from '../../utils/isIt'
+import { updateRelations } from '../utils/diffUtils.js'
+import { isIt } from '../../utils/isIt.js'
 
 export class ToggleJunctionEventLogModificationHandler implements ModificationHandler<ToggleJunctionEventLogModificationData> {
 	constructor(

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -1,11 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
-import { isIt } from '../../utils/isIt'
-import { updateRelations } from '../utils/diffUtils'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler.js'
+import { isIt } from '../../utils/isIt.js'
+import { updateRelations } from '../utils/diffUtils.js'
 import { acceptRelationTypeVisitor } from '@contember/schema-utils'
-import { addForeignKeyConstraint } from './helpers'
+import { addForeignKeyConstraint } from './helpers.js'
 
 export class UpdateRelationOnDeleteModificationHandler implements ModificationHandler<UpdateRelationOnDeleteModificationData> {
 	constructor(

package/src/modifications/relations/UpdateRelationOrderByModification.ts

@@ -1,8 +1,8 @@
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import deepEqual from 'fast-deep-equal'
-import { updateRelations } from '../utils/diffUtils'
+import { updateRelations } from '../utils/diffUtils.js'
 
 export class UpdateRelationOrderByModificationHandler implements ModificationHandler<UpdateRelationOrderByModificationData> {
 	constructor(private readonly data: UpdateRelationOrderByModificationData, private readonly schema: Schema) {}

package/src/modifications/relations/helpers.ts

@@ -1,6 +1,6 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model } from '@contember/schema'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 import { DatabaseMetadata } from '@contember/database'
 
 export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntity, recreate = false, databaseMetadata, invalidateDatabaseMetadata }: {