@contember/cli 2.1.0-beta.2 → 2.2.0-alpha.2

package/src/lib/migrations/MigrationExecutionFacade.ts

@@ -1,12 +1,20 @@
 import prompts from 'prompts'
-import { MigrationPrinter } from './MigrationPrinter'
-import { isSchemaMigration, MigrationExecutor, MigrationToExecuteOkStatus, SchemaVersionBuilder } from '@contember/migrations-client'
-import { MigrationsStatusFacade } from './MigrationsStatusFacade'
+import { MigrationPrinter } from './MigrationPrinter.js'
+import {
+	isSchemaMigration,
+	MigrateErrorCode,
+	MigrationExecutor,
+	MigrationToExecuteOkStatus,
+	SchemaState,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+} from '@contember/migrations-client'
+import { MigrationsStatusFacade } from './MigrationsStatusFacade.js'
+import { MigrationSnapshotFacade } from './MigrationSnapshotFacade.js'
 import { MigrationVersionHelper } from '@contember/engine-common'
-import { RemoteProject } from '../project/RemoteProject'
-import { SystemClientProvider } from '../SystemClientProvider'
-import { TenantClientProvider } from '../TenantClientProvider'
-import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+import { SystemClientProvider } from '../SystemClientProvider.js'
+import { TenantClientProvider } from '../TenantClientProvider.js'
+import { RemoteProjectProvider } from '../project/RemoteProjectProvider.js'
 
 export class MigrationExecutionFacade {
 	constructor(
@@ -17,6 +25,8 @@ export class MigrationExecutionFacade {
 		private readonly migrationPrinter: MigrationPrinter,
 		private readonly migrationExecutor: MigrationExecutor,
 		private readonly migrationStatusFacade: MigrationsStatusFacade,
+		private readonly schemaStateManager: SchemaStateManager,
+		private readonly migrationSnapshotFacade: MigrationSnapshotFacade,
 	) {
 	}
 
@@ -25,28 +35,52 @@ export class MigrationExecutionFacade {
 		force,
 		until,
 		additionalMessage,
+		useSnapshot = true,
 	}: {
 		requireConfirmation: boolean | ((migrations: MigrationToExecuteOkStatus[]) => boolean)
 		force?: boolean
 		until?: string
 		additionalMessage?: string
+		useSnapshot?: boolean
 	}): Promise<boolean> => {
 		const project = this.projectProvider.get()
 		await this.tenantClientProvider.get().createProject(project.name, true)
 
+		const stateMode = await this.schemaStateManager.isStateMode()
+		let schemaState = stateMode ? await this.schemaStateManager.readState() : undefined
+
+		// The state files always reflect the latest schema. When migrating to an older version, that
+		// state may reference parts of the model that don't exist yet, so skip it rather than push an
+		// inconsistent overlay. Run `migrations:execute` without `--until` to sync the schema state.
+		if (until && schemaState) {
+			console.log(
+				'Warning: schema state was not applied because --until targets a specific migration; the state files reflect the latest schema. Run migrations:execute without --until to sync it.',
+			)
+			schemaState = undefined
+		}
+
+		if (useSnapshot) {
+			await this.tryApplySnapshot({ until, schemaState })
+		}
+
 		const status = await this.migrationStatusFacade.resolveMigrationsStatus({ force })
 		const migrations = until
 			? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(until))
 			: status.migrationsToExecute
-		if (migrations.length === 0) {
+		if (migrations.length === 0 && !schemaState) {
 			console.log('No migrations to execute')
 			return true
 		}
-		console.log('Will execute following migrations:')
-		migrations.forEach(it => console.log(it.name))
+		if (migrations.length > 0) {
+			console.log('Will execute following migrations:')
+			migrations.forEach(it => console.log(it.name))
+		}
+		if (schemaState && migrations.length === 0) {
+			console.log('Updating schema state')
+		}
 		additionalMessage && console.log(additionalMessage)
 
-		if (typeof requireConfirmation === 'function' ? requireConfirmation(migrations) : requireConfirmation) {
+		if (migrations.length > 0 && (typeof requireConfirmation === 'function' ? requireConfirmation(migrations) : requireConfirmation)) {
 			if (!process.stdin.isTTY) {
 				throw 'TTY not available. Pass --yes option to confirm execution.'
 			}
@@ -81,18 +115,78 @@ export class MigrationExecutionFacade {
 			} while (true)
 		}
 
-		await this.migrationExecutor.executeMigrations({
-			client: this.systemClientProvider.get(),
-			migrations,
-			contentMigrationFactoryArgs: {
-				apiToken: project.token,
-				apiBaseUrl: project.endpoint,
-				projectName: project.name,
-				schemaVersionBuilder: this.schemaVersionBuilder,
-			},
-			log: message => console.log(message),
-			force,
-		})
+		try {
+			await this.migrationExecutor.executeMigrations({
+				client: this.systemClientProvider.get(),
+				migrations,
+				schemaState,
+				contentMigrationFactoryArgs: {
+					apiToken: project.token,
+					apiBaseUrl: project.endpoint,
+					projectName: project.name,
+					schemaVersionBuilder: this.schemaVersionBuilder,
+				},
+				log: message => console.log(message),
+				force,
+			})
+		} catch (e) {
+			if (isViewReplaceFailure(e)) {
+				console.error(
+					"\nAn in-place view update (CREATE OR REPLACE VIEW) failed — Postgres rejects it (SQLSTATE 42P16) when a view's"
+						+ ' output columns changed (e.g. reordered or retyped) even though its fields did not.\n'
+						+ 'Re-generate the migration with `migrations:diff <name> --recreate-views` to drop & recreate the affected'
+						+ ' views (and their dependants) instead.\n',
+				)
+			}
+			throw e
+		}
 		return true
 	}
+
+	private async tryApplySnapshot({ until, schemaState }: { until?: string; schemaState?: SchemaState }): Promise<void> {
+		const executed = await this.systemClientProvider.get().listExecutedMigrations()
+		const snapshot = await this.migrationSnapshotFacade.getUsableSnapshot(executed)
+		if (!snapshot) {
+			return
+		}
+		if (until && snapshot.version > MigrationVersionHelper.extractVersion(until)) {
+			// snapshot reaches past the requested target — fall back to a normal replay
+			return
+		}
+		console.log(`Bootstrapping from snapshot (collapses ${snapshot.covers.length} migrations up to ${snapshot.version})`)
+		if (snapshot.contentMigrations.length > 0) {
+			console.warn(
+				`Note: ${snapshot.contentMigrations.length} content migration(s) are covered by the snapshot; their data is NOT reproduced.`,
+			)
+		}
+		const input = await this.migrationSnapshotFacade.buildSnapshotInput(snapshot)
+		try {
+			await this.systemClientProvider.get().migrateFromSnapshot(input, schemaState)
+		} catch (e) {
+			if (isProjectNotEmptyError(e)) {
+				// The project was migrated between our emptiness check and the server call (e.g. a
+				// concurrent execute on a fresh database). Fall back to a normal replay rather than
+				// crashing — the subsequent status resolution will pick up whatever is left to run.
+				console.warn('Snapshot skipped: the project is no longer empty. Falling back to a full replay.')
+				return
+			}
+			throw e
+		}
+		console.log('Snapshot applied')
+	}
 }
+
+const isProjectNotEmptyError = (e: unknown): boolean =>
+	Array.isArray(e) && e.some(it => it !== null && typeof it === 'object' && (it as { code?: unknown }).code === MigrateErrorCode.ProjectNotEmpty)
+
+// A failed `updateView` modification surfaces as MIGRATION_FAILED whose developerMessage embeds the failing
+// statement (`CREATE OR REPLACE VIEW …`). Since each modification's SQL is executed in isolation, that string
+// is a precise signal that an in-place view update — and not some other statement — is what Postgres rejected.
+const isViewReplaceFailure = (e: unknown): boolean =>
+	Array.isArray(e) && e.some(it =>
+		it !== null
+		&& typeof it === 'object'
+		&& (it as { code?: unknown }).code === MigrateErrorCode.MigrationFailed
+		&& typeof (it as { message?: unknown }).message === 'string'
+		&& (it as { message: string }).message.includes('CREATE OR REPLACE VIEW')
+	)

package/src/lib/migrations/MigrationPrinter.ts

@@ -5,7 +5,7 @@ import chalk from 'chalk'
 import { AnyMigrationStatus, Migration, MigrationDescriber, MigrationState } from '@contember/migrations-client'
 import { emptyDatabaseMetadata } from '@contember/database'
 import chalkTable from 'chalk-table'
-import { assertNever } from '../assertNever'
+import { assertNever } from '../assertNever.js'
 
 export class MigrationPrinter {
 	constructor(

package/src/lib/migrations/MigrationRebaseFacade.ts

@@ -1,8 +1,8 @@
-import { Migration, MigrationFilesManager, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
-import { MigrationsValidator } from './MigrationsValidator'
+import { Migration, MigrationFilesManager, SchemaStateManager, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
+import { MigrationsValidator } from './MigrationsValidator.js'
 import { emptySchema } from '@contember/schema-utils'
 import { MigrationVersionHelper } from '@contember/engine-common'
-import { SystemClientProvider } from '../SystemClientProvider'
+import { SystemClientProvider } from '../SystemClientProvider.js'
 
 export class MigrationRebaseFacade {
 	constructor(
@@ -10,6 +10,7 @@ export class MigrationRebaseFacade {
 		private readonly migrationsValidator: MigrationsValidator,
 		private readonly systemClientProvider: SystemClientProvider,
 		private readonly migrationFilesManager: MigrationFilesManager,
+		private readonly schemaStateManager: SchemaStateManager,
 	) {
 	}
 
@@ -37,5 +38,11 @@ export class MigrationRebaseFacade {
 			await this.systemClientProvider.get().migrationModify(migration.version, newMigration)
 			await this.migrationFilesManager.moveFile(migration.name, newMigration.name)
 		}
+
+		// migrationModify rebuilds the server schema from migrations, dropping the non-model
+		// state; re-apply it from the state files so the server stays consistent.
+		if (await this.schemaStateManager.isStateMode()) {
+			await this.systemClientProvider.get().migrate([], false, await this.schemaStateManager.readState())
+		}
 	}
 }

package/src/lib/migrations/MigrationSnapshotFacade.ts

@@ -0,0 +1,218 @@
+import { compareArraysIgnoreOrder, deepCompare, emptySchema } from '@contember/schema-utils'
+import {
+	calculateMigrationChecksum,
+	CoveredMigration,
+	ExecutedMigrationInfo,
+	isSchemaMigration,
+	MigrationContent,
+	MigrationsResolver,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	SnapshotFile,
+	SnapshotInput,
+	SnapshotManager,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+
+export class MigrationSnapshotFacade {
+	constructor(
+		private readonly migrationsResolver: MigrationsResolver,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly schemaDiffer: SchemaDiffer,
+		private readonly schemaMigrator: SchemaMigrator,
+		private readonly schemaStateManager: SchemaStateManager,
+		private readonly snapshotManager: SnapshotManager,
+	) {
+	}
+
+	/** Collapses all migrations into a single schema snapshot and writes snapshot.json. */
+	async create(): Promise<SnapshotFile> {
+		const files = await this.migrationsResolver.getMigrationFiles()
+		if (files.length === 0) {
+			throw 'No migrations to snapshot'
+		}
+		const stateMode = await this.schemaStateManager.isStateMode()
+		const version = files[files.length - 1].version
+
+		// Replay all schema migrations into a single schema. In state mode the non-model parts
+		// (acl/validation/actions/settings) live in state/ and are skipped here; otherwise they
+		// are part of the migration history and must be included in the collapsed modifications.
+		const collapsedSchema = await this.schemaVersionBuilder.buildSchemaAdvanced(emptySchema, () => true)
+		const modifications = this.schemaDiffer.diffSchemas(emptySchema, collapsedSchema, {
+			skipNonModelDiffers: stateMode,
+		})
+
+		const covers: CoveredMigration[] = []
+		const contentMigrations: string[] = []
+		for (const file of files) {
+			const content = await file.getContent()
+			const schema = isSchemaMigration(content)
+			covers.push({
+				version: file.version,
+				name: file.name,
+				type: schema ? 'schema' : 'content',
+				checksum: schema ? calculateMigrationChecksum(content) : null,
+			})
+			if (!schema) {
+				contentMigrations.push(file.version)
+			}
+		}
+
+		const snapshot: SnapshotFile = {
+			version,
+			stateMode,
+			snapshot: { formatVersion: VERSION_LATEST, modifications },
+			covers,
+			contentMigrations,
+		}
+		await this.snapshotManager.write(snapshot)
+		return snapshot
+	}
+
+	/**
+	 * Returns the snapshot when it can safely bootstrap the current project, else null.
+	 * The snapshot is only usable on an empty project (no executed migrations) and only when
+	 * none of the covered migration files have changed. A present-but-stale snapshot is skipped
+	 * with a warning, falling back to a full replay.
+	 */
+	async getUsableSnapshot(executedMigrations: ExecutedMigrationInfo[]): Promise<SnapshotFile | null> {
+		if (!(await this.snapshotManager.exists())) {
+			return null
+		}
+		if (executedMigrations.length > 0) {
+			return null
+		}
+		const snapshot = await this.snapshotManager.read()
+		const stale = await this.findStaleness(snapshot)
+		if (stale) {
+			console.warn(`Ignoring snapshot: ${stale}. Run "migrations:snapshot" to regenerate it.`)
+			return null
+		}
+		return snapshot
+	}
+
+	/** Maps a snapshot to the GraphQL SnapshotInput; covered migrations are sent as Migration inputs. */
+	async buildSnapshotInput(snapshot: SnapshotFile): Promise<SnapshotInput> {
+		const files = await this.migrationsResolver.getMigrationFiles()
+		const byVersion = new Map(files.map(it => [it.version, it]))
+		const covers: unknown[] = []
+		for (const covered of snapshot.covers) {
+			const file = byVersion.get(covered.version)
+			if (!file) {
+				throw `Snapshot covers missing migration ${covered.name}`
+			}
+			covers.push(migrationContentToInput(covered.version, covered.name, await file.getContent()))
+		}
+		return {
+			formatVersion: snapshot.snapshot.formatVersion,
+			modifications: snapshot.snapshot.modifications,
+			covers,
+		}
+	}
+
+	/** Offline check that the snapshot still equals a full replay of all migrations. */
+	async verify(): Promise<{ ok: boolean; message: string }> {
+		if (!(await this.snapshotManager.exists())) {
+			throw 'No snapshot found. Run "migrations:snapshot" first.'
+		}
+		const snapshot = await this.snapshotManager.read()
+
+		const stale = await this.findStaleness(snapshot)
+		if (stale) {
+			return { ok: false, message: `Snapshot is stale: ${stale}. Run "migrations:snapshot" to regenerate it.` }
+		}
+
+		const stateMode = await this.schemaStateManager.isStateMode()
+		const replaySchema = await this.schemaVersionBuilder.buildSchema()
+		let snapshotSchema = this.schemaMigrator.applyModifications(emptySchema, snapshot.snapshot.modifications, snapshot.snapshot.formatVersion)
+		if (stateMode) {
+			snapshotSchema = { ...snapshotSchema, ...await this.schemaStateManager.readState() }
+		}
+
+		// Compare with the same order-insensitive equality that SchemaDiffer uses for its own
+		// round-trip check. The collapsed differ emits fields/constraints in a fixed order that may
+		// differ from a replay of an interleaved history (e.g. a column added to an entity that
+		// already has a relation), so a raw checksum (JSON.stringify) would report false mismatches
+		// on schemas that are in fact deeply equal.
+		const differences = deepCompare(replaySchema, snapshotSchema, [], path => {
+			if (path[0] === 'model' && path[1] === 'entities' && (path[3] === 'unique' || path[3] === 'index')) {
+				return (a, b) => compareArraysIgnoreOrder(a, b, path)
+			}
+			return null
+		})
+		if (differences.length === 0) {
+			return {
+				ok: true,
+				message: `Snapshot is up to date (covers ${snapshot.covers.length} migrations up to ${snapshot.version}).`,
+			}
+		}
+		return {
+			ok: false,
+			message: 'Snapshot does not match a full replay of all migrations. Run "migrations:snapshot" to regenerate it.',
+		}
+	}
+
+	private async findStaleness(snapshot: SnapshotFile): Promise<string | null> {
+		// The collapsed snapshot is built differently per mode (state mode omits the non-model parts,
+		// see create()), and on bootstrap the non-model overlay is driven by the *current* mode. A mode
+		// switch since the snapshot was created (e.g. migrations:init-state) leaves the covers untouched
+		// and would otherwise pass unnoticed, so treat it as stale and fall back to a full replay.
+		if (snapshot.stateMode !== await this.schemaStateManager.isStateMode()) {
+			return `schema state mode changed since the snapshot was created`
+		}
+		const files = await this.migrationsResolver.getMigrationFiles()
+		const byVersion = new Map(files.map(it => [it.version, it]))
+		for (const covered of snapshot.covers) {
+			const file = byVersion.get(covered.version)
+			if (!file) {
+				return `covered migration ${covered.name} is missing`
+			}
+			const content = await file.getContent()
+			const currentType = isSchemaMigration(content) ? 'schema' : 'content'
+			// A covered migration that flipped type (e.g. a content migration manually rewritten into a
+			// schema one) is not reflected in the collapsed modifications, so the snapshot no longer
+			// equals a replay. Schema covers also verify the checksum; content covers carry none (their
+			// data is never reproduced), so the type check is the only identity they get.
+			if (currentType !== covered.type) {
+				return `covered migration ${covered.name} changed type`
+			}
+			if (covered.type === 'schema') {
+				const checksum = isSchemaMigration(content) ? calculateMigrationChecksum(content) : null
+				if (checksum !== covered.checksum) {
+					return `covered migration ${covered.name} has changed`
+				}
+			}
+		}
+		// Detect a migration added within the covered range (version <= snapshot.version) that the
+		// snapshot does not know about — e.g. a teammate's migration with an earlier timestamp merged
+		// after the snapshot was generated. Without this, bootstrapping would record the covers up to
+		// snapshot.version and the subsequent normal replay would fail with MUST_FOLLOW_LATEST on the
+		// in-range migration, leaving the database half-bootstrapped. Treat it as stale and fall back.
+		const coveredVersions = new Set(snapshot.covers.map(it => it.version))
+		for (const file of files) {
+			if (file.version <= snapshot.version && !coveredVersions.has(file.version)) {
+				return `migration ${file.name} is within the covered range but not part of the snapshot`
+			}
+		}
+		return null
+	}
+}
+
+const migrationContentToInput = (version: string, name: string, content: MigrationContent) => {
+	if (isSchemaMigration(content)) {
+		return {
+			version,
+			name,
+			type: 'SCHEMA',
+			schemaMigration: {
+				formatVersion: content.formatVersion,
+				modifications: content.modifications,
+				skippedErrors: content.skippedErrors,
+			},
+		}
+	}
+	// Content migrations are only recorded as executed (no data is replayed), so the queries are irrelevant.
+	return { version, name, type: 'CONTENT', contentMigration: [] }
+}

package/src/lib/migrations/MigrationsStatusFacade.ts

@@ -1,6 +1,6 @@
 import { MigrationsResolver, MigrationsStatusResolver } from '@contember/migrations-client'
-import { SystemClientProvider } from '../SystemClientProvider'
-import { MigrationPrinter } from './MigrationPrinter'
+import { SystemClientProvider } from '../SystemClientProvider.js'
+import { MigrationPrinter } from './MigrationPrinter.js'
 
 export class MigrationsStatusFacade {
 	constructor(

package/src/lib/migrations/MigrationsValidator.ts

@@ -2,7 +2,7 @@ import { Migration } from '@contember/migrations-client'
 import { Schema } from '@contember/schema'
 import { SchemaValidatorSkippedErrors } from '@contember/schema-utils'
 import { MigrationDescriber, MigrationVersionHelper, SchemaMigrator, SchemaUpdateError } from '@contember/schema-migrations'
-import { validateSchemaAndPrintErrors } from '../schema/SchemaValidationHelper'
+import { validateSchemaAndPrintErrors } from '../schema/SchemaValidationHelper.js'
 
 export class MigrationsValidator {
 	constructor(

package/src/lib/project/RemoteProjectProvider.ts

@@ -1,4 +1,4 @@
-import { RemoteProject } from './RemoteProject'
+import { RemoteProject } from './RemoteProject.js'
 
 export class RemoteProjectProvider {
 	private _remoteProject: RemoteProject | undefined = undefined

package/src/lib/project/RemoteProjectResolver.ts

@@ -1,6 +1,6 @@
-import { parseDsn } from '../dsn'
-import { RemoteProject } from './RemoteProject'
-import { CliEnv } from '../env'
+import { parseDsn } from '../dsn.js'
+import { RemoteProject } from './RemoteProject.js'
+import { CliEnv } from '../env.js'
 
 export class RemoteProjectResolver {
 	constructor(

package/src/lib/project/docs/components/EntityInfo.tsx

@@ -1,10 +1,10 @@
 import { Model, Schema } from '@contember/schema'
-import { ReferencesMap } from '../../../schema/collectReferences'
-import { formatEntityAnchor, formatFieldAnchor } from './utils'
-import { SinglePermission } from './SinglePermission'
-import { FieldType } from './FieldType'
-import { FieldPermissions } from './FieldPermissions'
-import { OnDelete } from './OnDelete'
+import { ReferencesMap } from '../../../schema/collectReferences.js'
+import { formatEntityAnchor, formatFieldAnchor } from './utils.js'
+import { SinglePermission } from './SinglePermission.js'
+import { FieldType } from './FieldType.js'
+import { FieldPermissions } from './FieldPermissions.js'
+import { OnDelete } from './OnDelete.js'
 import { Fragment, h } from 'preact'
 
 interface EntityInfoProps {

package/src/lib/project/docs/components/EntityLink.tsx

@@ -1,5 +1,5 @@
 import { h } from 'preact'
-import { formatEntityAnchor } from './utils'
+import { formatEntityAnchor } from './utils.js'
 
 export const EntityLink = ({ entity }: { entity: string }) => (
 	<a href={`#${formatEntityAnchor(entity)}`} class={'text-blue-500 hover:underline'}>{entity}</a>

package/src/lib/project/docs/components/FieldLink.tsx

@@ -1,6 +1,6 @@
 import { Fragment, h } from 'preact'
-import { EntityLink } from './EntityLink'
-import { formatFieldAnchor } from './utils'
+import { EntityLink } from './EntityLink.js'
+import { formatFieldAnchor } from './utils.js'
 
 export const FieldLink = ({ entity, field, noEntityLabel }: { entity: string; field: string; noEntityLabel?: boolean }) => (
 	<Fragment>

package/src/lib/project/docs/components/FieldPermissions.tsx

@@ -1,6 +1,6 @@
 import { Fragment, h } from 'preact'
 import { Acl } from '@contember/schema'
-import { SinglePermission } from './SinglePermission'
+import { SinglePermission } from './SinglePermission.js'
 
 export const FieldPermissions = ({ entityPermissions, field }: { entityPermissions?: Acl.EntityPermissions; field: string }) => {
 	const readPermissions = entityPermissions?.operations.read?.[field]

package/src/lib/project/docs/components/FieldType.tsx

@@ -1,7 +1,7 @@
 import { Model } from '@contember/schema'
 import { Fragment, h } from 'preact'
-import { EntityLink } from './EntityLink'
-import { FieldLink } from './FieldLink'
+import { EntityLink } from './EntityLink.js'
+import { FieldLink } from './FieldLink.js'
 
 export const FieldType = ({ field }: { field: Model.AnyField }) => {
 	if (field.type === 'ManyHasMany') {

package/src/lib/project/docs/components/OnDelete.tsx

@@ -1,8 +1,8 @@
 import { Fragment, h } from 'preact'
 import { Model } from '@contember/schema'
-import { ReferenceMapEntry, ReferencesMap } from '../../../schema/collectReferences'
-import { FieldLink } from './FieldLink'
-import { EntityLink } from './EntityLink'
+import { ReferenceMapEntry, ReferencesMap } from '../../../schema/collectReferences.js'
+import { FieldLink } from './FieldLink.js'
+import { EntityLink } from './EntityLink.js'
 
 const sortReferences = (a: ReferenceMapEntry, b: ReferenceMapEntry) =>
 	a.owningRelation.joiningColumn.onDelete.localeCompare(b.owningRelation.joiningColumn.onDelete)

package/src/lib/project/docs/components/ProjectInfo.tsx

@@ -1,8 +1,8 @@
 import { Schema } from '@contember/schema'
 import { h } from 'preact'
-import { collectReferences } from '../../../schema/collectReferences'
-import { EntityLink } from './EntityLink'
-import { EntityInfo } from './EntityInfo'
+import { collectReferences } from '../../../schema/collectReferences.js'
+import { EntityLink } from './EntityLink.js'
+import { EntityInfo } from './EntityInfo.js'
 
 export const ProjectInfo = (props: { schema: Schema; projectName: string }) => {
 	const references = collectReferences(props.schema.model)

package/src/lib/project/docs/projectDescribe.tsx

@@ -1,9 +1,9 @@
 import { Schema } from '@contember/schema'
 import { h } from 'preact'
 import render from 'preact-render-to-string'
-import { ProjectInfo } from './components/ProjectInfo'
+import { ProjectInfo } from './components/ProjectInfo.js'
 import { readFile } from 'node:fs/promises'
-import { packageRoot } from '../../../consts'
+import { packageRoot } from '../../../consts.js'
 
 export const renderProjectInfoHtml = async (schema: Schema, projectName: string) => {
 	const html = render(<ProjectInfo schema={schema} projectName={projectName} />)

package/src/lib/schema/SchemaLoader.ts

@@ -1,9 +1,9 @@
 import { join } from 'node:path'
 import { Schema } from '@contember/schema'
 import { schemaType } from '@contember/schema-utils'
-import { JsCodeRunner } from '../js/JsCodeRunner'
+import { JsCodeRunner } from '../js/JsCodeRunner.js'
 import * as Typesafe from '@contember/typesafe'
-import { Workspace } from '../workspace/Workspace'
+import { Workspace } from '../workspace/Workspace.js'
 
 export class ImportSchemaLoader {
 	constructor(

package/src/lib/schema/SchemaValidationHelper.ts

@@ -1,6 +1,6 @@
 import { Schema } from '@contember/schema'
 import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
-import { printValidationErrors } from './SchemaValidationPrinter'
+import { printValidationErrors } from './SchemaValidationPrinter.js'
 
 export const validateSchemaAndPrintErrors = (schema: Schema, message?: string, skippedErrors?: SchemaValidatorSkippedErrors[]): boolean => {
 	const errors = SchemaValidator.validate(schema, skippedErrors)