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

package/tests/cases/unit/MigrationInitStateCommand.test.ts

@@ -0,0 +1,72 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { SchemaStateManager } from '@contember/migrations-client'
+import { emptySchema } from '@contember/schema-utils'
+import { MigrationInitStateCommand } from '../../../src/commands/migrations/MigrationInitStateCommand.js'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+const temporaryDirectories: string[] = []
+
+afterEach(async () => {
+	await Promise.all(temporaryDirectories.splice(0).map(directory => fs.rm(directory, { recursive: true, force: true })))
+})
+
+const createCommand = async (enabled = false): Promise<MigrationInitStateCommand> => {
+	const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-init-state-command-'))
+	temporaryDirectories.push(directory)
+	const stateManager = new SchemaStateManager(path.join(directory, 'state'))
+	if (enabled) {
+		await stateManager.extractState(emptySchema)
+	}
+	const schemaLoader: SchemaLoader = { loadSchema: async () => emptySchema }
+	return new MigrationInitStateCommand(schemaLoader, stateManager)
+}
+
+describe('MigrationInitStateCommand', () => {
+	test('keeps status messages as human diagnostics', async () => {
+		const command = await createCommand()
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run([], output)).toBe(0)
+		expect(stdout.text).toBe('')
+		expect(stderr.lines).toStrictEqual([
+			'Schema state mode enabled. ACL, validation, actions and settings are now managed in the state/ directory.',
+			'These parts of the schema will no longer be written into migrations.',
+		])
+	})
+
+	test('reports a changed result as JSON', async () => {
+		const command = await createCommand()
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--json'], output)).toBe(0)
+		expect(JSON.parse(stdout.text)).toStrictEqual({ enabled: true, changed: true })
+		expect(stderr.text).toBe('')
+	})
+
+	test('reports an already enabled result as JSON', async () => {
+		const command = await createCommand(true)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--json'], output)).toBe(0)
+		expect(JSON.parse(stdout.text)).toStrictEqual({ enabled: true, changed: false })
+		expect(stderr.text).toBe('')
+	})
+
+	test('projects the changed flag in quiet mode', async () => {
+		const command = await createCommand()
+		const changed = createTestOutput()
+
+		expect(await command.run(['--quiet'], changed.output)).toBe(0)
+		expect(changed.stdout.text).toBe('true\n')
+		expect(changed.stderr.text).toBe('')
+
+		const unchanged = createTestOutput()
+		expect(await command.run(['--quiet'], unchanged.output)).toBe(0)
+		expect(unchanged.stdout.text).toBe('false\n')
+		expect(unchanged.stderr.text).toBe('')
+	})
+})

package/tests/cases/unit/MigrationRebaseCommand.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import prompts from 'prompts'
+import { JsonLoader, MigrationFilesManager, MigrationParser, MigrationsResolver, VERSION_LATEST } from '@contember/migrations-client'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { MigrationRebaseCommand } from '../../../src/commands/migrations/MigrationRebaseCommand.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+let workDir: string
+
+beforeEach(async () => {
+	workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-rebase-command-'))
+})
+
+afterEach(async () => {
+	await fs.rm(workDir, { recursive: true, force: true })
+})
+
+const buildCommand = async () => {
+	const filesManager = new MigrationFilesManager(workDir, { json: new JsonLoader(new MigrationParser()) })
+	await filesManager.createFile(
+		JSON.stringify({ formatVersion: VERSION_LATEST, modifications: [] }),
+		'2024-01-01-120000-existing',
+	)
+	const resolver = new MigrationsResolver(filesManager)
+	let calls = 0
+	const command = new MigrationRebaseCommand(resolver, {
+		rebase: async () => {
+			calls++
+		},
+	})
+	return { command, getCalls: () => calls }
+}
+
+test('non-interactive rebase refusal returns an input error without rewriting migrations', async () => {
+	const { command, getCalls } = await buildCommand()
+	const before = await fs.readdir(workDir)
+	const { output } = createTestOutput({ stdinTty: false })
+
+	const error = await command.run(['2024-01-01-120000'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('TTY_UNAVAILABLE')
+	expect(error instanceof CliError ? error.exitCode : null).toBe(ExitCode.InputError)
+	expect(getCalls()).toBe(0)
+	expect(await fs.readdir(workDir)).toStrictEqual(before)
+})
+
+test('declining rebase returns OPERATION_ABORTED without invoking the facade', async () => {
+	const { command, getCalls } = await buildCommand()
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject([false])
+
+	const error = await command.run(['2024-01-01-120000'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+	expect(getCalls()).toBe(0)
+})

package/tests/cases/unit/MigrationSnapshotFacade.test.ts

@@ -18,6 +18,10 @@ import {
 	VERSION_LATEST,
 } from '@contember/migrations-client'
 import { MigrationSnapshotFacade } from '../../../src/lib/migrations/MigrationSnapshotFacade.js'
+import { MigrationSnapshotCommand } from '../../../src/commands/migrations/MigrationSnapshotCommand.js'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+import prompts from 'prompts'
 
 namespace ModelA {
 	export class Author {
@@ -77,8 +81,15 @@ const setup = async (migrationsDir: string) => {
 		schemaMigrator,
 		schemaStateManager,
 		snapshotManager,
+		createTestOutput().output,
 	)
-	return { facade, schemaDiffer, snapshotManager }
+	return { facade, schemaDiffer, snapshotManager, command: new MigrationSnapshotCommand(facade) }
+}
+
+const writeSnapshot = async (facade: MigrationSnapshotFacade) => {
+	const snapshot = await facade.prepare()
+	await facade.write(snapshot)
+	return snapshot
 }
 
 describe('MigrationSnapshotFacade', () => {
@@ -104,8 +115,8 @@ describe('MigrationSnapshotFacade', () => {
 		await fs.rm(migrationsDir, { recursive: true, force: true })
 	})
 
-	test('create collapses all migrations and records what they cover', async () => {
-		const snapshot = await (await freshFacade()).create()
+	test('prepare and write collapse all migrations and record what they cover', async () => {
+		const snapshot = await writeSnapshot(await freshFacade())
 
 		expect(snapshot.version).toBe('2024-01-03-120000')
 		expect(snapshot.covers.map(it => it.type)).toStrictEqual(['schema', 'schema', 'content'])
@@ -116,8 +127,59 @@ describe('MigrationSnapshotFacade', () => {
 		expect(snapshot.snapshot.modifications.length).toBeGreaterThan(0)
 	})
 
+	test('prepare is read-only until the caller writes the snapshot', async () => {
+		const { facade, snapshotManager } = await setup(migrationsDir)
+
+		await facade.prepare()
+
+		expect(await snapshotManager.exists()).toBe(false)
+	})
+
+	test('non-interactive snapshot refusal does not write and returns an input error', async () => {
+		const { command, snapshotManager } = await setup(migrationsDir)
+		const { output } = createTestOutput({ stdinTty: false })
+
+		const error = await command.run([], output).then(() => null, (reason: unknown) => reason)
+
+		expect(error).toBeInstanceOf(CliError)
+		expect(error instanceof CliError ? error.code : null).toBe('TTY_UNAVAILABLE')
+		expect(error instanceof CliError ? error.exitCode : null).toBe(ExitCode.InputError)
+		expect(await snapshotManager.exists()).toBe(false)
+	})
+
+	test('declining snapshot creation does not write', async () => {
+		const { command, snapshotManager } = await setup(migrationsDir)
+		const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+		prompts.inject([false])
+
+		const error = await command.run([], output).then(() => null, (reason: unknown) => reason)
+
+		expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+		expect(await snapshotManager.exists()).toBe(false)
+	})
+
+	test('confirmed snapshot writes once and emits structured JSON with a quiet path', async () => {
+		const jsonSetup = await setup(migrationsDir)
+		const json = createTestOutput()
+		await jsonSetup.command.run(['--yes', '--json'], json.output)
+
+		expect(JSON.parse(json.stdout.text)).toStrictEqual({
+			version: '2024-01-03-120000',
+			coveredMigrations: 3,
+			contentMigrations: ['2024-01-03-120000'],
+			path: 'snapshot.json',
+		})
+		expect(await jsonSetup.snapshotManager.exists()).toBe(true)
+
+		await fs.rm(path.join(migrationsDir, 'snapshot.json'))
+		const quietSetup = await setup(migrationsDir)
+		const quiet = createTestOutput()
+		await quietSetup.command.run(['--yes', '--quiet'], quiet.output)
+		expect(quiet.stdout.text).toBe('snapshot.json\n')
+	})
+
 	test('a freshly created snapshot verifies against a full replay', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		const result = await (await freshFacade()).verify()
 		expect(result.ok).toBe(true)
 	})
@@ -136,7 +198,7 @@ describe('MigrationSnapshotFacade', () => {
 			await write('2024-01-01-120000-a.json', { formatVersion: VERSION_LATEST, modifications: schemaDiffer.diffSchemas(emptySchema, a) })
 			await write('2024-01-02-120000-b.json', { formatVersion: VERSION_LATEST, modifications: schemaDiffer.diffSchemas(a, b) })
 
-			await (await setup(dir)).facade.create()
+			await writeSnapshot((await setup(dir)).facade)
 			const result = await (await setup(dir)).facade.verify()
 			expect(result.ok).toBe(true)
 		} finally {
@@ -145,7 +207,7 @@ describe('MigrationSnapshotFacade', () => {
 	})
 
 	test('verify fails when a covered migration changed after the snapshot', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		// tamper with a covered schema migration, then re-read from a fresh process
 		await fs.writeFile(
 			path.join(migrationsDir, '2024-01-02-120000-b.json'),
@@ -158,12 +220,12 @@ describe('MigrationSnapshotFacade', () => {
 	})
 
 	test('getUsableSnapshot returns the snapshot for an empty project', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		expect(await (await freshFacade()).getUsableSnapshot([])).not.toBeNull()
 	})
 
 	test('getUsableSnapshot returns null when the project already has executed migrations', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		const executed = [{
 			version: '2024-01-01-120000',
 			name: '2024-01-01-120000-a',
@@ -175,13 +237,13 @@ describe('MigrationSnapshotFacade', () => {
 	})
 
 	test('getUsableSnapshot returns null (with a warning) when a covered migration is stale', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		await fs.rm(path.join(migrationsDir, '2024-01-01-120000-a.json'))
 		expect(await (await freshFacade()).getUsableSnapshot([])).toBeNull()
 	})
 
 	test('getUsableSnapshot ignores the snapshot when a migration was added within the covered range', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		// a migration whose version falls between two covered migrations, added without regenerating the
 		// snapshot. Bootstrapping would then fail with MUST_FOLLOW_LATEST, so it must fall back to replay.
 		await fs.writeFile(
@@ -197,7 +259,7 @@ describe('MigrationSnapshotFacade', () => {
 
 	test('verify fails when a covered migration changed type', async () => {
 		const { schemaDiffer } = await setup(migrationsDir)
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		// the seed migration was recorded as a content cover; rewrite it into a schema migration. Its
 		// modifications are absent from the collapsed snapshot, so it no longer equals a full replay.
 		await fs.writeFile(
@@ -216,7 +278,7 @@ describe('MigrationSnapshotFacade', () => {
 	})
 
 	test('verify fails when schema state mode was toggled after the snapshot', async () => {
-		await (await freshFacade()).create()
+		await writeSnapshot(await freshFacade())
 		// enabling state mode (migrations:init-state) only creates the state/ dir — it leaves the covered
 		// migration files untouched, so without an explicit guard the snapshot would pass unnoticed.
 		await fs.mkdir(path.join(migrationsDir, 'state'), { recursive: true })
@@ -229,7 +291,7 @@ describe('MigrationSnapshotFacade', () => {
 
 	test('buildSnapshotInput maps covered migrations to GraphQL inputs', async () => {
 		const facade = await freshFacade()
-		const snapshot = await facade.create()
+		const snapshot = await writeSnapshot(facade)
 		const input = await facade.buildSnapshotInput(snapshot)
 
 		expect(input.covers).toHaveLength(3)

package/tests/cases/unit/MigrationStatusCommand.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from 'bun:test'
+import {
+	AnyMigrationStatus,
+	ErrorMigrationStatus,
+	ExecutedMigration,
+	MigrationFile,
+	MigrationState,
+	MigrationToExecuteOkStatus,
+} from '@contember/migrations-client'
+import { MigrationStatusCommand } from '../../../src/commands/migrations/MigrationStatusCommand.js'
+import { MigrationStatusRow } from '../../../src/lib/migrations/MigrationPrinter.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+interface StatusResult {
+	allMigrations: AnyMigrationStatus[]
+	errorMigrations: ErrorMigrationStatus[]
+	migrationsToExecute: MigrationToExecuteOkStatus[]
+}
+
+const executedAt = new Date('2025-01-02T03:04:05.000Z')
+const localMigration: MigrationFile = {
+	path: '/migrations/2025-01-01-000001-pending.json',
+	version: '2025-01-01-000001',
+	name: '2025-01-01-000001-pending',
+	getContent: async () => ({
+		type: 'schema',
+		name: '2025-01-01-000001-pending',
+		version: '2025-01-01-000001',
+		formatVersion: 1,
+		modifications: [],
+	}),
+}
+const executedMigration = {
+	name: '2025-01-01-000002-executed',
+	version: '2025-01-01-000002',
+	formatVersion: 1,
+	checksum: 'checksum',
+	executedAt,
+}
+
+const toExecute: MigrationToExecuteOkStatus = {
+	state: MigrationState.TO_EXECUTE_OK,
+	version: localMigration.version,
+	name: localMigration.name,
+	localMigration,
+}
+const executedMissing: ErrorMigrationStatus = {
+	state: MigrationState.EXECUTED_MISSING,
+	version: executedMigration.version,
+	name: executedMigration.name,
+	executedMigration,
+	errorMessage: `Migration ${executedMigration.name} is missing locally`,
+}
+const executedOk: AnyMigrationStatus = {
+	state: MigrationState.EXECUTED_OK,
+	version: '2025-01-01-000003',
+	name: '2025-01-01-000003-executed-ok',
+	executedMigration: { ...executedMigration, version: '2025-01-01-000003', name: '2025-01-01-000003-executed-ok' },
+	localMigration,
+}
+const executedError: ErrorMigrationStatus = {
+	state: MigrationState.EXECUTED_ERROR,
+	version: '2025-01-01-000004',
+	name: '2025-01-01-000004-executed-error',
+	executedMigration: { ...executedMigration, version: '2025-01-01-000004', name: '2025-01-01-000004-executed-error' },
+	localMigration,
+	errorMessage: 'Checksum mismatch',
+}
+const toExecuteError: ErrorMigrationStatus = {
+	state: MigrationState.TO_EXECUTE_ERROR,
+	version: '2025-01-01-000005',
+	name: '2025-01-01-000005-pending-error',
+	localMigration,
+	errorMessage: 'Must follow latest',
+}
+const skipped: AnyMigrationStatus = {
+	state: MigrationState.SKIP_EMPTY,
+	version: '2025-01-01-000006',
+	name: '2025-01-01-000006-empty',
+	localMigration,
+}
+const everyState = [toExecute, executedMissing, executedOk, executedError, toExecuteError, skipped]
+const everyError = [executedMissing, executedError, toExecuteError]
+
+const statusRows = (migrations: AnyMigrationStatus[]): MigrationStatusRow[] =>
+	migrations.map(migration => ({
+		status: migration.state,
+		migration: migration.name,
+		info: 'status info',
+	}))
+
+const createCommand = (
+	initialStatus: StatusResult,
+	restoredStatus: StatusResult = initialStatus,
+	fullMigration: ExecutedMigration = { ...executedMigration, modifications: [] },
+) => {
+	const requestedOptions: Array<{ allowError?: boolean }> = []
+	const writes: Array<{ content: string; name: string }> = []
+	let statusCalls = 0
+	const command = new MigrationStatusCommand(
+		{
+			resolveMigrationsStatus: async options => {
+				requestedOptions.push(options)
+				return statusCalls++ === 0 ? initialStatus : restoredStatus
+			},
+		},
+		{
+			createFile: async (content, name) => {
+				writes.push({ content, name })
+				return `/migrations/${name}.json`
+			},
+		},
+		{
+			get: () => ({
+				getExecutedMigration: async () => fullMigration,
+			}),
+		},
+		{ statusRows },
+	)
+	return { command, requestedOptions, writes }
+}
+
+describe('MigrationStatusCommand', () => {
+	test('emits every status row as structured JSON', async () => {
+		const status = {
+			allMigrations: everyState,
+			errorMigrations: everyError,
+			migrationsToExecute: [toExecute],
+		}
+		const { command } = createCommand(status)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--json'], output)).toBe(1)
+		expect(JSON.parse(stdout.text)).toStrictEqual(everyState.map(migration => ({
+			status: migration.state,
+			migration: migration.name,
+			info: 'status info',
+		})))
+		expect(stderr.text).toBe('')
+	})
+
+	test('quiet output contains only migration names and preserves the error exit status', async () => {
+		const status = {
+			allMigrations: everyState,
+			errorMigrations: everyError,
+			migrationsToExecute: [toExecute],
+		}
+		const { command } = createCommand(status)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--quiet'], output)).toBe(1)
+		expect(stdout.lines).toStrictEqual(everyState.map(migration => migration.name))
+		expect(stderr.text).toBe('')
+	})
+
+	test('filters pending migrations without hiding unrelated errors from the exit status', async () => {
+		const status = {
+			allMigrations: [toExecute, executedMissing],
+			errorMigrations: [executedMissing],
+			migrationsToExecute: [toExecute],
+		}
+		const { command } = createCommand(status)
+		const { output, stdout } = createTestOutput()
+
+		expect(await command.run(['--json', '--only-to-execute'], output)).toBe(1)
+		expect(JSON.parse(stdout.text)).toStrictEqual([
+			{ status: MigrationState.TO_EXECUTE_OK, migration: toExecute.name, info: 'status info' },
+		])
+	})
+
+	test('restores a missing migration and renders the refreshed status', async () => {
+		const initialStatus = {
+			allMigrations: [executedMissing],
+			errorMigrations: [executedMissing],
+			migrationsToExecute: [],
+		}
+		const restored = {
+			allMigrations: [],
+			errorMigrations: [],
+			migrationsToExecute: [],
+		}
+		const fullMigration: ExecutedMigration = { ...executedMigration, modifications: [{ modification: 'createEntity', entityName: 'Article' }] }
+		const { command, requestedOptions, writes } = createCommand(initialStatus, restored, fullMigration)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--json', '--restore-missing'], output)).toBe(0)
+		expect(JSON.parse(stdout.text)).toStrictEqual([])
+		expect(stderr.text).toBe('')
+		expect(requestedOptions).toStrictEqual([{ allowError: true }, {}])
+		expect(writes).toStrictEqual([
+			{
+				name: executedMigration.name,
+				content: JSON.stringify({ formatVersion: 1, modifications: fullMigration.modifications }, undefined, '\t') + '\n',
+			},
+		])
+	})
+})

package/tests/cases/unit/MigrationsValidator.test.ts

@@ -0,0 +1,61 @@
+import { beforeAll, expect, test } from 'bun:test'
+import chalk from 'chalk'
+import { emptySchema } from '@contember/schema-utils'
+import { MigrationDescriber, ModificationHandlerFactory, SchemaMigrator, VERSION_LATEST } from '@contember/schema-migrations'
+import { Migration } from '@contember/migrations-client'
+import { MigrationsValidator } from '../../../src/lib/migrations/MigrationsValidator.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+beforeAll(() => {
+	// deterministic assertions regardless of the terminal the suite runs in
+	chalk.level = 0
+})
+
+// A migration that grants a role on an entity the model does not have — applying it succeeds, but the
+// resulting schema fails validation (ACL_UNDEFINED_ENTITY).
+const invalidAclMigration: Migration = {
+	version: '2024-01-01-120000',
+	name: '2024-01-01-120000-invalid-acl',
+	formatVersion: VERSION_LATEST,
+	modifications: [
+		{
+			modification: 'updateAclSchema',
+			schema: {
+				roles: {
+					admin: {
+						variables: {},
+						stages: '*',
+						entities: { Ghost: { predicates: {}, operations: { read: { id: true } } } },
+					},
+				},
+			},
+		},
+	],
+}
+
+const buildValidator = (options: { quiet?: boolean } = {}) => {
+	const factory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const { output, stdout, stderr } = createTestOutput()
+	if (options.quiet) {
+		output.setMode('quiet')
+	}
+	return { validator: new MigrationsValidator(new MigrationDescriber(factory), new SchemaMigrator(factory), output), stdout, stderr }
+}
+
+test('reports validation errors of a migrated schema on stderr', () => {
+	const { validator, stdout, stderr } = buildValidator()
+
+	expect(validator.validate(emptySchema, [invalidAclMigration])).toBe(false)
+	expect(stderr.text).toContain('2024-01-01-120000-invalid-acl produces invalid schema')
+	expect(stderr.text).toContain('ACL_UNDEFINED_ENTITY')
+	// diagnostics never leak into the data stream
+	expect(stdout.text).toBe('')
+})
+
+test('prints nothing in quiet mode, while still reporting the schema as invalid', () => {
+	const { validator, stdout, stderr } = buildValidator({ quiet: true })
+
+	expect(validator.validate(emptySchema, [invalidAclMigration])).toBe(false)
+	expect(stderr.text).toBe('')
+	expect(stdout.text).toBe('')
+})