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

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

@@ -0,0 +1,223 @@
+import { afterEach, beforeAll, 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 chalk from 'chalk'
+import { Schema } from '@contember/schema'
+import { emptySchema } from '@contember/schema-utils'
+import {
+	JsonLoader,
+	MigrationDescriber,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	ModificationHandlerFactory,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+} from '@contember/migrations-client'
+import { SchemaDiffer } from '@contember/schema-migrations'
+import { Application, CommandFactoryList, CommandManager, ExitCode, Output, OutputStream } from '@contember/cli-common'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { MigrationsValidator } from '../../../src/lib/migrations/MigrationsValidator.js'
+import { ProjectPrintSchemaCommand } from '../../../src/commands/project/ProjectPrintSchemaCommand.js'
+import { ProjectValidateCommand } from '../../../src/commands/project/ProjectValidateCommand.js'
+
+beforeAll(() => {
+	// deterministic assertions regardless of the terminal the suite runs in
+	chalk.level = 0
+})
+
+class CapturingStream implements OutputStream {
+	public chunks: string[] = []
+	constructor(public readonly isTty: boolean = false) {}
+	write(text: string): void {
+		this.chunks.push(text)
+	}
+	get text(): string {
+		return this.chunks.join('')
+	}
+}
+
+const createOutput = () => {
+	const stdout = new CapturingStream()
+	const stderr = new CapturingStream()
+	return { stdout, stderr, output: new Output({ stdout, stderr }) }
+}
+
+const tmpDirs: string[] = []
+afterEach(async () => {
+	await Promise.all(tmpDirs.splice(0).map(dir => fs.rm(dir, { recursive: true, force: true })))
+})
+
+// Wires the project commands with real (but empty) migrations-client services backed by an empty temp dir,
+// so `getSchemaMigrations()` resolves to `[]` and `buildSchema()` resolves to `emptySchema` — only the
+// "defined schema" (schemaLoader) varies per test.
+const buildProjectCommands = async (definedSchema: Schema) => {
+	const migrationsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-project-'))
+	tmpDirs.push(migrationsDir)
+
+	const filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const modificationHandlerFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const schemaMigrator = new SchemaMigrator(modificationHandlerFactory)
+	const schemaStateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+	const schemaVersionBuilder = new SchemaVersionBuilder(migrationsResolver, schemaMigrator, schemaStateManager)
+	const schemaDiffer = new SchemaDiffer(schemaMigrator)
+	const migrationsValidator = new MigrationsValidator(new MigrationDescriber(modificationHandlerFactory), schemaMigrator, createOutput().output)
+	const schemaLoader: SchemaLoader = { loadSchema: async () => definedSchema }
+
+	return {
+		validateCommand: new ProjectValidateCommand(schemaLoader, migrationsValidator, migrationsResolver, schemaDiffer, schemaVersionBuilder),
+		printSchemaCommand: new ProjectPrintSchemaCommand(schemaLoader, schemaVersionBuilder),
+	}
+}
+
+const runApplication = async (args: string[], commands: CommandFactoryList) => {
+	const io = createOutput()
+	const application = new Application(new CommandManager(commands), 'Test CLI', io.output)
+	const exitCode = await application.execute(args)
+	return { exitCode, stdout: io.stdout.text, stderr: io.stderr.text }
+}
+
+// a role inheriting from a role that does not exist — one deterministic ACL_UNDEFINED_ROLE error
+const schemaWithKnownError: Schema = {
+	...emptySchema,
+	acl: {
+		roles: {
+			admin: { variables: {}, stages: '*', entities: {}, inherits: ['ghost'] },
+		},
+	},
+}
+
+describe('project validate', () => {
+	test('--json emits one error envelope with structured issues and leaves stdout empty', async () => {
+		const { validateCommand } = await buildProjectCommands(schemaWithKnownError)
+		const { exitCode, stdout, stderr } = await runApplication(
+			['project', 'validate', '--json'],
+			{ ['project validate']: () => validateCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.InputError)
+
+		expect(stdout).toBe('')
+		const envelope = JSON.parse(stderr)
+		expect(envelope.error.details).toStrictEqual([
+			{ source: 'schema', path: 'acl.admin.inherits.ghost', code: 'ACL_UNDEFINED_ROLE', message: 'Referenced role not exists.' },
+		])
+		expect(envelope.ok).toBe(false)
+		expect(envelope.error.code).toBe('SCHEMA_INVALID')
+		expect(envelope.error.retryable).toBe(false)
+	})
+
+	test('--json emits an empty array and exits 0 for a valid, in-sync project', async () => {
+		const { validateCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout, stderr } = await runApplication(
+			['project', 'validate', '--json'],
+			{ ['project validate']: () => validateCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.Success)
+		expect(JSON.parse(stdout)).toStrictEqual([])
+		expect(stderr).toBe('')
+	})
+
+	test('human mode renders a readable table on stdout and the summary error on stderr', async () => {
+		const { validateCommand } = await buildProjectCommands(schemaWithKnownError)
+		const { exitCode, stdout, stderr } = await runApplication(
+			['project', 'validate'],
+			{ ['project validate']: () => validateCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.InputError)
+		expect(stdout).toContain('ACL_UNDEFINED_ROLE')
+		expect(stdout).toContain('acl.admin.inherits.ghost')
+		expect(stderr).toContain('SCHEMA_INVALID')
+	})
+
+	test('human mode prints nothing but a success diagnostic for a valid project', async () => {
+		const { validateCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout, stderr } = await runApplication(
+			['project', 'validate'],
+			{ ['project validate']: () => validateCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.Success)
+		expect(stdout).toBe('')
+		expect(stderr).toContain('Project schema is valid')
+	})
+})
+
+describe('project print-schema — --format and --json are orthogonal', () => {
+	test('--format graphql (default) prints raw SDL text, not JSON', async () => {
+		const { printSchemaCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout } = await runApplication(
+			['project', 'print-schema'],
+			{ ['project print-schema']: () => printSchemaCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.Success)
+		expect(stdout.startsWith('"')).toBe(false)
+		expect(() => JSON.parse(stdout)).toThrow()
+	})
+
+	test('--format graphql --json wraps the same SDL text as a single JSON string (not double-encoded)', async () => {
+		const { printSchemaCommand: human } = await buildProjectCommands(emptySchema)
+		const { printSchemaCommand: json } = await buildProjectCommands(emptySchema)
+		const plain = await runApplication(['project', 'print-schema'], { ['project print-schema']: () => human })
+		const wrapped = await runApplication(['project', 'print-schema', '--json'], { ['project print-schema']: () => json })
+
+		expect(wrapped.exitCode).toBe(ExitCode.Success)
+		const parsed = wrapped.stdout
+		const decoded = JSON.parse(parsed)
+		expect(typeof decoded).toBe('string')
+		expect(decoded).toBe(plain.stdout.replace(/\n$/, ''))
+	})
+
+	test('--format graphql --quiet preserves the raw multi-line SDL', async () => {
+		const { printSchemaCommand: human } = await buildProjectCommands(emptySchema)
+		const { printSchemaCommand: quiet } = await buildProjectCommands(emptySchema)
+		const plain = await runApplication(['project', 'print-schema'], { ['project print-schema']: () => human })
+		const minimal = await runApplication(['project', 'print-schema', '--quiet'], { ['project print-schema']: () => quiet })
+
+		expect(minimal.exitCode).toBe(ExitCode.Success)
+		expect(minimal.stdout).toBe(plain.stdout)
+	})
+
+	test('--format introspection already produces JSON; --json prints the same object once, not a re-encoded string', async () => {
+		const { printSchemaCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout } = await runApplication(
+			['project', 'print-schema', '--format', 'introspection', '--json'],
+			{ ['project print-schema']: () => printSchemaCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.Success)
+		const decoded = JSON.parse(stdout)
+		// a double-encoded payload would decode to a string, not an object
+		expect(typeof decoded).toBe('object')
+		expect(Array.isArray(decoded.entities)).toBe(true)
+	})
+
+	test('--format introspection without --json still prints valid (tab-indented) JSON', async () => {
+		const { printSchemaCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout } = await runApplication(
+			['project', 'print-schema', '--format', 'introspection'],
+			{ ['project print-schema']: () => printSchemaCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.Success)
+		expect(JSON.parse(stdout)).toStrictEqual({ enums: [], entities: [] })
+	})
+
+	test('an unknown format is a stable InputError, not a crash', async () => {
+		const { printSchemaCommand } = await buildProjectCommands(emptySchema)
+		const { exitCode, stdout, stderr } = await runApplication(
+			['project', 'print-schema', '--format', 'yaml', '--json'],
+			{ ['project print-schema']: () => printSchemaCommand },
+		)
+
+		expect(exitCode).toBe(ExitCode.InputError)
+		expect(stdout).toBe('')
+		expect(JSON.parse(stderr).error.code).toBe('UNKNOWN_FORMAT')
+	})
+})

package/tests/cases/unit/structured-output.test.ts

@@ -0,0 +1,189 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test'
+import { CliError, CommandManager, ExitCode } from '@contember/cli-common'
+import {
+	JsonLoader,
+	MigrationDescriber,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	ModificationHandlerFactory,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { emptySchema } from '@contember/schema-utils'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { CommandsCommand } from '../../../src/commands/misc/CommandsCommand.js'
+import { VersionCommand } from '../../../src/commands/misc/VersionCommand.js'
+import { MigrationDescribeCommand } from '../../../src/commands/migrations/MigrationDescribeCommand.js'
+import { ProjectGenerateDocumentationCommand } from '../../../src/commands/project/ProjectGenerateDocumentationCommand.js'
+import { TenantPersonShowCommand } from '../../../src/commands/tenant/person/TenantPersonShowCommand.js'
+import { TenantConfigShowCommand } from '../../../src/commands/tenant/project/TenantConfigShowCommand.js'
+import { TenantProjectShowCommand } from '../../../src/commands/tenant/project/TenantProjectShowCommand.js'
+import { TenantWhoAmICommand } from '../../../src/commands/tenant/project/TenantWhoAmICommand.js'
+import { MigrationPrinter } from '../../../src/lib/migrations/MigrationPrinter.js'
+import { RemoteProject } from '../../../src/lib/project/RemoteProject.js'
+import { RemoteProjectProvider } from '../../../src/lib/project/RemoteProjectProvider.js'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { TenantClientProvider } from '../../../src/lib/TenantClientProvider.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+const API_URL = 'http://tenant.test'
+const temporaryDirectories: string[] = []
+const requests: { query: string; variables: unknown }[] = []
+let tenantResponse: unknown = {}
+const originalFetch = globalThis.fetch
+
+beforeAll(() => {
+	globalThis.fetch = async (_input: RequestInfo | URL, init?: RequestInit) => {
+		const request: { query: string; variables: unknown } = JSON.parse(String(init?.body))
+		requests.push(request)
+		return new Response(JSON.stringify({ data: tenantResponse }), { status: 200 })
+	}
+})
+
+afterEach(async () => {
+	requests.length = 0
+	tenantResponse = {}
+	await Promise.all(temporaryDirectories.splice(0).map(directory => fs.rm(directory, { recursive: true, force: true })))
+})
+
+afterAll(() => {
+	globalThis.fetch = originalFetch
+})
+
+const createTenantClientProvider = (): TenantClientProvider => {
+	const remoteProjectProvider = new RemoteProjectProvider()
+	remoteProjectProvider.setRemoteProject(new RemoteProject('blog', API_URL, 'token'))
+	return new TenantClientProvider(remoteProjectProvider)
+}
+
+const createMigrationServices = async () => {
+	const migrationsDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-structured-output-'))
+	temporaryDirectories.push(migrationsDirectory)
+	const filesManager = new MigrationFilesManager(migrationsDirectory, { json: new JsonLoader(new MigrationParser()) })
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const modificationHandlerFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const schemaMigrator = new SchemaMigrator(modificationHandlerFactory)
+	const stateManager = new SchemaStateManager(path.join(migrationsDirectory, 'state'))
+	return {
+		migrationsDirectory,
+		migrationsResolver,
+		migrationPrinter: new MigrationPrinter(new MigrationDescriber(modificationHandlerFactory)),
+		schemaVersionBuilder: new SchemaVersionBuilder(migrationsResolver, schemaMigrator, stateManager),
+	}
+}
+
+describe('structured command quiet output', () => {
+	test('commands discovery prints canonical command names', async () => {
+		const command = new CommandsCommand()
+		const versionFactory = () => new VersionCommand('1.2.3')
+		command.setCommandManager(
+			new CommandManager({
+				'version show': versionFactory,
+				'version:show': versionFactory,
+			}),
+		)
+		const { output, stdout } = createTestOutput()
+
+		await command.run(['--quiet'], output)
+
+		expect(stdout.lines).toEqual(['version show'])
+	})
+
+	test('migration describe prints the stable migration version', async () => {
+		const services = await createMigrationServices()
+		const version = '2026-08-12-120000'
+		await fs.writeFile(
+			path.join(services.migrationsDirectory, `${version}-empty.json`),
+			JSON.stringify({ formatVersion: VERSION_LATEST, modifications: [] }),
+		)
+		const command = new MigrationDescribeCommand(
+			services.migrationPrinter,
+			services.schemaVersionBuilder,
+			services.migrationsResolver,
+		)
+		const { output, stdout } = createTestOutput()
+
+		await command.run(['--quiet'], output)
+
+		expect(stdout.lines).toEqual([version])
+	})
+
+	test('project documentation prints its output destination', async () => {
+		const services = await createMigrationServices()
+		const schemaLoader: SchemaLoader = { loadSchema: async () => emptySchema }
+		const command = new ProjectGenerateDocumentationCommand(schemaLoader, services.schemaVersionBuilder, async () => '<html>project</html>')
+		const { output, stdout } = createTestOutput()
+		const destination = path.relative(process.cwd(), path.join(services.migrationsDirectory, 'project.html'))
+
+		await command.run(['--output', destination, '--quiet'], output)
+
+		expect(stdout.lines).toEqual([destination])
+	})
+
+	test('person show prints the person id', async () => {
+		tenantResponse = {
+			personById: {
+				id: 'person-1',
+				email: 'person@example.test',
+				name: 'Person',
+				otpEnabled: false,
+				emailOtpEnabled: false,
+				emailVerified: true,
+				passwordlessEnabled: null,
+				identity: { id: 'identity-1', roles: [], sessions: [] },
+				identityProviders: [],
+			},
+		}
+		const { output, stdout } = createTestOutput()
+
+		await new TenantPersonShowCommand(createTenantClientProvider()).run(['person-1', '--quiet'], output)
+
+		expect(stdout.lines).toEqual(['person-1'])
+	})
+
+	test('project show prints the stable project slug', async () => {
+		tenantResponse = {
+			projectBySlug: { id: 'project-1', name: 'Blog', slug: 'blog', config: {}, roles: [], secrets: [] },
+		}
+		const { output, stdout } = createTestOutput()
+
+		await new TenantProjectShowCommand(createTenantClientProvider()).run(['blog', '--quiet'], output)
+
+		expect(stdout.lines).toEqual(['blog'])
+	})
+
+	test('whoami prints the identity id', async () => {
+		tenantResponse = {
+			me: { id: 'identity-1', description: null, roles: [], permissions: null, projects: [] },
+		}
+		const { output, stdout } = createTestOutput()
+
+		await new TenantWhoAmICommand(createTenantClientProvider()).run(['--quiet'], output)
+
+		expect(stdout.lines).toEqual(['identity-1'])
+	})
+
+	test('tenant config rejects quiet mode before making a request', async () => {
+		const { output, stdout } = createTestOutput()
+		let thrown: unknown
+
+		try {
+			await new TenantConfigShowCommand(createTenantClientProvider()).run(['--quiet'], output)
+		} catch (error) {
+			thrown = error
+		}
+
+		expect(thrown).toBeInstanceOf(CliError)
+		if (thrown instanceof CliError) {
+			expect(thrown.code).toBe('QUIET_OUTPUT_UNSUPPORTED')
+			expect(thrown.exitCode).toBe(ExitCode.InputError)
+		}
+		expect(stdout.text).toBe('')
+		expect(requests).toHaveLength(0)
+	})
+})