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

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

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, 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 { c, createSchema } from '@contember/schema-definition'
+import { Schema } from '@contember/schema'
+import { emptySchema } from '@contember/schema-utils'
+import {
+	JsonLoader,
+	MigrationCreator,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	ModificationHandlerFactory,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { CliError, ExitCode, Input } from '@contember/cli-common'
+import { MigrationAmendCommand } from '../../../src/commands/migrations/MigrationAmendCommand.js'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+namespace BlogModel {
+	export class Author {
+		name = c.stringColumn()
+	}
+}
+
+namespace BlogModelExtended {
+	export class Author {
+		name = c.stringColumn()
+		nickname = c.stringColumn()
+	}
+}
+
+const aclWith = (role: string): Schema['acl'] => ({
+	roles: {
+		[role]: { variables: {}, stages: '*', entities: {} },
+	},
+})
+
+type SystemClientCall = { method: 'migrate' | 'migrationDelete' | 'migrationModify'; args: any[] }
+
+// A system client that records calls instead of hitting the network. `get()` throws by default so a
+// state-only amend (which must not touch the server) fails loudly if it ever reaches out.
+const recordingSystemClient = (calls?: SystemClientCall[]) => ({
+	get: () => {
+		if (!calls) {
+			throw new Error('systemClient must not be used for a state-only amend')
+		}
+		const record = (method: SystemClientCall['method']) => async (...args: any[]) => {
+			calls.push({ method, args })
+		}
+		return { migrate: record('migrate'), migrationDelete: record('migrationDelete'), migrationModify: record('migrationModify') }
+	},
+})
+
+// Builds an amend command wired with real migrations-client services backed by `migrationsDir`.
+const buildCommand = (migrationsDir: string, loadedSchema: Schema, calls?: SystemClientCall[]) => {
+	const filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const schemaMigrator = new SchemaMigrator(new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
+	const schemaStateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+	const schemaVersionBuilder = new SchemaVersionBuilder(migrationsResolver, schemaMigrator, schemaStateManager)
+	const migrationCreator = new MigrationCreator(filesManager, new SchemaDiffer(schemaMigrator))
+
+	const schemaLoader: SchemaLoader = { loadSchema: async () => loadedSchema }
+	const statusFacade = { resolveMigrationsStatus: async () => ({ migrationsToExecute: [] }) }
+	const migrationsValidator = { validate: async () => true }
+	const migrationPrinter = { printMigrationDescription: () => {} }
+
+	const command = new MigrationAmendCommand(
+		migrationsResolver,
+		recordingSystemClient(calls) as any,
+		statusFacade as any,
+		schemaLoader,
+		schemaVersionBuilder,
+		migrationCreator,
+		migrationsValidator as any,
+		migrationPrinter as any,
+		schemaMigrator,
+		schemaStateManager,
+	)
+	return { command, schemaStateManager }
+}
+
+const run = (command: MigrationAmendCommand) => command.execute(new Input({}, { force: false, yes: true }), createTestOutput().output)
+
+describe('MigrationAmendCommand (schema state mode)', () => {
+	let migrationsDir: string
+
+	beforeEach(async () => {
+		migrationsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-amend-'))
+
+		const schemaDiffer = new SchemaDiffer(new SchemaMigrator(new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)))
+		const model = createSchema(BlogModel)
+		// model-only migration, exactly as state mode would produce (non-model parts live in state/ files)
+		const modifications = schemaDiffer.diffSchemas(emptySchema, model, { skipNonModelDiffers: true })
+		await fs.writeFile(
+			path.join(migrationsDir, '2024-01-01-120000-init.json'),
+			JSON.stringify({ formatVersion: VERSION_LATEST, modifications }, null, '\t'),
+		)
+
+		// enable state mode with an initial ACL granting the `admin` role
+		const stateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+		await stateManager.extractState({ ...model, acl: aclWith('admin') })
+	})
+
+	afterEach(async () => {
+		await fs.rm(migrationsDir, { recursive: true, force: true })
+	})
+
+	test('rewrites state files when only non-model parts changed', async () => {
+		const model = createSchema(BlogModel)
+		// same model, different ACL — the diff is non-model only, so no migration is produced
+		const { command, schemaStateManager } = buildCommand(migrationsDir, { ...model, acl: aclWith('editor') })
+
+		const code = await run(command)
+
+		expect(code).toBe(0)
+		const state = await schemaStateManager.readState()
+		expect(Object.keys(state.acl.roles)).toStrictEqual(['editor'])
+	})
+
+	test('non-interactive state-only amendment refuses before writing state', async () => {
+		const model = createSchema(BlogModel)
+		const { command, schemaStateManager } = buildCommand(migrationsDir, { ...model, acl: aclWith('editor') })
+		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)
+		const state = await schemaStateManager.readState()
+		expect(Object.keys(state.acl.roles)).toStrictEqual(['admin'])
+	})
+
+	test('leaves state untouched when nothing changed', async () => {
+		const model = createSchema(BlogModel)
+		// identical model and ACL — nothing to do, state files must not be rewritten
+		const { command, schemaStateManager } = buildCommand(migrationsDir, { ...model, acl: aclWith('admin') })
+
+		const code = await run(command)
+
+		expect(code).toBe(0)
+		const state = await schemaStateManager.readState()
+		expect(Object.keys(state.acl.roles)).toStrictEqual(['admin'])
+	})
+
+	test('re-pushes schema state to the server after amending model changes', async () => {
+		// model changed (a column added) — migrationModify rebuilds the server schema from migrations
+		// and drops the non-model state, so amend must re-apply the state via a follow-up migrate call.
+		const loaded: Schema = { ...createSchema(BlogModelExtended), acl: aclWith('admin') }
+		const calls: SystemClientCall[] = []
+		const { command } = buildCommand(migrationsDir, loaded, calls)
+
+		const code = await run(command)
+
+		expect(code).toBe(0)
+		const modifyIndex = calls.findIndex(it => it.method === 'migrationModify')
+		expect(modifyIndex).toBeGreaterThanOrEqual(0)
+		// the state re-push is a migrate call carrying schemaState, after the migrationModify
+		const restate = calls.slice(modifyIndex + 1).find(it => it.method === 'migrate' && it.args[2])
+		expect(restate).toBeDefined()
+		expect(Object.keys(restate!.args[2].acl.roles)).toStrictEqual(['admin'])
+	})
+})

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

@@ -0,0 +1,182 @@
+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 { Schema } from '@contember/schema'
+import { c, createSchema } from '@contember/schema-definition'
+import { emptySchema } from '@contember/schema-utils'
+import {
+	JsonLoader,
+	MigrationCreator,
+	MigrationDescriber,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	MigrationState,
+	MigrationToExecuteOkStatus,
+	ModificationHandlerFactory,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { MigrationDiffCommand } from '../../../src/commands/migrations/MigrationDiffCommand.js'
+import { MigrationExecutionFacade } from '../../../src/lib/migrations/MigrationExecutionFacade.js'
+import { MigrationPrinter } from '../../../src/lib/migrations/MigrationPrinter.js'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+namespace BlogModel {
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+namespace ExistingModel {
+	export class LegacyArticle {
+		title = c.stringColumn()
+	}
+}
+
+const invalidSchema: Schema = {
+	...emptySchema,
+	acl: {
+		roles: {
+			admin: { variables: {}, stages: '*', entities: {}, inherits: ['missing'] },
+		},
+	},
+}
+
+let workDir: string
+
+beforeEach(async () => {
+	workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-diff-command-'))
+})
+
+afterEach(async () => {
+	await fs.rm(workDir, { recursive: true, force: true })
+})
+
+const listTree = async (): Promise<string[]> => {
+	const entries: string[] = []
+	const visit = async (directory: string, prefix = ''): Promise<void> => {
+		for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+			const relative = path.join(prefix, entry.name)
+			entries.push(relative)
+			if (entry.isDirectory()) {
+				await visit(path.join(directory, entry.name), relative)
+			}
+		}
+	}
+	await visit(workDir)
+	return entries.sort()
+}
+
+const buildCommand = async (schema: Schema, existingMigration = false) => {
+	const migrationsDir = path.join(workDir, 'migrations')
+	const filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+	const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const schemaMigrator = new SchemaMigrator(modificationFactory)
+	const schemaDiffer = new SchemaDiffer(schemaMigrator)
+	if (existingMigration) {
+		await filesManager.createDirIfNotExist()
+		await filesManager.createFile(
+			JSON.stringify({
+				formatVersion: VERSION_LATEST,
+				modifications: schemaDiffer.diffSchemas(emptySchema, createSchema(ExistingModel)),
+			}),
+			'2024-01-01-120000-existing',
+		)
+	}
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const stateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+	const schemaVersionBuilder = new SchemaVersionBuilder(migrationsResolver, schemaMigrator, stateManager)
+	const loader: SchemaLoader = { loadSchema: async () => schema }
+	const executionConfirmations: boolean[] = []
+	const executor = {
+		execute: async (options: Parameters<MigrationExecutionFacade['execute']>[0]) => {
+			const migrations = await migrationsResolver.getMigrationFiles()
+			const pendingFiles = existingMigration ? migrations : migrations.slice(-1)
+			const pending: MigrationToExecuteOkStatus[] = pendingFiles.map(localMigration => ({
+				state: MigrationState.TO_EXECUTE_OK,
+				version: localMigration.version,
+				name: localMigration.name,
+				localMigration,
+			}))
+			executionConfirmations.push(
+				typeof options.requireConfirmation === 'function' ? options.requireConfirmation(pending) : options.requireConfirmation,
+			)
+			return true
+		},
+	}
+	const output = createTestOutput()
+	const command = new MigrationDiffCommand(
+		loader,
+		schemaVersionBuilder,
+		new MigrationCreator(filesManager, schemaDiffer),
+		new MigrationPrinter(new MigrationDescriber(modificationFactory), output.output),
+		executor,
+		stateManager,
+		migrationsResolver,
+	)
+	return { command, migrationsDir, executionConfirmations }
+}
+
+test('declining a diff leaves a new project filesystem untouched', async () => {
+	const { command } = await buildCommand(createSchema(BlogModel))
+	const before = await listTree()
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['no'])
+
+	const error = await command.run(['change'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+	expect(await listTree()).toStrictEqual(before)
+})
+
+test('executing a new diff requires a second confirmation when older migrations are pending', async () => {
+	const { command, executionConfirmations } = await buildCommand(createSchema(BlogModel), true)
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['yes'])
+
+	await command.run(['change', '--execute'], output)
+
+	expect(executionConfirmations).toStrictEqual([true])
+})
+
+test('executing a new diff does not require a redundant second confirmation when it is the only pending migration', async () => {
+	const { command, executionConfirmations } = await buildCommand(createSchema(BlogModel))
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['yes'])
+
+	await command.run(['change', '--execute'], output)
+
+	expect(executionConfirmations).toStrictEqual([false])
+})
+
+test('non-interactive diff refusal leaves a new project filesystem untouched', async () => {
+	const { command } = await buildCommand(createSchema(BlogModel))
+	const before = await listTree()
+	const { output } = createTestOutput({ stdinTty: false })
+
+	const error = await command.run(['change'], 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(await listTree()).toStrictEqual(before)
+})
+
+test('an invalid diff returns a structured error without changing the filesystem', async () => {
+	const { command } = await buildCommand(invalidSchema, true)
+	const before = await listTree()
+	const { output, stdout } = createTestOutput()
+
+	const error = await command.run(['change', '--yes', '--json'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('SCHEMA_INVALID')
+	expect(stdout.text).toBe('')
+	expect(await listTree()).toStrictEqual(before)
+})

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

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+import { MigrationExecuteCommand } from '../../../src/commands/migrations/MigrationExecuteCommand.js'
+import { MigrationExecutionFacade } from '../../../src/lib/migrations/MigrationExecutionFacade.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+type ExecuteOptions = Parameters<MigrationExecutionFacade['execute']>[0]
+
+const createCommand = (changed: boolean) => {
+	const calls: ExecuteOptions[] = []
+	const command = new MigrationExecuteCommand({
+		execute: async options => {
+			calls.push(options)
+			return changed
+		},
+	})
+	return { command, calls }
+}
+
+describe('MigrationExecuteCommand', () => {
+	test('reports the completed status and forwards execution flags in JSON mode', async () => {
+		const { command, calls } = createCommand(true)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(
+			await command.run(
+				['--json', '--yes', '--force', '--until', '2025-01-01-000001-first', '--no-snapshot'],
+				output,
+			),
+		).toBe(0)
+		expect(JSON.parse(stdout.text)).toStrictEqual({ status: 'completed', until: '2025-01-01-000001-first' })
+		expect(stderr.text).toBe('')
+		expect(calls).toStrictEqual([
+			{
+				force: true,
+				until: '2025-01-01-000001-first',
+				requireConfirmation: false,
+				useSnapshot: false,
+			},
+		])
+	})
+
+	test('reports a no-op as a quiet scalar', async () => {
+		const { command, calls } = createCommand(false)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--quiet', '--yes'], output)).toBe(0)
+		expect(stdout.text).toBe('noop\n')
+		expect(stderr.text).toBe('')
+		expect(calls).toStrictEqual([
+			{
+				force: undefined,
+				until: undefined,
+				requireConfirmation: false,
+				useSnapshot: true,
+			},
+		])
+	})
+})