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

package/src/commands/migrations/MigrationInitStateCommand.ts

@@ -1,4 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
 import { SchemaStateManager } from '@contember/migrations-client'
 import { SchemaLoader } from '../../lib/schema/SchemaLoader.js'
 
@@ -6,6 +6,11 @@ type Args = {}
 
 type Options = {}
 
+type InitStateResult = {
+	enabled: true
+	changed: boolean
+}
+
 export class MigrationInitStateCommand extends Command<Args, Options> {
 	constructor(
 		private readonly schemaLoader: SchemaLoader,
@@ -18,17 +23,25 @@ export class MigrationInitStateCommand extends Command<Args, Options> {
 		configuration.description('Enables schema state mode by extracting ACL, validation, actions and settings into the state/ directory')
 	}
 
-	protected async execute(): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
 		if (await this.schemaStateManager.isStateMode()) {
-			console.log('Schema state mode is already enabled')
+			output.info('Schema state mode is already enabled')
+			writeMachineResult(output, { enabled: true, changed: false })
 			return 0
 		}
 
 		const schema = await this.schemaLoader.loadSchema()
 		await this.schemaStateManager.extractState(schema)
 
-		console.log('Schema state mode enabled. ACL, validation, actions and settings are now managed in the state/ directory.')
-		console.log('These parts of the schema will no longer be written into migrations.')
+		output.info('Schema state mode enabled. ACL, validation, actions and settings are now managed in the state/ directory.')
+		output.info('These parts of the schema will no longer be written into migrations.')
+		writeMachineResult(output, { enabled: true, changed: true })
 		return 0
 	}
 }
+
+const writeMachineResult = (output: Output, result: InitStateResult): void => {
+	if (output.mode !== 'human') {
+		output.data(result, { quiet: value => value.changed })
+	}
+}

package/src/commands/migrations/MigrationRebaseCommand.ts

@@ -1,6 +1,9 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
 import { Migration, MigrationsResolver } from '@contember/migrations-client'
 import { MigrationRebaseFacade } from '../../lib/migrations/MigrationRebaseFacade.js'
+import { promptConfirm } from '../../lib/prompt/index.js'
+
+type MigrationRebaser = Pick<MigrationRebaseFacade, 'rebase'>
 
 type Args = {
 	migration: string[]
@@ -13,7 +16,7 @@ type Options = {
 export class MigrationRebaseCommand extends Command<Args, Options> {
 	constructor(
 		private readonly migrationsResolver: MigrationsResolver,
-		private readonly migrationRebaseFacade: MigrationRebaseFacade,
+		private readonly migrationRebaseFacade: MigrationRebaser,
 	) {
 		super()
 	}
@@ -27,20 +30,39 @@ export class MigrationRebaseCommand 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 migrationNames = input.getArgument('migration')
 
 		const migrations: Migration[] = []
 		for (const migrationName of migrationNames) {
 			const migration = await this.migrationsResolver.findSchemaMigrationByVersion(migrationName)
 			if (!migration) {
-				throw `Migration ${migrationName} not found`
+				throw new CliError(`Migration ${migrationName} not found`, { code: 'MIGRATION_NOT_FOUND', exitCode: ExitCode.NotFound })
 			}
 			migrations.push(migration)
 		}
 
-		console.log('Rebasing: ' + migrations.map(it => it.name).join(', '))
+		output.info('Rebasing: ' + migrations.map(it => it.name).join(', '))
+		if (!input.getOption('yes')) {
+			if (!output.canPrompt()) {
+				throw new CliError('TTY not available. Pass --yes to confirm rebasing.', {
+					code: 'TTY_UNAVAILABLE',
+					exitCode: ExitCode.InputError,
+				})
+			}
+			const confirmed = await promptConfirm(output, {
+				message: 'Rewrite these migrations?',
+				initial: false,
+			})
+			if (!confirmed) {
+				throw new CliError('Migration rebase aborted', { code: 'OPERATION_ABORTED', exitCode: ExitCode.InputError })
+			}
+		}
 		await this.migrationRebaseFacade.rebase(migrations)
-		console.log('Done')
+		const result = { migrations: migrations.map(it => it.name), count: migrations.length }
+		output.data(result, {
+			human: value => `Rebased ${value.count} migration(s)`,
+			quiet: value => value.migrations,
+		})
 	}
 }

package/src/commands/migrations/MigrationSnapshotCommand.ts

@@ -1,9 +1,12 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
 import { MigrationSnapshotFacade } from '../../lib/migrations/MigrationSnapshotFacade.js'
+import { promptConfirm } from '../../lib/prompt/index.js'
 
 type Args = {}
 
-type Options = {}
+type Options = {
+	yes?: true
+}
 
 export class MigrationSnapshotCommand extends Command<Args, Options> {
 	constructor(
@@ -16,19 +19,51 @@ export class MigrationSnapshotCommand extends Command<Args, Options> {
 		configuration.description(
 			'Creates a schema snapshot (snapshot.json) that bootstraps a fresh database in one step instead of replaying every migration',
 		)
+		configuration.option('yes').valueNone().description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
-		const snapshot = await this.migrationSnapshotFacade.create()
-		console.log(`Snapshot created: ${snapshot.covers.length} migrations collapsed up to ${snapshot.version}.`)
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
+		const snapshot = await this.migrationSnapshotFacade.prepare()
+		output.info(`Will collapse ${snapshot.covers.length} migrations up to ${snapshot.version} into snapshot.json.`)
 
 		if (snapshot.contentMigrations.length > 0) {
-			console.warn('')
-			console.warn(`Warning: ${snapshot.contentMigrations.length} content (data) migration(s) are covered by this snapshot:`)
-			snapshot.contentMigrations.forEach(version => console.warn(`  - ${version}`))
-			console.warn('Their data effects are NOT reproduced when bootstrapping from the snapshot.')
-			console.warn('Seed any required data manually for local development.')
+			output.warn('')
+			output.warn(`Warning: ${snapshot.contentMigrations.length} content (data) migration(s) are covered by this snapshot:`)
+			snapshot.contentMigrations.forEach(version => output.warn(`  - ${version}`))
+			output.warn('Their data effects are NOT reproduced when bootstrapping from the snapshot.')
+			output.warn('Seed any required data manually for local development.')
+		}
+
+		if (!input.getOption('yes')) {
+			if (!output.canPrompt()) {
+				throw new CliError('TTY not available. Pass --yes to confirm snapshot creation.', {
+					code: 'TTY_UNAVAILABLE',
+					exitCode: ExitCode.InputError,
+				})
+			}
+			const confirmed = await promptConfirm(output, {
+				message: 'Write snapshot.json?',
+				initial: false,
+			})
+			if (!confirmed) {
+				throw new CliError('Snapshot creation aborted', {
+					code: 'OPERATION_ABORTED',
+					exitCode: ExitCode.InputError,
+				})
+			}
+		}
+
+		await this.migrationSnapshotFacade.write(snapshot)
+		const result = {
+			version: snapshot.version,
+			coveredMigrations: snapshot.covers.length,
+			contentMigrations: snapshot.contentMigrations,
+			path: 'snapshot.json',
 		}
+		output.data(result, {
+			human: value => `Snapshot created: ${value.coveredMigrations} migrations collapsed up to ${value.version}.`,
+			quiet: value => value.path,
+		})
 		return 0
 	}
 }

package/src/commands/migrations/MigrationStatusCommand.ts

@@ -1,8 +1,7 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
-import { MigrationFilesManager, MigrationState, sortMigrations, SystemClient } from '@contember/migrations-client'
-import chalk from 'chalk'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
+import { MigrationFilesManager, MigrationState, sortMigrations } from '@contember/migrations-client'
 import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade.js'
-import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter.js'
+import { MigrationPrinter, migrationStatusColumns } from '../../lib/migrations/MigrationPrinter.js'
 import { SystemClientProvider } from '../../lib/SystemClientProvider.js'
 
 type Args = {}
@@ -13,12 +12,20 @@ type Options = {
 	['restore-missing']?: true
 }
 
+type MigrationStatusResolver = Pick<MigrationsStatusFacade, 'resolveMigrationsStatus'>
+type MigrationFileWriter = Pick<MigrationFilesManager, 'createFile'>
+type MigrationStatusPrinter = Pick<MigrationPrinter, 'statusRows'>
+
+interface MigrationSystemClientProvider {
+	get(): Pick<ReturnType<SystemClientProvider['get']>, 'getExecutedMigration'>
+}
+
 export class MigrationStatusCommand extends Command<Args, Options> {
 	constructor(
-		private readonly migrationsStatusFacade: MigrationsStatusFacade,
-		private readonly migrationFilesManager: MigrationFilesManager,
-		private readonly systemClientProvider: SystemClientProvider,
-		private readonly migrationPrinter: MigrationPrinter,
+		private readonly migrationsStatusFacade: MigrationStatusResolver,
+		private readonly migrationFilesManager: MigrationFileWriter,
+		private readonly systemClientProvider: MigrationSystemClientProvider,
+		private readonly migrationPrinter: MigrationStatusPrinter,
 	) {
 		super()
 	}
@@ -39,7 +46,7 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 			.description('Restores migrations locally missing')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
 		const onlyErrors = input.getOption('only-errors')
 		const onlyToExecute = input.getOption('only-to-execute')
 		const restoreMissing = input.getOption('restore-missing')
@@ -49,7 +56,7 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 		if (restoreMissing) {
 			const missing = status.errorMigrations.filter(it => it.state === MigrationState.EXECUTED_MISSING)
 			for (const migration of missing) {
-				console.log(`Restoring migration ${migration.name}`)
+				output.info(`Restoring migration ${migration.name}`)
 				const fullMigration = await this.systemClientProvider.get().getExecutedMigration(migration.version)
 				await this.migrationFilesManager.createFile(
 					JSON.stringify(
@@ -73,12 +80,13 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 			])
 			: status.allMigrations
 
-		console.log(this.migrationPrinter.printStatusTable(filtered))
+		// the status is the answer of this command, so it goes to stdout — as a table, JSON or bare names
+		output.table(migrationStatusColumns, this.migrationPrinter.statusRows(filtered), 'migration')
 
 		const hasErrors = status.errorMigrations.length > 0
 
 		if (hasErrors) {
-			console.error(chalk.redBright('Some migrations are broken'))
+			output.error('Some migrations are broken')
 		}
 
 		return hasErrors ? 1 : 0

package/src/commands/migrations/MigrationVerifySnapshotCommand.ts

@@ -1,4 +1,4 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
 import { MigrationSnapshotFacade } from '../../lib/migrations/MigrationSnapshotFacade.js'
 
 type Args = {}
@@ -16,13 +16,12 @@ export class MigrationVerifySnapshotCommand extends Command<Args, Options> {
 		configuration.description('Verifies that snapshot.json still matches a full replay of all migrations')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<number> {
 		const result = await this.migrationSnapshotFacade.verify()
-		if (result.ok) {
-			console.log(result.message)
-			return 0
-		}
-		console.error(result.message)
-		return 1
+		output.data(result, {
+			human: value => value.message,
+			quiet: value => value.ok,
+		})
+		return result.ok ? 0 : 1
 	}
 }

package/src/commands/misc/CommandsCommand.ts

@@ -0,0 +1,74 @@
+import { Command, CommandConfiguration, CommandManager, globalOptions, Input, mergeOptions, Output } from '@contember/cli-common'
+
+type Args = {}
+type Options = {}
+
+interface CommandInfo {
+	name: string
+	group: string | null
+	description: string
+	aliases: string[]
+	arguments: { name: string; description: string | null; optional: boolean; variadic: boolean }[]
+	options: {
+		name: string
+		shortcut: string | null
+		description: string | null
+		mode: string
+		required: boolean
+		deprecated: boolean
+		global: boolean
+	}[]
+}
+
+/** Machine readable catalog of the whole CLI — the entry point for an agent discovering the available commands. */
+export class CommandsCommand extends Command<Args, Options> {
+	private commandManager: CommandManager | undefined = undefined
+
+	/** Set by the container: the catalog contains this very command, so the dependency cannot be constructor injected. */
+	public setCommandManager(commandManager: CommandManager): void {
+		this.commandManager = commandManager
+	}
+
+	protected configure(configuration: CommandConfiguration<Args, Options>): void {
+		configuration.description('Lists all commands with their arguments and options')
+	}
+
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
+		if (this.commandManager === undefined) {
+			throw new Error('Command manager is not set')
+		}
+		const commands = this.commandManager.getCommands().map((entry): CommandInfo => {
+			const configuration = entry.create().getConfiguration()
+			const commandOptions = configuration.getOptions()
+			return {
+				name: entry.name,
+				group: entry.group ?? null,
+				description: configuration.getDescription(),
+				aliases: [...entry.aliases],
+				arguments: configuration.getArguments().map(it => ({
+					name: it.name,
+					description: it.description ?? null,
+					optional: it.optional,
+					variadic: it.variadic,
+				})),
+				options: mergeOptions(commandOptions, globalOptions).map(it => ({
+					name: it.name,
+					shortcut: it.shortcut ?? null,
+					description: it.description ?? null,
+					mode: it.mode,
+					required: it.required,
+					deprecated: it.deprecated,
+					global: !commandOptions.includes(it),
+				})),
+			}
+		})
+
+		output.data(commands, {
+			human: it => {
+				const width = Math.max(0, ...it.map(command => command.name.length))
+				return it.map(command => `${command.name.padEnd(width)}    ${command.description}`).join('\n')
+			},
+			quiet: it => it.map(command => command.name),
+		})
+	}
+}

package/src/commands/misc/VersionCommand.ts

@@ -1,17 +1,24 @@
-import { Command, CommandConfiguration } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input, Output } from '@contember/cli-common'
 
-export class VersionCommand extends Command<{}, {}> {
+type Args = {}
+type Options = {}
+
+/**
+ * The reference implementation of the output contract: the value goes to stdout through `output.data`,
+ * which renders it as plain text for a human, as JSON with --json and bare with --quiet.
+ */
+export class VersionCommand extends Command<Args, Options> {
 	constructor(
 		private readonly version: string,
 	) {
 		super()
 	}
-	protected configure(configuration: CommandConfiguration<{}, {}>): void {
+
+	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Prints Contember CLI version')
 	}
 
-	protected async execute(): Promise<void | number> {
-		console.log(this.version)
-		return 0
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
+		output.data(this.version, it => it)
 	}
 }

package/src/commands/misc/index.ts

@@ -1 +1,2 @@
+export * from './CommandsCommand.js'
 export * from './VersionCommand.js'

package/src/commands/project/ProjectGenerateDocumentationCommand.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 { renderProjectInfoHtml } from '../../lib/project/docs/projectDescribe.js'
 import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
@@ -18,6 +18,7 @@ export class ProjectGenerateDocumentationCommand extends Command<Args, Options>
 	constructor(
 		private readonly schemaLoader: SchemaLoader,
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly renderDocumentation: typeof renderProjectInfoHtml = renderProjectInfoHtml,
 	) {
 		super()
 	}
@@ -29,24 +30,22 @@ export class ProjectGenerateDocumentationCommand extends Command<Args, Options>
 		configuration.option('name').valueRequired().description('project name (for the title)')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
 		const schema = input.getOption('source') === 'migrations'
 			? await this.schemaVersionBuilder.buildSchema()
 			: await this.schemaLoader.loadSchema()
-		if (!validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:')) {
-			return 1
+		if (!validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:', undefined, output)) {
+			throw new CliError('Defined schema is invalid', { code: 'SCHEMA_INVALID', exitCode: ExitCode.InputError })
 		}
 		const name = input.getOption('name') ?? 'Contember project'
 
-		const html = await renderProjectInfoHtml(schema, name)
-		const output = input.getOption('output') ?? `${name.toLowerCase().replace(/\s+/g, '-')}.html`
-		if (output === '-') {
-			console.log(html)
-		} else {
-			console.log(`Documentation saved to ${output}`)
-			await writeFile(join(process.cwd(), output), html)
+		const html = await this.renderDocumentation(schema, name)
+		const destination = input.getOption('output') ?? `${name.toLowerCase().replace(/\s+/g, '-')}.html`
+		if (destination === '-') {
+			output.data(html, { human: value => value, quiet: () => destination })
+			return
 		}
-
-		return 0
+		await writeFile(join(process.cwd(), destination), html)
+		output.data({ path: destination }, { human: it => `Documentation saved to ${it.path}`, quiet: it => it.path })
 	}
 }

package/src/commands/project/ProjectPrintSchemaCommand.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 {
 	Authorizator,
 	EntityRulesResolver,
@@ -47,7 +47,7 @@ export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 		configuration.option('omit-settings').valueNone()
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
 		const format = input.getOption('format') || 'graphql'
 
 		const schema = input.getOption('source') === 'migrations'
@@ -62,8 +62,8 @@ export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 			settings: input.getOption('omit-settings') ? emptySchema.settings : schema.settings,
 		}
 
-		if (!validateSchemaAndPrintErrors(filteredSchema, 'Defined schema is invalid:')) {
-			return 1
+		if (!validateSchemaAndPrintErrors(filteredSchema, 'Defined schema is invalid:', undefined, output)) {
+			throw new CliError('Defined schema is invalid', { code: 'SCHEMA_INVALID', exitCode: ExitCode.InputError })
 		}
 
 		const permissionFactory = new PermissionFactory()
@@ -82,19 +82,20 @@ export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 			authorizator,
 		)
 
-		const printByLine = (out: string) => {
-			out.split('\n').forEach(line => {
-				process.stdout.write(line + '\n')
-			})
-		}
 		if (format === 'schema') {
 			if (inputRoles) {
-				throw `--roles option is not supported for "schema" format`
+				throw new CliError('The --role option is not supported for the "schema" format', { code: 'UNSUPPORTED_OPTION', exitCode: ExitCode.InputError })
 			}
-			const jsonString = JSON.stringify(schemaNormalized, null, '\t')
-			printByLine(jsonString)
+			// human mode keeps the tab-indented rendering; --json is a single JSON.stringify of the same value, not a re-encoding of this string
+			output.data(schemaNormalized, {
+				human: value => JSON.stringify(value, null, '\t'),
+				quiet: value => JSON.stringify(value),
+			})
 		} else if (format === 'introspection') {
-			printByLine(JSON.stringify(introspection.create(), null, '\t'))
+			output.data(introspection.create(), {
+				human: value => JSON.stringify(value, null, '\t'),
+				quiet: value => JSON.stringify(value),
+			})
 		} else if (format === 'graphql') {
 			const contentSchema = schemaBuilderFactory.create(schemaNormalized.model, authorizator).build()
 			const introspectionSchemaFactory = new IntrospectionSchemaDefinitionFactory(introspection)
@@ -104,11 +105,12 @@ export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 			})
 			gqlSchema.description = '' // this enforces schema definition print
 			const printedSchema = printSchema(gqlSchema).replace('""""""\n', '') // remove empty comment
-			printByLine(printedSchema)
+			output.data(printedSchema, {
+				human: value => value,
+				quiet: value => value.split('\n'),
+			})
 		} else {
-			throw `Unknown format ${format}`
+			throw new CliError(`Unknown schema format "${format}"`, { code: 'UNKNOWN_FORMAT', exitCode: ExitCode.InputError })
 		}
-
-		return 0
 	}
 }

package/src/commands/project/ProjectValidateCommand.ts

@@ -1,15 +1,21 @@
-import { Command, CommandConfiguration } from '@contember/cli-common'
-import { emptySchema } from '@contember/schema-utils'
-import { SchemaLoader } from '../../lib/schema/SchemaLoader.js'
-import { validateSchemaAndPrintErrors } from '../../lib/schema/SchemaValidationHelper.js'
+import { CliError, Command, CommandConfiguration, ExitCode, Input, Output } from '@contember/cli-common'
+import { emptySchema, SchemaValidator } from '@contember/schema-utils'
 import { MigrationsValidator } from '../../lib/migrations/MigrationsValidator.js'
 import { MigrationsResolver, SchemaVersionBuilder } from '@contember/migrations-client'
 import { SchemaDiffer } from '@contember/schema-migrations'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader.js'
 
 type Args = {}
 
 type Options = {}
 
+type ValidationIssue = {
+	source: 'schema' | 'built-schema' | 'migrations' | 'diff'
+	path: string
+	code: string
+	message: string
+}
+
 export class ProjectValidateCommand extends Command<Args, Options> {
 	constructor(
 		private readonly schemaLoader: SchemaLoader,
@@ -25,33 +31,61 @@ export class ProjectValidateCommand extends Command<Args, Options> {
 		configuration.description('Validates project schema')
 	}
 
-	protected async execute(): Promise<number> {
-		let projectValid = true
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void> {
+		const issues: ValidationIssue[] = []
 
+		// prints its own itemized diagnostics per offending migration; here we only need the pass/fail
 		const migrations = await this.migrationsResolver.getSchemaMigrations()
-		projectValid = this.migrationValidator.validate(emptySchema, migrations)
-			&& projectValid
+		if (!this.migrationValidator.validate(emptySchema, migrations)) {
+			issues.push({
+				source: 'migrations',
+				path: '',
+				code: 'MIGRATIONS_INVALID_SCHEMA',
+				message: 'One or more migrations produce an invalid schema; see the diagnostics above for details',
+			})
+		}
 
 		const schema = await this.schemaLoader.loadSchema()
-		projectValid = validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:')
-			&& projectValid
+		for (const err of SchemaValidator.validate(schema)) {
+			issues.push({ source: 'schema', path: err.path.join('.'), code: err.code, message: err.message })
+		}
 
 		const builtSchema = await this.schemaVersionBuilder.buildSchema()
-		projectValid = validateSchemaAndPrintErrors(builtSchema, 'Schema built from migrations is invalid:')
-			&& projectValid
+		for (const err of SchemaValidator.validate(builtSchema)) {
+			issues.push({ source: 'built-schema', path: err.path.join('.'), code: err.code, message: err.message })
+		}
 
-		if (projectValid) {
+		// comparing an already-invalid schema against migrations is meaningless — only diff once both sides are valid
+		if (issues.length === 0) {
 			const diff = await this.schemaDiffer.diffSchemas(builtSchema, schema)
 			if (diff.length > 0) {
-				console.log('Migrations are not in sync with a defined schema')
-				projectValid = false
+				issues.push({
+					source: 'diff',
+					path: '',
+					code: 'SCHEMA_MIGRATIONS_DIFF',
+					message: 'Migrations are not in sync with the defined schema',
+				})
 			}
 		}
 
-		if (projectValid) {
-			console.log('Project schema is valid')
+		const columns: { field: keyof ValidationIssue & string; name: string }[] = [
+			{ field: 'source', name: 'Source' },
+			{ field: 'path', name: 'Path' },
+			{ field: 'code', name: 'Code' },
+			{ field: 'message', name: 'Message' },
+		]
+		if (issues.length > 0) {
+			if (!output.isJson && !output.isQuiet) {
+				output.table(columns, issues, 'message')
+			}
+			throw new CliError(`Project schema is invalid: found ${issues.length} issue(s)`, {
+				code: 'SCHEMA_INVALID',
+				exitCode: ExitCode.InputError,
+				details: issues,
+			})
 		}
 
-		return projectValid ? 0 : 1
+		output.table(columns, issues, 'message')
+		output.info('Project schema is valid')
 	}
 }