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

package/src/lib/migrations/MigrationSnapshotFacade.ts

@@ -0,0 +1,223 @@
+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'
+import { CliError, ExitCode, Output } from '@contember/cli-common'
+
+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,
+		private readonly output: Output = new Output(),
+	) {
+	}
+
+	/** Builds a snapshot in memory without changing the filesystem. */
+	async prepare(): Promise<SnapshotFile> {
+		const files = await this.migrationsResolver.getMigrationFiles()
+		if (files.length === 0) {
+			throw new CliError('No migrations to snapshot', { code: 'MIGRATIONS_NOT_FOUND', exitCode: ExitCode.NotFound })
+		}
+		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,
+		}
+		return snapshot
+	}
+
+	async write(snapshot: SnapshotFile): Promise<void> {
+		await this.snapshotManager.write(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) {
+			this.output.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 new CliError(`Snapshot covers missing migration ${covered.name}`, { code: 'SNAPSHOT_COVER_MISSING', exitCode: ExitCode.NotFound })
+			}
+			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 new CliError('No snapshot found. Run "migrations snapshot" first.', { code: 'SNAPSHOT_NOT_FOUND', exitCode: ExitCode.NotFound })
+		}
+		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,7 @@
-import { MigrationsResolver, MigrationsStatusResolver } from '@contember/migrations-client'
-import { SystemClientProvider } from '../SystemClientProvider'
-import { MigrationPrinter } from './MigrationPrinter'
+import { ExecutedMigrationInfo, MigrationsResolver, MigrationsStatusResolver } from '@contember/migrations-client'
+import { SystemClientProvider } from '../SystemClientProvider.js'
+import { MigrationPrinter } from './MigrationPrinter.js'
+import { CliError, ExitCode, Output } from '@contember/cli-common'
 
 export class MigrationsStatusFacade {
 	constructor(
@@ -8,17 +9,30 @@ export class MigrationsStatusFacade {
 		private readonly migrationsResolver: MigrationsResolver,
 		private readonly migrationsStatusResolver: MigrationsStatusResolver,
 		private readonly migrationPrinter: MigrationPrinter,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
+	public getLocalMigrationFiles = () => this.migrationsResolver.getMigrationFiles()
+
 	public resolveMigrationsStatus = async ({ force, allowError }: { force?: boolean; allowError?: boolean }) => {
 		const executedMigrations = await this.systemClientProvider.get().listExecutedMigrations()
+		return await this.resolveMigrationsStatusFromExecuted(executedMigrations, { force, allowError })
+	}
+
+	public resolveMigrationsStatusFromExecuted = async (
+		executedMigrations: ExecutedMigrationInfo[],
+		{ force, allowError }: { force?: boolean; allowError?: boolean },
+	) => {
 		const localMigrations = await this.migrationsResolver.getMigrationFiles()
 		const status = await this.migrationsStatusResolver.getMigrationsStatus(executedMigrations, localMigrations, force)
 		if (status.errorMigrations.length > 0 && !allowError) {
-			console.error(this.migrationPrinter.printStatusTable(status.errorMigrations))
+			// diagnostic context for the failure below, so it goes to stderr unstyled
+			for (const line of this.migrationPrinter.formatStatusTable(status.errorMigrations).split('\n')) {
+				this.output.info(line)
+			}
 			if (!force) {
-				throw `Cannot execute migrations`
+				throw new CliError('Cannot execute migrations', { code: 'MIGRATIONS_BROKEN', exitCode: ExitCode.InputError })
 			}
 		}
 

package/src/lib/migrations/MigrationsValidator.ts

@@ -2,12 +2,14 @@ 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'
+import { Output } from '@contember/cli-common'
 
 export class MigrationsValidator {
 	constructor(
 		private readonly describer: MigrationDescriber,
 		private readonly migrator: SchemaMigrator,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
@@ -23,7 +25,7 @@ export class MigrationsValidator {
 				migratedSchema = this.migrator.applyModifications(migratedSchema, migration.modifications, migration.formatVersion)
 			} catch (e) {
 				if (e instanceof SchemaUpdateError) {
-					console.error(`Migration ${migration.name} has failed`)
+					this.output.error(`Migration ${migration.name} has failed`)
 				}
 				throw e
 			}
@@ -32,7 +34,7 @@ export class MigrationsValidator {
 				...skippedErrors.filter(it => it.skipUntil && MigrationVersionHelper.extractVersion(it.skipUntil) >= migration.version),
 				...migration.skippedErrors ?? [],
 			]
-			projectValid = validateSchemaAndPrintErrors(migratedSchema, errorMessage, skippedErrors)
+			projectValid = validateSchemaAndPrintErrors(migratedSchema, errorMessage, skippedErrors, this.output)
 				&& projectValid
 		}
 		return projectValid

package/src/lib/project/RemoteProjectProvider.ts

@@ -1,4 +1,5 @@
-import { RemoteProject } from './RemoteProject'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { RemoteProject } from './RemoteProject.js'
 
 export class RemoteProjectProvider {
 	private _remoteProject: RemoteProject | undefined = undefined
@@ -9,7 +10,11 @@ export class RemoteProjectProvider {
 
 	public get(): RemoteProject {
 		if (!this._remoteProject) {
-			throw new Error('Remote project not set')
+			// the container leaves this unset when the env resolves to no project — a user mistake, not a bug
+			throw new CliError('Project not defined. Set CONTEMBER_DSN, or CONTEMBER_API_URL, CONTEMBER_API_TOKEN and CONTEMBER_PROJECT_NAME.', {
+				code: 'PROJECT_NOT_DEFINED',
+				exitCode: ExitCode.InputError,
+			})
 		}
 		return this._remoteProject
 	}

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/prompt/index.ts

@@ -0,0 +1 @@
+export * from './prompt.js'

package/src/lib/prompt/prompt.internal.ts

@@ -0,0 +1,69 @@
+import { Output, type PromptOutputStream } from '@contember/cli-common'
+
+const answerName = 'value'
+
+export interface ConfirmPromptOptions {
+	readonly message: string
+	readonly initial?: boolean
+}
+
+export interface SelectPromptChoice<T extends string> {
+	readonly title: string
+	readonly value: T
+}
+
+export interface SelectPromptOptions<T extends string> {
+	readonly message: string
+	readonly choices: readonly SelectPromptChoice<T>[]
+}
+
+export interface PromptAnswer {
+	readonly value?: unknown
+}
+
+export interface ConfirmQuestion {
+	readonly type: 'confirm'
+	readonly name: typeof answerName
+	readonly message: string
+	readonly initial?: boolean
+	readonly stdout: PromptOutputStream
+}
+
+export interface SelectQuestion<T extends string> {
+	readonly type: 'select'
+	readonly name: typeof answerName
+	readonly message: string
+	readonly choices: SelectPromptChoice<T>[]
+	readonly stdout: PromptOutputStream
+}
+
+export type PromptQuestion = ConfirmQuestion | SelectQuestion<string>
+
+type PromptRunner<Q> = (question: Q) => Promise<PromptAnswer>
+
+export const promptConfirmWithRunner = async (
+	output: Output,
+	options: ConfirmPromptOptions,
+	runner: PromptRunner<ConfirmQuestion>,
+): Promise<boolean> => {
+	const question: ConfirmQuestion = options.initial === undefined
+		? { type: 'confirm', name: answerName, message: options.message, stdout: output.promptOutput }
+		: { type: 'confirm', name: answerName, message: options.message, initial: options.initial, stdout: output.promptOutput }
+	const answer = await runner(question)
+	return answer.value === true
+}
+
+export const promptSelectWithRunner = async <const T extends string>(
+	output: Output,
+	options: SelectPromptOptions<T>,
+	runner: PromptRunner<SelectQuestion<T>>,
+): Promise<T | undefined> => {
+	const answer = await runner({
+		type: 'select',
+		name: answerName,
+		message: options.message,
+		choices: options.choices.map(choice => ({ title: choice.title, value: choice.value })),
+		stdout: output.promptOutput,
+	})
+	return options.choices.find(choice => choice.value === answer.value)?.value
+}

package/src/lib/prompt/prompt.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'bun:test'
+import { Output, type OutputStream } from '@contember/cli-common'
+import { promptConfirmWithRunner, promptSelectWithRunner } from './prompt.internal.js'
+
+class CapturingStream implements OutputStream {
+	public readonly isTty = true
+	public readonly columns = 120
+
+	public write(): void {
+	}
+}
+
+const createOutput = (): Output =>
+	new Output({
+		stdout: new CapturingStream(),
+		stderr: new CapturingStream(),
+		isStdinTty: () => true,
+	})
+
+describe('promptConfirm', () => {
+	test('binds diagnostic output and maps a confirmed answer', async () => {
+		const output = createOutput()
+		const result = await promptConfirmWithRunner(output, { message: 'Continue?', initial: false }, async question => {
+			expect(question).toStrictEqual({
+				type: 'confirm',
+				name: 'value',
+				message: 'Continue?',
+				initial: false,
+				stdout: output.promptOutput,
+			})
+			return { value: true }
+		})
+
+		expect(result).toBe(true)
+	})
+
+	test('maps rejection and cancellation to false', async () => {
+		const output = createOutput()
+		expect(
+			await promptConfirmWithRunner(output, { message: 'Continue?' }, async question => {
+				expect(question).toStrictEqual({
+					type: 'confirm',
+					name: 'value',
+					message: 'Continue?',
+					stdout: output.promptOutput,
+				})
+				expect('initial' in question).toBe(false)
+				return { value: false }
+			}),
+		).toBe(false)
+		expect(await promptConfirmWithRunner(output, { message: 'Continue?' }, async () => ({}))).toBe(false)
+	})
+
+	test('propagates runner rejection unchanged', async () => {
+		const output = createOutput()
+		const rejection = new Error('prompt failed')
+		const promise = promptConfirmWithRunner(output, { message: 'Continue?' }, async () => {
+			throw rejection
+		})
+
+		await expect(promise).rejects.toBe(rejection)
+	})
+})
+
+describe('promptSelect', () => {
+	test('preserves literal values, binds diagnostic output, and maps the answer', async () => {
+		const output = createOutput()
+		const selected = await promptSelectWithRunner(output, {
+			message: 'Choose an action',
+			choices: [
+				{ value: 'remove', title: 'Remove migration' },
+				{ value: 'keep', title: 'Keep migration' },
+			],
+		}, async question => {
+			expect(question.type).toBe('select')
+			expect(question.name).toBe('value')
+			expect(question.message).toBe('Choose an action')
+			expect(question.choices).toStrictEqual([
+				{ value: 'remove', title: 'Remove migration' },
+				{ value: 'keep', title: 'Keep migration' },
+			])
+			expect(question.stdout).toBe(output.promptOutput)
+			return { value: 'remove' }
+		})
+		const typedSelection: 'remove' | 'keep' | undefined = selected
+
+		expect(typedSelection).toBe('remove')
+	})
+
+	test('returns undefined for cancellation and unknown answers', async () => {
+		const output = createOutput()
+		const options = {
+			message: 'Choose an action',
+			choices: [{ value: 'keep', title: 'Keep migration' }],
+		}
+
+		expect(await promptSelectWithRunner(output, options, async () => ({}))).toBeUndefined()
+		expect(await promptSelectWithRunner(output, options, async () => ({ value: 'unexpected' }))).toBeUndefined()
+	})
+})

package/src/lib/prompt/prompt.ts

@@ -0,0 +1,23 @@
+import { Output } from '@contember/cli-common'
+import prompts from 'prompts'
+import {
+	type ConfirmPromptOptions,
+	type PromptAnswer,
+	promptConfirmWithRunner,
+	type PromptQuestion,
+	promptSelectWithRunner,
+	type SelectPromptChoice,
+	type SelectPromptOptions,
+} from './prompt.internal.js'
+
+export type { ConfirmPromptOptions, SelectPromptChoice, SelectPromptOptions } from './prompt.internal.js'
+
+const runPrompt = async <Q extends PromptQuestion>(question: Q): Promise<PromptAnswer> => {
+	const answer: { value?: unknown } = await prompts(question)
+	return answer
+}
+
+export const promptConfirm = (output: Output, options: ConfirmPromptOptions): Promise<boolean> => promptConfirmWithRunner(output, options, runPrompt)
+
+export const promptSelect = <const T extends string>(output: Output, options: SelectPromptOptions<T>): Promise<T | undefined> =>
+	promptSelectWithRunner(output, options, runPrompt)

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,9 +1,15 @@
 import { Schema } from '@contember/schema'
 import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
-import { printValidationErrors } from './SchemaValidationPrinter'
+import { Output } from '@contember/cli-common'
+import { printValidationErrors } from './SchemaValidationPrinter.js'
 
-export const validateSchemaAndPrintErrors = (schema: Schema, message?: string, skippedErrors?: SchemaValidatorSkippedErrors[]): boolean => {
+export const validateSchemaAndPrintErrors = (
+	schema: Schema,
+	message?: string,
+	skippedErrors?: SchemaValidatorSkippedErrors[],
+	output?: Output,
+): boolean => {
 	const errors = SchemaValidator.validate(schema, skippedErrors)
-	printValidationErrors(errors, message)
+	printValidationErrors(errors, message, output)
 	return errors.length === 0
 }