@contember/cli 2.2.0-alpha.1 → 2.2.0-alpha.10

package/src/commands/deploy/DeployCommand.ts

@@ -1,5 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
-import prompts from 'prompts'
+import { CliError, Command, CommandConfiguration, escapeTerminalText, ExitCode, Input, Output } from '@contember/cli-common'
 import { maskToken } from '../../lib/maskToken.js'
 import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade.js'
 import { AdminDeployer } from '../../lib/admin/AdminDeployer.js'
@@ -8,6 +7,7 @@ import { RemoteProject } from '../../lib/project/RemoteProject.js'
 import { Workspace } from '../../lib/workspace/Workspace.js'
 import { RemoteProjectProvider } from '../../lib/project/RemoteProjectProvider.js'
 import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver.js'
+import { promptConfirm } from '../../lib/prompt/index.js'
 
 type Args = {
 	dsn?: string
@@ -22,10 +22,21 @@ type Options = {
 	snapshot?: boolean
 }
 
+/** The result of a deploy, printed via `output.data` — the token is deliberately never part of it. */
+export interface DeployResult {
+	project: string
+	apiUrl: string
+	adminUrl: string | null
+	migrationsDeployed: boolean
+	adminDeployed: boolean
+}
+
 export class DeployCommand extends Command<Args, Options> {
 	constructor(
 		private readonly adminDeployer: AdminDeployer,
-		private readonly migrationExecutionFacade: MigrationExecutionFacade,
+		// narrowed to the one method used: the real facade has a deep, partly-external dependency
+		// graph that is impractical to construct for tests, and this keeps the DI wiring unchanged.
+		private readonly migrationExecutionFacade: Pick<MigrationExecutionFacade, 'execute'>,
 		private readonly fs: FileSystem,
 		private readonly remoteProjectProvider: RemoteProjectProvider,
 		private readonly remoteProjectResolver: RemoteProjectResolver,
@@ -51,12 +62,15 @@ export class DeployCommand extends Command<Args, Options> {
 			.description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void | number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void | number> {
 		const dsn = input.getArgument('dsn')
 		const adminEndpoint = input.getOption('admin')
 		const remoteProject = this.remoteProjectResolver.resolve(dsn, adminEndpoint)
 		if (!remoteProject) {
-			throw `Project not defined. Please provide DSN or environment variables CONTEMBER_*`
+			throw new CliError('Project not defined. Please provide DSN or environment variables CONTEMBER_*', {
+				code: 'PROJECT_NOT_DEFINED',
+				exitCode: ExitCode.NotFound,
+			})
 		}
 		this.remoteProjectProvider.setRemoteProject(remoteProject)
 
@@ -66,41 +80,49 @@ export class DeployCommand extends Command<Args, Options> {
 
 		const deployAdmin = input.getOption('no-admin') !== true && !!remoteProject.adminEndpoint && !!projectAdminDistDir
 
-		console.log('')
-		console.log('Contember project deployment configuration:')
-		console.log(`Target project name: ${remoteProject.name}`)
-		console.log(`API URL: ${remoteProject.endpoint}`)
-		console.log(`Admin URL: ${remoteProject.adminEndpoint ?? 'none'}`)
-		console.log(`Deploy token: ${maskToken(remoteProject.token)}`)
-		console.log('')
+		output.info('')
+		output.info('Contember project deployment configuration:')
+		output.info(`Target project name: ${remoteProject.name}`)
+		output.info(`API URL: ${remoteProject.endpoint}`)
+		output.info(`Admin URL: ${remoteProject.adminEndpoint ?? 'none'}`)
+		output.info(`Deploy token: ${maskToken(remoteProject.token)}`)
+		output.info('')
 
 		if (deployAdmin && !(await this.fs.pathExists(`${projectAdminDistDir}/index.html`))) {
-			throw `Missing ${projectAdminDistDir}/index.html. Please build admin before deploying.`
+			throw new CliError(`Missing ${projectAdminDistDir}/index.html. Please build admin before deploying.`, {
+				code: 'ADMIN_BUILD_MISSING',
+				exitCode: ExitCode.InputError,
+				details: { path: `${projectAdminDistDir}/index.html` },
+			})
 		}
 
+		let migrationsConfirmed = false
+		let migrationsDeployed = false
 		if (deployMigration) {
-			const result = await this.migrationExecutionFacade.execute({
+			migrationsDeployed = await this.migrationExecutionFacade.execute({
 				force: false,
 				requireConfirmation: !yes,
 				additionalMessage: deployAdmin ? 'Admin will be deployed.' : 'Admin will NOT be deployed.',
 				useSnapshot: input.getOption('snapshot') === true,
+				onConfirmed: () => {
+					migrationsConfirmed = true
+				},
 			})
-			if (!result) {
-				return
-			}
 		}
 
+		let adminDeployed = false
 		if (deployAdmin) {
-			if (!deployMigration && !yes) {
-				if (!process.stdin.isTTY) {
-					throw 'TTY not available. Pass --yes option to confirm execution.'
+			if (!migrationsDeployed && !migrationsConfirmed && !yes) {
+				if (!output.canPrompt()) {
+					throw new CliError('TTY not available. Pass --yes to confirm execution.', {
+						code: 'TTY_UNAVAILABLE',
+						exitCode: ExitCode.InputError,
+					})
 				}
-				console.log('Admin will be deployed.')
-				console.log('(to skip this dialog, you can pass --yes option)')
-				console.log('')
-				const { ok } = await prompts({
-					type: 'confirm',
-					name: 'ok',
+				output.info('Admin will be deployed.')
+				output.info('(to skip this dialog, you can pass --yes option)')
+				output.info('')
+				const ok = await promptConfirm(output, {
 					message: `Do you want to continue?`,
 				})
 				if (!ok) {
@@ -111,12 +133,29 @@ export class DeployCommand extends Command<Args, Options> {
 				dir: projectAdminDistDir,
 				root: input.getOption('root') === true,
 			})
+			adminDeployed = true
 		}
 
-		console.log('')
-		console.log('Deployment successful')
-		console.log(`API URL: ${remoteProject.endpoint}`)
-		console.log(`Admin URL: ${remoteProject.adminEndpoint ?? 'none'}`)
+		const deployResult: DeployResult = {
+			project: remoteProject.name,
+			apiUrl: remoteProject.endpoint,
+			adminUrl: remoteProject.adminEndpoint ?? null,
+			migrationsDeployed,
+			adminDeployed,
+		}
+		output.data(
+			deployResult,
+			{
+				human: it =>
+					[
+						'',
+						'Deployment successful',
+						`API URL: ${escapeTerminalText(it.apiUrl)}`,
+						`Admin URL: ${it.adminUrl === null ? 'none' : escapeTerminalText(it.adminUrl)}`,
+					].join('\n'),
+				quiet: it => it.apiUrl,
+			},
+		)
 
 		return 0
 	}

package/src/commands/migrations/MigrationAmendCommand.ts

@@ -1,6 +1,5 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
 import { InvalidSchemaException, SchemaMigrator } from '@contember/schema-migrations'
-import prompts from 'prompts'
 import { emptySchema } from '@contember/schema-utils'
 import { MigrationCreator, MigrationsResolver, SchemaStateManager, SchemaVersionBuilder } from '@contember/migrations-client'
 import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade.js'
@@ -9,6 +8,7 @@ import { MigrationsValidator } from '../../lib/migrations/MigrationsValidator.js
 import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter.js'
 import { printValidationErrors } from '../../lib/schema/SchemaValidationPrinter.js'
 import { SystemClientProvider } from '../../lib/SystemClientProvider.js'
+import { promptSelect } from '../../lib/prompt/index.js'
 
 type Args = {
 	migration?: string
@@ -45,18 +45,21 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 			.description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
 		const migrationName = input.getArgument('migration')
 		const amendMigration = migrationName
 			? await this.migrationsResolver.findSchemaMigrationByVersion(migrationName)
 			: await this.migrationsResolver.findLatestSchemaMigration()
 		if (!amendMigration) {
-			throw 'No migration to amend'
+			throw new CliError('No migration to amend', { code: 'MIGRATION_NOT_FOUND', exitCode: ExitCode.NotFound })
 		}
 		const force = input.getOption('force')
 		const status = await this.migrationsStatusFacade.resolveMigrationsStatus({ force })
 		if (status.migrationsToExecute.length > 0) {
-			throw `Some migrations are not executed. Unable to amend.`
+			throw new CliError('Some migrations are not executed. Unable to amend.', {
+				code: 'MIGRATIONS_NOT_EXECUTED',
+				exitCode: ExitCode.InputError,
+			})
 		}
 
 		const schema = await this.schemaLoader.loadSchema()
@@ -72,15 +75,27 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 
 			if (intermediateResult === null) {
 				if (stateChanged) {
-					await this.schemaStateManager.writeState(schemaState!)
-					console.log('Schema state updated (no model changes)')
+					if (!(await this.shouldContinue(input, output))) {
+						throw abortedError('Migration amendment')
+					}
+					if (schemaState === undefined) {
+						throw new CliError('Schema state is unavailable', { code: 'SCHEMA_STATE_UNAVAILABLE', exitCode: ExitCode.InternalError })
+					}
+					await this.schemaStateManager.writeState(schemaState)
 				} else {
-					console.log('Nothing to do')
+					output.info('Nothing to do')
 				}
+				output.data(
+					{ migration: amendMigration.name, stateUpdated: stateChanged, changed: stateChanged },
+					{ human: value => value.changed ? 'Schema state updated (no model changes)' : 'Nothing to do', quiet: value => value.migration },
+				)
 				return 0
 			}
 			if (amendMigration.formatVersion !== intermediateResult.migration.formatVersion) {
-				throw 'Incompatible migration format version'
+				throw new CliError('Incompatible migration format version', {
+					code: 'MIGRATION_FORMAT_INCOMPATIBLE',
+					exitCode: ExitCode.InputError,
+				})
 			}
 			const prevSchema = await this.schemaVersionBuilder.buildSchemaAdvanced(
 				emptySchema,
@@ -103,7 +118,7 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 				[...(newMigrationResult ? [newMigrationResult.migration] : []), ...followingMigrations],
 			)
 			if (!valid) {
-				throw `Cannot amend migration`
+				throw new CliError('Cannot amend migration', { code: 'MIGRATIONS_INVALID', exitCode: ExitCode.InputError })
 			}
 
 			this.migrationPrinter.printMigrationDescription(
@@ -111,16 +126,15 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 				intermediateResult.migration,
 				{ noSql: true },
 			)
-			console.log(`Amending ${amendMigration.name}`)
-			if (!(await this.shouldContinue(input))) {
-				console.log('Aborting')
-				return 1
+			output.info(`Amending ${amendMigration.name}`)
+			if (!(await this.shouldContinue(input, output))) {
+				throw abortedError('Migration amendment')
 			}
 			const systemClient = this.systemApiClientProvider.get()
 			await systemClient.migrate([intermediateResult.migration], force)
 			await systemClient.migrationDelete(intermediateResult.migration.version)
 
-			if (!newMigrationResult && await this.shouldRemove()) {
+			if (!newMigrationResult && await this.shouldRemove(input, output)) {
 				await this.migrationCreator.removeMigration(amendMigration.name)
 				await systemClient.migrationDelete(amendMigration.version)
 				if (schemaState) {
@@ -129,7 +143,10 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 					// non-model state; re-apply it so the server stays in sync with the state files.
 					await systemClient.migrate([], force, schemaState)
 				}
-				console.log('Latest migration was removed')
+				output.data(
+					{ migration: amendMigration.name, removed: true, stateUpdated: schemaState !== undefined },
+					{ human: () => 'Latest migration was removed', quiet: value => value.migration },
+				)
 				return 0
 			}
 			const newMigration = {
@@ -147,25 +164,33 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 				// non-model state; re-apply it so the server stays in sync with the state files.
 				await systemClient.migrate([], force, schemaState)
 			}
+			output.data(
+				{ migration: amendMigration.name, removed: false, stateUpdated: schemaState !== undefined },
+				{ human: value => `Amended ${value.migration}`, quiet: value => value.migration },
+			)
 
 			return 0
 		} catch (e) {
 			if (e instanceof InvalidSchemaException) {
-				printValidationErrors(e.validationErrors, e.message)
-				return 1
+				printValidationErrors(e.validationErrors, e.message, output)
+				throw new CliError(e.message, {
+					code: 'SCHEMA_INVALID',
+					exitCode: ExitCode.InputError,
+					details: e.validationErrors,
+					cause: e,
+				})
 			}
 			throw e
 		}
 	}
 
-	private async shouldContinue(input: Input<{}, { yes?: true }>): Promise<boolean> {
+	private async shouldContinue(input: Input<{}, { yes?: true }>, output: Output): Promise<boolean> {
 		const yes = input.getOption('yes')
 		if (yes) {
 			return true
 		}
-		const { action } = await prompts({
-			type: 'select',
-			name: 'action',
+		assertCanPrompt(output)
+		const action = await promptSelect(output, {
 			message: 'Do you want to continue?',
 			choices: [
 				{ value: 'yes', title: 'Yes' },
@@ -175,10 +200,13 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 		return action === 'yes'
 	}
 
-	private async shouldRemove(): Promise<boolean> {
-		const { action } = await prompts({
-			type: 'select',
-			name: 'action',
+	/** With --yes the migration is kept and emptied — removing a file that others may have already executed is not safe to assume. */
+	private async shouldRemove(input: Input<{}, { yes?: true }>, output: Output): Promise<boolean> {
+		if (input.getOption('yes')) {
+			return false
+		}
+		assertCanPrompt(output)
+		const action = await promptSelect(output, {
 			message:
 				'The amendment results in a no-op migration because the changes introduced by the latest migration were reverted.\nYou can choose to remove the latest migration or to modify it so it is empty.',
 			choices: [
@@ -189,3 +217,18 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 		return action === 'remove'
 	}
 }
+
+const abortedError = (operation: string): CliError =>
+	new CliError(`${operation} aborted`, {
+		code: 'OPERATION_ABORTED',
+		exitCode: ExitCode.InputError,
+	})
+
+const assertCanPrompt = (output: Output): void => {
+	if (!output.canPrompt()) {
+		throw new CliError('TTY not available. Pass --yes to confirm execution.', {
+			code: 'TTY_UNAVAILABLE',
+			exitCode: ExitCode.InputError,
+		})
+	}
+}

package/src/commands/migrations/MigrationBlankCommand.ts

@@ -1,4 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
 import { MigrationCreator } from '@contember/migrations-client'
 
 type Args = {
@@ -22,11 +22,11 @@ export class MigrationBlankCommand extends Command<Args, Options> {
 			.description('Migration file format (js, ts, json), default is ts.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
 		const migrationName = input.getArgument('migrationName')
 		const migrationFormat = input.getArgument('format') || 'ts'
 		const filename = await this.migrationCreator.createEmptyMigrationFile(migrationName, migrationFormat)
-		console.log(`${filename} created`)
+		output.data({ path: filename }, { human: value => `${value.path} created`, quiet: value => value.path })
 		return 0
 	}
 }

package/src/commands/migrations/MigrationDescribeCommand.ts

@@ -1,4 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
 import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter.js'
 import { MigrationsResolver, SchemaVersionBuilder } from '@contember/migrations-client'
 
@@ -27,7 +27,7 @@ export class MigrationDescribeCommand extends Command<Args, Options> {
 		configuration.option('no-sql').valueNone()
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
 		const migrationArg = input.getArgument('migration')
 		const sqlOnly = input.getOption('sql-only')
 		const noSql = input.getOption('no-sql')
@@ -37,9 +37,14 @@ export class MigrationDescribeCommand extends Command<Args, Options> {
 			: await this.migrationsResolver.findLatestSchemaMigration()
 
 		if (!migration) {
-			throw 'Undefined migration'
+			throw new CliError('Undefined migration', { code: 'MIGRATION_NOT_FOUND', exitCode: ExitCode.NotFound })
 		}
 		const schema = await this.schemaVersionBuilder.buildSchemaUntil(migration.version)
-		this.migrationPrinter.printMigrationDescription(schema, migration, { sqlOnly, noSql })
+		// the description is what the user asked for, so it is data: structured with --json, formatted for a human otherwise
+		const description = this.migrationPrinter.describeMigration(schema, migration)
+		output.data(description, {
+			human: it => this.migrationPrinter.formatMigrationDescription(it, { sqlOnly, noSql }),
+			quiet: () => migration.version,
+		})
 	}
 }

package/src/commands/migrations/MigrationDiffCommand.ts

@@ -1,11 +1,13 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
 import { InvalidSchemaException } from '@contember/schema-migrations'
-import prompts from 'prompts'
 import { MigrationCreator, MigrationsResolver, SchemaStateManager, SchemaVersionBuilder } from '@contember/migrations-client'
 import { SchemaLoader } from '../../lib/schema/SchemaLoader.js'
 import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter.js'
 import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade.js'
 import { printValidationErrors } from '../../lib/schema/SchemaValidationPrinter.js'
+import { promptConfirm, promptSelect } from '../../lib/prompt/index.js'
+
+type MigrationExecutor = Pick<MigrationExecutionFacade, 'execute'>
 
 type Args = {
 	migrationName: string
@@ -24,7 +26,7 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly migrationCreator: MigrationCreator,
 		private readonly migrationPrinter: MigrationPrinter,
-		private readonly migrationExecutorFacade: MigrationExecutionFacade,
+		private readonly migrationExecutorFacade: MigrationExecutor,
 		private readonly schemaStateManager: SchemaStateManager,
 		private readonly migrationsResolver: MigrationsResolver,
 	) {
@@ -49,7 +51,7 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 			)
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
 		const migrationName = input.getArgument('migrationName')
 		let shouldExecute = input.getOption('execute')
 		const yes = input.getOption('yes')
@@ -58,13 +60,14 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 
 		const schema = await this.schemaLoader.loadSchema()
 		let stateMode = await this.schemaStateManager.isStateMode()
+		let initializeStateMode = false
 
-		// New project (no migrations yet) defaults to schema state mode. To opt out, create a migration first (e.g. `migrations:blank`).
+		// New project (no migrations yet) defaults to schema state mode. To opt out, create a migration first (e.g. `migrations blank`).
 		if (!stateMode && (await this.migrationsResolver.getSchemaMigrations()).length === 0) {
-			console.log('No migrations found — enabling schema state mode for this project.')
-			console.log('ACL, validation, actions and settings will be managed in the state/ directory instead of migrations.')
-			await this.schemaStateManager.extractState(schema)
+			output.info('No migrations found — enabling schema state mode for this project.')
+			output.info('ACL, validation, actions and settings will be managed in the state/ directory instead of migrations.')
 			stateMode = true
+			initializeStateMode = true
 		}
 
 		try {
@@ -80,26 +83,55 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 
 			if (result === null) {
 				if (stateChanged) {
-					console.log('Schema state updated (no model changes)')
-					await this.schemaStateManager.writeState(schemaState!)
+					if (!yes) {
+						if (!output.canPrompt()) {
+							throw new CliError('TTY not available. Pass --yes to confirm the schema state update.', {
+								code: 'TTY_UNAVAILABLE',
+								exitCode: ExitCode.InputError,
+							})
+						}
+						const confirmed = await promptConfirm(output, {
+							message: 'Write the schema state changes?',
+							initial: false,
+						})
+						if (!confirmed) {
+							throw abortedError('Schema state update')
+						}
+					}
+					if (schemaState === undefined) {
+						throw new CliError('Schema state is unavailable', { code: 'SCHEMA_STATE_UNAVAILABLE', exitCode: ExitCode.InternalError })
+					}
+					if (initializeStateMode) {
+						await this.schemaStateManager.extractState(schema)
+					} else {
+						await this.schemaStateManager.writeState(schemaState)
+					}
 				} else {
-					console.log('Nothing to do')
+					output.info('Nothing to do')
 				}
 				if (stateChanged && shouldExecute) {
-					console.log('Syncing schema state to server...')
+					output.info('Syncing schema state to server...')
 					await this.migrationExecutorFacade.execute({
 						force: false,
 						requireConfirmation: false,
 					})
 				}
+				output.data(
+					{ migration: null, stateUpdated: stateChanged, executed: stateChanged && shouldExecute === true },
+					{ human: value => value.stateUpdated ? 'Schema state updated' : 'Nothing to do', quiet: value => value.stateUpdated },
+				)
 				return
 			}
 			this.migrationPrinter.printMigrationDescription(result.initialSchema, result.migration, { noSql: true })
 
 			if (!yes) {
-				const { action } = await prompts({
-					type: 'select',
-					name: 'action',
+				if (!output.canPrompt()) {
+					throw new CliError('TTY not available. Pass --yes to confirm execution.', {
+						code: 'TTY_UNAVAILABLE',
+						exitCode: ExitCode.InputError,
+					})
+				}
+				const action = await promptSelect(output, {
 					message: 'Do you want to continue?',
 					choices: [
 						{ value: 'yes', title: 'Yes' },
@@ -108,8 +140,7 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 					],
 				})
 				if (!action || action === 'no') {
-					console.log('Aborting')
-					return
+					throw abortedError('Migration creation')
 				}
 				if (action === 'execute') {
 					shouldExecute = true
@@ -118,27 +149,48 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 
 			const filename = await this.migrationCreator.saveMigration(result.migration)
 			if (stateChanged) {
-				await this.schemaStateManager.writeState(schemaState!)
+				if (schemaState === undefined) {
+					throw new CliError('Schema state is unavailable', { code: 'SCHEMA_STATE_UNAVAILABLE', exitCode: ExitCode.InternalError })
+				}
+				if (initializeStateMode) {
+					await this.schemaStateManager.extractState(schema)
+				} else {
+					await this.schemaStateManager.writeState(schemaState)
+				}
 			}
-
-			console.log(`${filename} created`)
 			if (stateChanged) {
-				console.log('Schema state files updated')
+				output.info('Schema state files updated')
+			}
+
+			if (shouldExecute) {
+				await this.migrationExecutorFacade.execute({
+					force: false,
+					requireConfirmation: yes
+						? false
+						: migrations => migrations.some(migration => migration.name !== result.migration.name),
+				})
 			}
+			output.data(
+				{ migration: filename, stateUpdated: stateChanged, executed: shouldExecute === true },
+				{ human: value => `${value.migration} created`, quiet: value => value.migration },
+			)
 		} catch (e) {
 			if (e instanceof InvalidSchemaException) {
-				printValidationErrors(e.validationErrors, e.message)
-
-				return
+				printValidationErrors(e.validationErrors, e.message, output)
+				throw new CliError(e.message, {
+					code: 'SCHEMA_INVALID',
+					exitCode: ExitCode.InputError,
+					details: e.validationErrors,
+					cause: e,
+				})
 			}
 			throw e
 		}
-
-		if (shouldExecute) {
-			await this.migrationExecutorFacade.execute({
-				force: false,
-				requireConfirmation: migrations => migrations.length !== 1 && !yes,
-			})
-		}
 	}
 }
+
+const abortedError = (operation: string): CliError =>
+	new CliError(`${operation} aborted`, {
+		code: 'OPERATION_ABORTED',
+		exitCode: ExitCode.InputError,
+	})

package/src/commands/migrations/MigrationExecuteCommand.ts

@@ -1,4 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
 import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade.js'
 
 type Args = {}
@@ -10,9 +10,11 @@ type Options = {
 	['no-snapshot']?: boolean
 }
 
+type MigrationExecutor = Pick<MigrationExecutionFacade, 'execute'>
+
 export class MigrationExecuteCommand extends Command<Args, Options> {
 	constructor(
-		private readonly migrationExecutorFacade: MigrationExecutionFacade,
+		private readonly migrationExecutorFacade: MigrationExecutor,
 	) {
 		super()
 	}
@@ -33,15 +35,20 @@ export class MigrationExecuteCommand extends Command<Args, Options> {
 			.description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
 		const force = input.getOption('force')
 		const until = input.getOption('until')
 
-		await this.migrationExecutorFacade.execute({
+		const changed = await this.migrationExecutorFacade.execute({
 			force,
 			until,
 			requireConfirmation: !input.getOption('yes'),
 			useSnapshot: input.getOption('no-snapshot') !== true,
 		})
+		const result = { status: changed ? 'completed' : 'noop', until: until ?? null }
+		output.data(result, {
+			human: value => value.status === 'completed' ? 'Migrations executed' : 'No migrations to execute',
+			quiet: value => value.status,
+		})
 	}
 }