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

package/src/lib/js/JsCodeRunner.ts

@@ -1,5 +1,5 @@
-import { JsBuilder } from './JsBuilder'
-import { JsExecutor } from './JsExecutor'
+import { JsBuilder } from './JsBuilder.js'
+import { JsExecutor } from './JsExecutor.js'
 
 export class JsCodeRunner {
 	constructor(

package/src/lib/maskToken.ts

@@ -1 +1,9 @@
-export const maskToken = (token: string) => token.replace(/^(\w{3}).+(\w{3})$/, '$1***$2')
+const recognizableToken = /^[A-Za-z0-9._~-]{12,}$/
+
+/** Keeps a small fingerprint for recognizable credentials and hides every other value completely. */
+export const maskToken = (token: string): string => {
+	if (!recognizableToken.test(token)) {
+		return '***'
+	}
+	return `${token.slice(0, 3)}***${token.slice(-3)}`
+}

package/src/lib/migrations/MigrationExecutionFacade.ts

@@ -1,12 +1,23 @@
-import prompts from 'prompts'
-import { MigrationPrinter } from './MigrationPrinter'
-import { isSchemaMigration, MigrationExecutor, MigrationToExecuteOkStatus, SchemaVersionBuilder } from '@contember/migrations-client'
-import { MigrationsStatusFacade } from './MigrationsStatusFacade'
+import { MigrationPrinter } from './MigrationPrinter.js'
+import {
+	isSchemaMigration,
+	MigrateErrorCode,
+	MigrationExecutor,
+	MigrationToExecuteOkStatus,
+	SchemaState,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	SnapshotFile,
+} from '@contember/migrations-client'
+import { MigrationsStatusFacade } from './MigrationsStatusFacade.js'
+import { MigrationSnapshotFacade } from './MigrationSnapshotFacade.js'
 import { MigrationVersionHelper } from '@contember/engine-common'
-import { RemoteProject } from '../project/RemoteProject'
-import { SystemClientProvider } from '../SystemClientProvider'
-import { TenantClientProvider } from '../TenantClientProvider'
-import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+import { SystemClientProvider } from '../SystemClientProvider.js'
+import { TenantClientProvider } from '../TenantClientProvider.js'
+import { RemoteProjectProvider } from '../project/RemoteProjectProvider.js'
+import { CliError, ExitCode, Output } from '@contember/cli-common'
+import { GraphQlClientError } from '@contember/graphql-client'
+import { promptSelect } from '../prompt/index.js'
 
 export class MigrationExecutionFacade {
 	constructor(
@@ -17,6 +28,9 @@ export class MigrationExecutionFacade {
 		private readonly migrationPrinter: MigrationPrinter,
 		private readonly migrationExecutor: MigrationExecutor,
 		private readonly migrationStatusFacade: MigrationsStatusFacade,
+		private readonly schemaStateManager: SchemaStateManager,
+		private readonly migrationSnapshotFacade: MigrationSnapshotFacade,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
@@ -25,74 +39,212 @@ export class MigrationExecutionFacade {
 		force,
 		until,
 		additionalMessage,
+		useSnapshot = true,
+		onConfirmed,
 	}: {
 		requireConfirmation: boolean | ((migrations: MigrationToExecuteOkStatus[]) => boolean)
 		force?: boolean
 		until?: string
 		additionalMessage?: string
+		useSnapshot?: boolean
+		onConfirmed?: () => void
 	}): Promise<boolean> => {
 		const project = this.projectProvider.get()
-		await this.tenantClientProvider.get().createProject(project.name, true)
+		const stateMode = await this.schemaStateManager.isStateMode()
+		let schemaState = stateMode ? await this.schemaStateManager.readState() : undefined
+		const localMigrations = await this.migrationStatusFacade.getLocalMigrationFiles()
 
-		const status = await this.migrationStatusFacade.resolveMigrationsStatus({ force })
-		const migrations = until
-			? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(until))
-			: status.migrationsToExecute
-		if (migrations.length === 0) {
-			console.log('No migrations to execute')
-			return true
+		// The state files always reflect the latest schema. When migrating to an older version, that
+		// state may reference parts of the model that don't exist yet, so skip it rather than push an
+		// inconsistent overlay. Run `migrations execute` without `--until` to sync the schema state.
+		if (until && schemaState) {
+			this.output.warn(
+				'Warning: schema state was not applied because --until targets a specific migration; the state files reflect the latest schema. Run "migrations execute" without --until to sync it.',
+			)
+			schemaState = undefined
+		}
+		if (localMigrations.length === 0 && !schemaState) {
+			this.output.info('No migrations to execute')
+			return false
 		}
-		console.log('Will execute following migrations:')
-		migrations.forEach(it => console.log(it.name))
-		additionalMessage && console.log(additionalMessage)
 
-		if (typeof requireConfirmation === 'function' ? requireConfirmation(migrations) : requireConfirmation) {
-			if (!process.stdin.isTTY) {
-				throw 'TTY not available. Pass --yes option to confirm execution.'
+		let migrationsToConfirm: MigrationToExecuteOkStatus[] = []
+		if (localMigrations.length > 0) {
+			const status = await this.resolvePreflightStatus({ force })
+			migrationsToConfirm = until
+				? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(until))
+				: status.migrationsToExecute
+			if (migrationsToConfirm.length === 0 && !schemaState) {
+				this.output.info('No migrations to execute')
+				return false
+			}
+			if (migrationsToConfirm.length > 0) {
+				this.output.info('Will execute following migrations:')
+				migrationsToConfirm.forEach(it => this.output.info(it.name))
+			}
+		}
+		if (schemaState && localMigrations.length === 0) {
+			this.output.info('Will update schema state')
+		}
+		if (additionalMessage) {
+			this.output.info(additionalMessage)
+		}
+
+		if (typeof requireConfirmation === 'function' ? requireConfirmation(migrationsToConfirm) : requireConfirmation) {
+			if (!this.output.canPrompt()) {
+				throw new CliError('TTY not available. Pass --yes to confirm execution.', {
+					code: 'TTY_UNAVAILABLE',
+					exitCode: ExitCode.InputError,
+				})
 			}
 			do {
-				const { action } = await prompts({
-					type: 'select',
-					name: 'action',
+				const action = await promptSelect(this.output, {
 					message: 'Do you want to continue?',
 					choices: [
-						{ value: 'yes', title: 'Execute migrations' },
-						{ value: 'describe', title: 'Describe migrations' },
+						{ value: 'yes', title: migrationsToConfirm.length > 0 ? 'Execute migrations' : 'Update schema state' },
+						...(migrationsToConfirm.length > 0 ? [{ value: 'describe', title: 'Describe migrations' }] : []),
 						{ value: 'no', title: 'Abort' },
 					],
 				})
 				if (action === 'describe') {
-					const schema = await this.schemaVersionBuilder.buildSchemaUntil(migrations[0].version)
-					for (const migration of migrations) {
-						const migrationContent = await migration.localMigration.getContent()
-						if (!isSchemaMigration(migrationContent)) {
-							continue
+					const schema = await this.schemaVersionBuilder.buildSchemaUntil(migrationsToConfirm[0].version)
+					for (const migration of migrationsToConfirm) {
+						const content = await migration.localMigration.getContent()
+						if (isSchemaMigration(content)) {
+							this.migrationPrinter.printMigrationDescription(schema, content, { noSql: true })
 						}
-
-						await this.migrationPrinter.printMigrationDescription(schema, migrationContent, {
-							noSql: true,
-						})
 					}
-				} else if (action === 'yes') {
+					continue
+				}
+				if (action === 'yes') {
+					onConfirmed?.()
 					break
-				} else {
-					return false
 				}
+				throw new CliError('Migration execution aborted', {
+					code: 'OPERATION_ABORTED',
+					exitCode: ExitCode.InputError,
+				})
 			} while (true)
 		}
 
-		await this.migrationExecutor.executeMigrations({
-			client: this.systemClientProvider.get(),
-			migrations,
-			contentMigrationFactoryArgs: {
-				apiToken: project.token,
-				apiBaseUrl: project.endpoint,
-				projectName: project.name,
-				schemaVersionBuilder: this.schemaVersionBuilder,
-			},
-			log: message => console.log(message),
-			force,
-		})
+		await this.tenantClientProvider.get().createProject(project.name, true, { noDeployToken: true })
+
+		const snapshot = useSnapshot ? await this.getSnapshotToApply({ until }) : undefined
+
+		let status = await this.migrationStatusFacade.resolveMigrationsStatus({ force })
+		let migrations = until
+			? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(until))
+			: status.migrationsToExecute
+		if (schemaState && migrations.length === 0) {
+			this.output.info('Updating schema state')
+		}
+		if (snapshot) {
+			this.output.info(`Will bootstrap from snapshot (${snapshot.covers.length} migrations up to ${snapshot.version})`)
+		}
+		if (migrations.length === 0 && !schemaState && !snapshot) {
+			this.output.info('No pending migrations to execute')
+			return false
+		}
+
+		if (snapshot) {
+			await this.applySnapshot(snapshot, schemaState)
+			status = await this.migrationStatusFacade.resolveMigrationsStatus({ force })
+			migrations = until
+				? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(until))
+				: status.migrationsToExecute
+		}
+
+		try {
+			await this.migrationExecutor.executeMigrations({
+				client: this.systemClientProvider.get(),
+				migrations,
+				schemaState,
+				contentMigrationFactoryArgs: {
+					apiToken: project.token,
+					apiBaseUrl: project.endpoint,
+					projectName: project.name,
+					schemaVersionBuilder: this.schemaVersionBuilder,
+				},
+				log: message => this.output.info(message),
+				force,
+			})
+		} catch (e) {
+			if (isViewReplaceFailure(e)) {
+				this.output.error(
+					"\nAn in-place view update (CREATE OR REPLACE VIEW) failed — Postgres rejects it (SQLSTATE 42P16) when a view's"
+						+ ' output columns changed (e.g. reordered or retyped) even though its fields did not.\n'
+						+ 'Re-generate the migration with `migrations diff <name> --recreate-views` to drop & recreate the affected'
+						+ ' views (and their dependants) instead.\n',
+				)
+			}
+			throw e
+		}
 		return true
 	}
+
+	private async resolvePreflightStatus({ force }: { force?: boolean }) {
+		try {
+			return await this.migrationStatusFacade.resolveMigrationsStatus({ force })
+		} catch (error) {
+			const projectNotFound = error instanceof CliError
+				? error.code === 'SYSTEM_API_NOT_FOUND'
+				: error instanceof GraphQlClientError && error.response?.status === 404
+			if (!projectNotFound) {
+				throw error
+			}
+			return await this.migrationStatusFacade.resolveMigrationsStatusFromExecuted([], { force })
+		}
+	}
+
+	private async getSnapshotToApply({ until }: { until?: string }): Promise<SnapshotFile | undefined> {
+		const executed = await this.systemClientProvider.get().listExecutedMigrations()
+		const snapshot = await this.migrationSnapshotFacade.getUsableSnapshot(executed)
+		if (!snapshot) {
+			return undefined
+		}
+		if (until && snapshot.version > MigrationVersionHelper.extractVersion(until)) {
+			// snapshot reaches past the requested target — fall back to a normal replay
+			return undefined
+		}
+		return snapshot
+	}
+
+	private async applySnapshot(snapshot: SnapshotFile, schemaState?: SchemaState): Promise<void> {
+		this.output.info(`Bootstrapping from snapshot (collapses ${snapshot.covers.length} migrations up to ${snapshot.version})`)
+		if (snapshot.contentMigrations.length > 0) {
+			this.output.warn(
+				`Note: ${snapshot.contentMigrations.length} content migration(s) are covered by the snapshot; their data is NOT reproduced.`,
+			)
+		}
+		const input = await this.migrationSnapshotFacade.buildSnapshotInput(snapshot)
+		try {
+			await this.systemClientProvider.get().migrateFromSnapshot(input, schemaState)
+		} catch (e) {
+			if (isProjectNotEmptyError(e)) {
+				// The project was migrated between our emptiness check and the server call (e.g. a
+				// concurrent execute on a fresh database). Fall back to a normal replay rather than
+				// crashing — the subsequent status resolution will pick up whatever is left to run.
+				this.output.warn('Snapshot skipped: the project is no longer empty. Falling back to a full replay.')
+				return
+			}
+			throw e
+		}
+		this.output.info('Snapshot applied')
+	}
 }
+
+const isProjectNotEmptyError = (e: unknown): boolean => Array.isArray(e) && e.some(it => hasCode(it, MigrateErrorCode.ProjectNotEmpty))
+
+// A failed `updateView` modification surfaces as MIGRATION_FAILED whose developerMessage embeds the failing
+// statement (`CREATE OR REPLACE VIEW …`). Since each modification's SQL is executed in isolation, that string
+// is a precise signal that an in-place view update — and not some other statement — is what Postgres rejected.
+const isViewReplaceFailure = (e: unknown): boolean =>
+	Array.isArray(e) && e.some(it =>
+		hasCode(it, MigrateErrorCode.MigrationFailed)
+		&& 'message' in it
+		&& typeof it.message === 'string'
+		&& it.message.includes('CREATE OR REPLACE VIEW')
+	)
+
+const hasCode = (value: unknown, code: MigrateErrorCode): value is object & { code: MigrateErrorCode } =>
+	value !== null && typeof value === 'object' && 'code' in value && value.code === code

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 { assertNever } from '../assertNever'
+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

@@ -1,8 +1,9 @@
-import { Migration, MigrationFilesManager, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
-import { MigrationsValidator } from './MigrationsValidator'
+import { Migration, MigrationFilesManager, SchemaStateManager, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
+import { MigrationsValidator } from './MigrationsValidator.js'
 import { emptySchema } from '@contember/schema-utils'
 import { MigrationVersionHelper } from '@contember/engine-common'
-import { SystemClientProvider } from '../SystemClientProvider'
+import { SystemClientProvider } from '../SystemClientProvider.js'
+import { CliError, ExitCode } from '@contember/cli-common'
 
 export class MigrationRebaseFacade {
 	constructor(
@@ -10,6 +11,7 @@ export class MigrationRebaseFacade {
 		private readonly migrationsValidator: MigrationsValidator,
 		private readonly systemClientProvider: SystemClientProvider,
 		private readonly migrationFilesManager: MigrationFilesManager,
+		private readonly schemaStateManager: SchemaStateManager,
 	) {
 	}
 
@@ -21,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
@@ -37,5 +39,11 @@ export class MigrationRebaseFacade {
 			await this.systemClientProvider.get().migrationModify(migration.version, newMigration)
 			await this.migrationFilesManager.moveFile(migration.name, newMigration.name)
 		}
+
+		// migrationModify rebuilds the server schema from migrations, dropping the non-model
+		// state; re-apply it from the state files so the server stays consistent.
+		if (await this.schemaStateManager.isStateMode()) {
+			await this.systemClientProvider.get().migrate([], false, await this.schemaStateManager.readState())
+		}
 	}
 }