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

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 }: {

package/src/modifications/relations/index.ts

@@ -1,11 +1,12 @@
-export * from './ConvertOneHasManyToManyHasManyRelationModification'
-export * from './ConvertOneToManyRelationModification'
-export * from './CreateRelationInverseSideModification'
-export * from './CreateRelationModification'
-export * from './DisableOrphanRemovalModification'
-export * from './EnableOrphanRemovalModification'
-export * from './MakeRelationNotNullModification'
-export * from './MakeRelationNullableModification'
-export * from './ToggleJunctionEventLogModification'
-export * from './UpdateRelationOnDeleteModification'
-export * from './UpdateRelationOrderByModification'
+export * from './ConvertManyHasManyToJoiningEntityModification.js'
+export * from './ConvertOneHasManyToManyHasManyRelationModification.js'
+export * from './ConvertOneToManyRelationModification.js'
+export * from './CreateRelationInverseSideModification.js'
+export * from './CreateRelationModification.js'
+export * from './DisableOrphanRemovalModification.js'
+export * from './EnableOrphanRemovalModification.js'
+export * from './MakeRelationNotNullModification.js'
+export * from './MakeRelationNullableModification.js'
+export * from './ToggleJunctionEventLogModification.js'
+export * from './UpdateRelationOnDeleteModification.js'
+export * from './UpdateRelationOrderByModification.js'

package/src/modifications/settings/UpdateSettingsModification.ts

@@ -1,6 +1,6 @@
 import { Schema, Settings } from '@contember/schema'
-import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import deepEqual from 'fast-deep-equal'
 
 export class UpdateSettingsModificationHandler implements ModificationHandler<UpdateSettingsModificationData> {

package/src/modifications/settings/index.ts

@@ -1 +1 @@
-export * from './UpdateSettingsModification'
+export * from './UpdateSettingsModification.js'

package/src/modifications/upgrade/RemoveIndexNamesModification.ts

@@ -1,6 +1,6 @@
 import { Schema } from '@contember/schema'
-import { SchemaUpdater, updateEveryEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater, updateEveryEntity, updateModel } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 
 export class RemoveIndexNamesModificationHandler implements ModificationHandler<RemoveIndexNamesModificationData> {
 	public createSql(): void {

package/src/modifications/utils/createJunctionTable.ts

@@ -1,8 +1,8 @@
-import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
+import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils.js'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { getPrimaryColumnType } from './getPrimaryColumnType'
-import { wrapIdentifier } from '../../utils/dbHelpers'
+import { getPrimaryColumnType } from './getPrimaryColumnType.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 
 export const createJunctionTableSql = (
 	builder: MigrationBuilder,

package/src/modifications/utils/diffUtils.ts

@@ -1,7 +1,7 @@
 import { Model, Schema } from '@contember/schema'
-import { Migration } from '../../Migration'
+import { Migration } from '../../Migration.js'
 import { isColumn, isRelation } from '@contember/schema-utils'
-import { isDefined } from '../../utils/isDefined'
+import { isDefined } from '../../utils/isDefined.js'
 import deepEqual from 'fast-deep-equal'
 
 export const updateFields = <Data = { [field: string]: any }>(

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -1,8 +1,8 @@
 import { Acl, Model, Schema, Writable } from '@contember/schema'
-import { SchemaUpdateError } from '../exceptions'
-import { isDefined } from '../../utils/isDefined'
+import { SchemaUpdateError } from '../exceptions.js'
+import { isDefined } from '../../utils/isDefined.js'
 import { isInverseRelation, isOwningRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
-import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
+import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions.js'
 
 export type SchemaUpdater = (args: { schema: Schema }) => Schema
 export type ModelUpdater = (args: { schema: Schema; model: Model.Schema }) => Model.Schema

package/src/modifications/utils/viewDependencies.ts

@@ -1,6 +1,30 @@
 import { Model } from '@contember/schema'
-import { Migration } from '../../Migration'
-import { removeEntityModification } from '../entities'
+import deepEqual from 'fast-deep-equal'
+import { Migration } from '../../Migration.js'
+import { removeEntityModification } from '../entities/index.js'
+
+/**
+ * Determines whether a view change can be applied in-place via `CREATE OR REPLACE VIEW`,
+ * i.e. without dropping & recreating the view (and cascading to its dependants).
+ *
+ * Postgres allows `CREATE OR REPLACE VIEW` only when the output columns stay the same
+ * (it may append new columns at the end). We conservatively allow it only when the
+ * entity is structurally identical and just the view metadata (`sql`/`dependencies`/`idSource`)
+ * differs. Materialized views are never replaceable (no `CREATE OR REPLACE MATERIALIZED VIEW`).
+ */
+export const isReplaceableViewChange = (original: Model.Entity, updated: Model.Entity): boolean => {
+	if (!original.view || !updated.view) {
+		return false
+	}
+	if (original.view.materialized || updated.view.materialized) {
+		return false
+	}
+	const stripView = (entity: Model.Entity): Omit<Model.Entity, 'view'> => {
+		const { view, ...rest } = entity
+		return rest
+	}
+	return deepEqual(stripView(original), stripView(updated))
+}
 
 type EntityDependantViews = Map<string, Set<Model.Entity>>
 export const getEntityDependantViews = (model: Model.Schema): EntityDependantViews => {

package/src/modifications/validation/PatchValidationSchemaModification.ts

@@ -1,7 +1,7 @@
-import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { createModificationType, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, ModificationHandler } from '../ModificationHandler.js'
 import { applyPatch, Operation } from 'rfc6902'
-import deepCopy from '../../utils/deepCopy'
+import deepCopy from '../../utils/deepCopy.js'
 
 export class PatchValidationSchemaModificationHandler implements ModificationHandler<PatchValidationSchemaModificationData> {
 	constructor(private readonly data: PatchValidationSchemaModificationData) {}

package/src/modifications/validation/UpdateValidationSchemaModification.ts

@@ -1,9 +1,9 @@
 import { Schema, Validation } from '@contember/schema'
-import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils.js'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler.js'
 import deepEqual from 'fast-deep-equal'
 import { createPatch } from 'rfc6902'
-import { patchValidationSchemaModification } from './PatchValidationSchemaModification'
+import { patchValidationSchemaModification } from './PatchValidationSchemaModification.js'
 
 export class UpdateValidationSchemaModificationHandler implements ModificationHandler<UpdateValidationSchemaModificationData> {
 	constructor(private readonly data: UpdateValidationSchemaModificationData) {}

package/src/modifications/validation/index.ts

@@ -1,2 +1,2 @@
-export * from './PatchValidationSchemaModification'
-export * from './UpdateValidationSchemaModification'
+export * from './PatchValidationSchemaModification.js'
+export * from './UpdateValidationSchemaModification.js'