@contember/cli 2.2.0-alpha.3 → 2.2.0-alpha.4

package/src/lib/migrations/MigrationPrinter.ts

@@ -5,88 +5,124 @@ import chalk from 'chalk'
 import { AnyMigrationStatus, Migration, MigrationDescriber, MigrationState } from '@contember/migrations-client'
 import { emptyDatabaseMetadata } from '@contember/database'
 import chalkTable from 'chalk-table'
+import { escapeTerminalText, Output } from '@contember/cli-common'
 import { assertNever } from '../assertNever.js'
 
+export interface MigrationDescriptionItem {
+	modification: string
+	description: string
+	isDestructive: boolean
+	failureWarning: string | null
+	sql: string
+}
+
+export interface MigrationStatusRow {
+	status: string
+	migration: string
+	info: string
+}
+
+export const migrationStatusColumns: { field: keyof MigrationStatusRow & string; name: string }[] = [
+	{ field: 'status', name: 'Status' },
+	{ field: 'migration', name: 'Migration' },
+	{ field: 'info', name: 'Info' },
+]
+
 export class MigrationPrinter {
 	constructor(
 		private readonly migrationsDescriber: MigrationDescriber,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
+	/** The structured description of a migration — the data behind `migrations describe`. */
+	describeMigration = (schema: Schema, migration: Migration): MigrationDescriptionItem[] => {
+		return this.migrationsDescriber.describeModifications(schema, migration).map(({ modification, getSql, description }) => ({
+			modification: modification.modification,
+			description: description.message,
+			isDestructive: description.isDestructive ?? false,
+			failureWarning: description.failureWarning ?? null,
+			sql: getSql({
+				systemSchema: 'system',
+				databaseMetadata: emptyDatabaseMetadata,
+				invalidateDatabaseMetadata: () => null,
+			}),
+		}))
+	}
+
+	formatMigrationDescription = (items: MigrationDescriptionItem[], options: { sqlOnly?: boolean; noSql?: boolean } = {}): string => {
+		if (options.sqlOnly) {
+			return items.map(it => sanitizeMultiline(it.sql.trim())).filter(it => it !== '').join('\n')
+		}
+		return items.map(item => {
+			const color = item.isDestructive ? chalk.red : chalk.blue
+			const lines = [color(`${sanitizeMultiline(item.description)} [${sanitizeMultiline(item.modification)}]`)]
+			if (item.failureWarning) {
+				lines.push(chalk.bgWhite(chalk.redBright(sanitizeMultiline(item.failureWarning))))
+			}
+			if (!options.noSql) {
+				lines.push(item.sql.trim() ? sanitizeMultiline(item.sql) : 'No sql to execute')
+			}
+			// the body is indented under its header, as console.group used to render it
+			return lines.map((line, index) => index === 0 ? line : indent(line)).join('\n')
+		}).join('\n')
+	}
+
+	/** Prints the description as a diagnostic — a preamble of what a command is about to do. */
 	printMigrationDescription = (
 		schema: Schema,
 		migration: Migration,
 		options: { sqlOnly?: boolean; noSql?: boolean },
 	) => {
-		const description = this.migrationsDescriber.describeModifications(schema, migration)
-		description.forEach(({ modification, getSql, description }) => {
-			const sql = getSql({
-				systemSchema: 'system',
-				databaseMetadata: emptyDatabaseMetadata,
-				invalidateDatabaseMetadata: () => null,
-			})
-			if (options.sqlOnly) {
-				if (sql.trim()) {
-					console.log(sql)
-				}
-			} else {
-				const color = description.isDestructive ? chalk.red : chalk.blue
-				console.group(color(`${description.message} [${modification.modification}]`))
-				if (description.failureWarning) {
-					console.log(chalk.bgWhite(chalk.redBright(description.failureWarning)))
-				}
+		const description = this.formatMigrationDescription(this.describeMigration(schema, migration), options)
+		if (description !== '') {
+			for (const line of description.split('\n')) {
+				this.output.info(line)
+			}
+		}
+	}
 
-				if (!options.noSql) {
-					if (sql.trim()) {
-						console.log(sql)
-					} else {
-						console.log('No sql to execute')
+	statusRows = (migrations: AnyMigrationStatus[]): MigrationStatusRow[] => {
+		return migrations.map((it): MigrationStatusRow => {
+			switch (it.state) {
+				case MigrationState.EXECUTED_ERROR:
+					return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
+				case MigrationState.EXECUTED_OK:
+					return {
+						status: chalk.bgGreen.blackBright('Executed'),
+						migration: it.name,
+						info: `Executed at ${it.executedMigration.executedAt.toISOString()}`,
+					}
+				case MigrationState.EXECUTED_MISSING:
+					return {
+						status: chalk.bgRedBright.white('ERROR'),
+						migration: it.name,
+						info: it.errorMessage,
+					}
+				case MigrationState.TO_EXECUTE_OK:
+					return {
+						status: chalk.bgBlueBright.white('Not executed'),
+						migration: it.name,
+						info: 'Will be executed during next deploy',
 					}
-				}
-				console.groupEnd()
+				case MigrationState.TO_EXECUTE_ERROR:
+					return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
+				case MigrationState.SKIP_EMPTY:
+					return {
+						status: chalk.bgYellow.white('Skip'),
+						migration: it.name,
+						info: `Skipped because empty`,
+					}
+				default:
+					return assertNever(it)
 			}
 		})
 	}
 
-	printStatusTable = (migrations: AnyMigrationStatus[]) => {
-		return chalkTable(
-			{
-				columns: ['status', 'migration', 'info'],
-			},
-			migrations.map(it => {
-				switch (it.state) {
-					case MigrationState.EXECUTED_ERROR:
-						return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
-					case MigrationState.EXECUTED_OK:
-						return {
-							status: chalk.bgGreen.blackBright('Executed'),
-							migration: it.name,
-							info: `Executed at ${it.executedMigration.executedAt.toISOString()}`,
-						}
-					case MigrationState.EXECUTED_MISSING:
-						return {
-							status: chalk.bgRedBright.white('ERROR'),
-							migration: it.name,
-							info: it.errorMessage,
-						}
-					case MigrationState.TO_EXECUTE_OK:
-						return {
-							status: chalk.bgBlueBright.white('Not executed'),
-							migration: it.name,
-							info: 'Will be executed during next deploy',
-						}
-					case MigrationState.TO_EXECUTE_ERROR:
-						return { status: chalk.bgRedBright.white('ERROR'), migration: it.name, info: it.errorMessage }
-					case MigrationState.SKIP_EMPTY:
-						return {
-							status: chalk.bgYellow.white('Skip'),
-							migration: it.name,
-							info: `Skipped because empty`,
-						}
-					default:
-						assertNever(it)
-				}
-			}),
-		)
+	formatStatusTable = (migrations: AnyMigrationStatus[]): string => {
+		return chalkTable({ columns: migrationStatusColumns }, this.statusRows(migrations))
 	}
 }
+
+const indent = (text: string): string => text.split('\n').map(line => `  ${line}`).join('\n')
+const sanitizeMultiline = (text: string): string => text.split('\n').map(escapeTerminalText).join('\n')

package/src/lib/migrations/MigrationRebaseFacade.ts

@@ -3,6 +3,7 @@ import { MigrationsValidator } from './MigrationsValidator.js'
 import { emptySchema } from '@contember/schema-utils'
 import { MigrationVersionHelper } from '@contember/engine-common'
 import { SystemClientProvider } from '../SystemClientProvider.js'
+import { CliError, ExitCode } from '@contember/cli-common'
 
 export class MigrationRebaseFacade {
 	constructor(
@@ -22,7 +23,7 @@ export class MigrationRebaseFacade {
 		)
 		const valid = await this.migrationsValidator.validate(schemaWithoutMigrations, migrations)
 		if (!valid) {
-			throw `Cannot rebase migrations`
+			throw new CliError('Cannot rebase migrations', { code: 'MIGRATIONS_INVALID', exitCode: ExitCode.InputError })
 		}
 
 		let i = 0

package/src/lib/migrations/MigrationSnapshotFacade.ts

@@ -15,6 +15,7 @@ import {
 	SnapshotManager,
 	VERSION_LATEST,
 } from '@contember/migrations-client'
+import { CliError, ExitCode, Output } from '@contember/cli-common'
 
 export class MigrationSnapshotFacade {
 	constructor(
@@ -24,14 +25,15 @@ export class MigrationSnapshotFacade {
 		private readonly schemaMigrator: SchemaMigrator,
 		private readonly schemaStateManager: SchemaStateManager,
 		private readonly snapshotManager: SnapshotManager,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
-	/** Collapses all migrations into a single schema snapshot and writes snapshot.json. */
-	async create(): Promise<SnapshotFile> {
+	/** Builds a snapshot in memory without changing the filesystem. */
+	async prepare(): Promise<SnapshotFile> {
 		const files = await this.migrationsResolver.getMigrationFiles()
 		if (files.length === 0) {
-			throw 'No migrations to snapshot'
+			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
@@ -67,10 +69,13 @@ export class MigrationSnapshotFacade {
 			covers,
 			contentMigrations,
 		}
-		await this.snapshotManager.write(snapshot)
 		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
@@ -87,7 +92,7 @@ export class MigrationSnapshotFacade {
 		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.`)
+			this.output.warn(`Ignoring snapshot: ${stale}. Run "migrations snapshot" to regenerate it.`)
 			return null
 		}
 		return snapshot
@@ -101,7 +106,7 @@ export class MigrationSnapshotFacade {
 		for (const covered of snapshot.covers) {
 			const file = byVersion.get(covered.version)
 			if (!file) {
-				throw `Snapshot covers missing migration ${covered.name}`
+				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()))
 		}
@@ -115,13 +120,13 @@ export class MigrationSnapshotFacade {
 	/** 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.'
+			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.` }
+			return { ok: false, message: `Snapshot is stale: ${stale}. Run "migrations snapshot" to regenerate it.` }
 		}
 
 		const stateMode = await this.schemaStateManager.isStateMode()
@@ -150,14 +155,14 @@ export class MigrationSnapshotFacade {
 		}
 		return {
 			ok: false,
-			message: 'Snapshot does not match a full replay of all migrations. Run "migrations:snapshot" to regenerate it.',
+			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
+		// 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`

package/src/lib/migrations/MigrationsStatusFacade.ts

@@ -1,6 +1,7 @@
-import { MigrationsResolver, MigrationsStatusResolver } from '@contember/migrations-client'
+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

@@ -3,11 +3,13 @@ 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.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,3 +1,4 @@
+import { CliError, ExitCode } from '@contember/cli-common'
 import { RemoteProject } from './RemoteProject.js'
 
 export class RemoteProjectProvider {
@@ -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/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/SchemaValidationHelper.ts

@@ -1,9 +1,15 @@
 import { Schema } from '@contember/schema'
 import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
+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
 }

package/src/lib/schema/SchemaValidationPrinter.ts

@@ -1,12 +1,13 @@
+import { Output } from '@contember/cli-common'
 import { ValidationError } from '@contember/schema-utils'
 
-export const printValidationErrors = (errors: ValidationError[], message?: string) => {
+// diagnostic only — never the command's own data output; callers that don't yet pass `output` fall back to a fresh one
+export const printValidationErrors = (errors: ValidationError[], message?: string, output: Output = new Output()) => {
 	if (errors.length === 0) {
 		return
 	}
-	console.group(message || 'Schema is invalid:')
+	output.error(message || 'Schema is invalid:')
 	for (const err of errors) {
-		console.log(`${err.path.join('.')}: [${err.code}] ${err.message}`)
+		output.error(`  ${err.path.join('.')}: [${err.code}] ${err.message}`)
 	}
-	console.groupEnd()
 }