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

package/src/commands/deploy/DeployCommand.ts

@@ -1,13 +1,13 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
-import prompts from 'prompts'
-import { maskToken } from '../../lib/maskToken'
-import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade'
-import { AdminDeployer } from '../../lib/admin/AdminDeployer'
-import { FileSystem } from '../../lib/fs/FileSystem'
-import { RemoteProject } from '../../lib/project/RemoteProject'
-import { Workspace } from '../../lib/workspace/Workspace'
-import { RemoteProjectProvider } from '../../lib/project/RemoteProjectProvider'
-import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
+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'
+import { FileSystem } from '../../lib/fs/FileSystem.js'
+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
@@ -19,12 +19,24 @@ type Options = {
 	['no-migrations']?: boolean
 	root?: boolean
 	yes?: boolean
+	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,
@@ -41,18 +53,24 @@ export class DeployCommand extends Command<Args, Options> {
 		configuration.option('root').valueNone()
 		configuration.option('no-admin').valueNone()
 		configuration.option('no-migrations').valueNone()
+		configuration.option('snapshot')
+			.valueNone()
+			.description('Bootstrap an empty target database from snapshot.json instead of replaying every migration')
 		configuration //
 			.option('yes')
 			.valueNone()
 			.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)
 
@@ -62,40 +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) {
@@ -106,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/deploy/index.ts

@@ -1 +1 @@
-export * from './DeployCommand'
+export * from './DeployCommand.js'

package/src/commands/index.ts

@@ -1,5 +1,6 @@
-export * from './deploy'
-export * from './migrations'
-export * from './misc'
-export * from './project'
-export * from './workspace'
+export * from './deploy/index.js'
+export * from './migrations/index.js'
+export * from './misc/index.js'
+export * from './project/index.js'
+export * from './tenant/index.js'
+export * from './workspace/index.js'

package/src/commands/migrations/MigrationAmendCommand.ts

@@ -1,14 +1,14 @@
-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, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
-import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade'
-import { SchemaLoader } from '../../lib/schema/SchemaLoader'
-import { MigrationsValidator } from '../../lib/migrations/MigrationsValidator'
-import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
-import { printValidationErrors } from '../../lib/schema/SchemaValidationPrinter'
-import { SystemClientProvider } from '../../lib/SystemClientProvider'
+import { MigrationCreator, MigrationsResolver, SchemaStateManager, SchemaVersionBuilder } from '@contember/migrations-client'
+import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade.js'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader.js'
+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
@@ -30,6 +30,7 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 		private readonly migrationsValidator: MigrationsValidator,
 		private readonly migrationPrinter: MigrationPrinter,
 		private readonly schemaMigrator: SchemaMigrator,
+		private readonly schemaStateManager: SchemaStateManager,
 	) {
 		super()
 	}
@@ -44,30 +45,57 @@ 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()
+		const stateMode = await this.schemaStateManager.isStateMode()
 		try {
 			const initialSchema = await this.schemaVersionBuilder.buildSchema()
-			const intermediateResult = await this.migrationCreator.prepareMigration(initialSchema, schema, '')
+			const intermediateResult = await this.migrationCreator.prepareMigration(initialSchema, schema, '', {
+				skipNonModelDiffers: stateMode,
+			})
+
+			const schemaState = stateMode ? SchemaStateManager.schemaStateFromSchema(schema) : undefined
+			const stateChanged = schemaState ? await this.schemaStateManager.writeState(schemaState, { dryRun: true }) : false
+
 			if (intermediateResult === null) {
-				console.log('Nothing to do')
+				if (stateChanged) {
+					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 {
+					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,
@@ -78,7 +106,9 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 				[...amendMigration.modifications, ...intermediateResult.migration.modifications],
 				amendMigration.formatVersion,
 			)
-			const newMigrationResult = await this.migrationCreator.prepareMigration(prevSchema, newSchema, '')
+			const newMigrationResult = await this.migrationCreator.prepareMigration(prevSchema, newSchema, '', {
+				skipNonModelDiffers: stateMode,
+			})
 			const followingMigrations = (await this.migrationsResolver.getSchemaMigrations()).filter(
 				it => it.version > amendMigration.version,
 			)
@@ -88,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(
@@ -96,19 +126,27 @@ 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)
-				console.log('Latest migration was removed')
+				if (schemaState) {
+					await this.schemaStateManager.writeState(schemaState)
+					// migrationDelete rebuilds the server schema from migrations, dropping the
+					// 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: true, stateUpdated: schemaState !== undefined },
+					{ human: () => 'Latest migration was removed', quiet: value => value.migration },
+				)
 				return 0
 			}
 			const newMigration = {
@@ -120,24 +158,39 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 			await this.migrationCreator.saveMigration(newMigration)
 			await systemClient.migrationModify(amendMigration.version, newMigration)
 
+			if (schemaState) {
+				await this.schemaStateManager.writeState(schemaState)
+				// migrationModify rebuilds the server schema from migrations, dropping the
+				// 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' },
@@ -147,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: [
@@ -161,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,5 +1,5 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
-import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
+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'
 
 type Args = {
@@ -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,
+		})
 	}
 }