@contember/cli 1.4.0-rc.7 → 2.0.0-alpha.10

package/src/commands/migrations/MigrationDiffCommand.ts

@@ -1,17 +1,13 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { printValidationErrors } from '../../utils/schema'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
 import { InvalidSchemaException } from '@contember/schema-migrations'
-import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
-import { createMigrationStatusTable, printMigrationDescription } from '../../utils/migrations/migrations'
-import { executeMigrations, resolveMigrationStatus } from '../../utils/migrations/MigrationExecuteHelper'
 import prompts from 'prompts'
-import { interactiveResolveApiToken, TenantClient } from '../../utils/tenant'
-import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
-import { SystemClient } from '@contember/migrations-client'
-import { loadSchema } from '../../utils/project/loadSchema'
+import { MigrationCreator, SchemaVersionBuilder } from '@contember/migrations-client'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader'
+import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
+import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade'
+import { printValidationErrors } from '../../lib/schema/SchemaValidationPrinter'
 
 type Args = {
-	project?: string
 	migrationName: string
 }
 
@@ -23,16 +19,17 @@ type Options = {
 
 export class MigrationDiffCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly schemaLoader: SchemaLoader,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly migrationCreator: MigrationCreator,
+		private readonly migrationPrinter: MigrationPrinter,
+		private readonly migrationExecutorFacade: MigrationExecutionFacade,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
-		configuration.description('Creates schema migration diff for given project')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
+		configuration.description('Creates schema migration diff')
 		configuration.argument('migrationName')
 		configuration.option('execute').valueNone()
 		configuration //
@@ -43,89 +40,63 @@ export class MigrationDiffCommand extends Command<Args, Options> {
 		configuration.option('skip-initial-schema-validation')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
-		return await executeCreateMigrationCommand(
-			input,
-			{ workspace: this.workspace },
-			async ({
-				schemaVersionBuilder,
-				migrationsResolver,
-				workspace,
-				project,
-				migrationCreator,
-				migrationDescriber,
-			}) => {
-				const schema = await loadSchema(project)
-				try {
-					const migrationName = input.getArgument('migrationName')
-					const initialSchema = await schemaVersionBuilder.buildSchema()
-					const result = await migrationCreator.prepareMigration(initialSchema, schema, migrationName, {
-						skipInitialSchemaValidation: input.getOption('skip-initial-schema-validation') === true,
-					})
-					if (result === null) {
-						console.log('Nothing to do')
-						return 0
-					}
-					await printMigrationDescription(migrationDescriber, result.initialSchema, result.migration, { noSql: true })
-					const yes = input.getOption('yes')
-					let shouldExecute = input.getOption('execute')
-					if (!yes) {
-						const { action } = await prompts({
-							type: 'select',
-							name: 'action',
-							message: 'Do you want to continue?',
-							choices: [
-								{ value: 'yes', title: 'Yes' },
-								...(!shouldExecute ? [{ value: 'execute', title: 'Yes and execute immediately' }] : []),
-								{ value: 'no', title: 'Abort' },
-							],
-						})
-						if (!action || action === 'no') {
-							console.log('Aborting')
-							return 1
-						}
-						if (action === 'execute') {
-							shouldExecute = true
-						}
-					}
-					const filename = await migrationCreator.saveMigration(result.migration)
+	protected async execute(input: Input<Args, Options>): Promise<void> {
+		const migrationName = input.getArgument('migrationName')
+		let shouldExecute = input.getOption('execute')
+		const yes = input.getOption('yes')
+		const skipInitialSchemaValidation = input.getOption('skip-initial-schema-validation') === true
 
-					console.log(`${filename} created`)
+		const schema = await this.schemaLoader.loadSchema()
+		try {
+			const initialSchema = await this.schemaVersionBuilder.buildSchema()
+			const result = await this.migrationCreator.prepareMigration(initialSchema, schema, migrationName, {
+				skipInitialSchemaValidation: skipInitialSchemaValidation,
+			})
+			if (result === null) {
+				console.log('Nothing to do')
+				return
+			}
+			this.migrationPrinter.printMigrationDescription(result.initialSchema, result.migration, { noSql: true })
 
-					if (shouldExecute) {
-						const instance = await interactiveResolveInstanceEnvironmentFromInput(workspace)
-						const apiToken = await interactiveResolveApiToken({ workspace, instance })
-						const tenantClient = TenantClient.create(instance.baseUrl, apiToken)
-						await tenantClient.createProject(project.name, true)
-						const systemClient = SystemClient.create(instance.baseUrl, project.name, apiToken)
 
-						const status = await resolveMigrationStatus(systemClient, migrationsResolver)
-						if (status.errorMigrations.length > 0) {
-							console.error(createMigrationStatusTable(status.errorMigrations))
-							throw `Cannot execute migrations`
-						}
-						await executeMigrations({
-							client: systemClient,
-							migrations: status.migrationsToExecute,
-							requireConfirmation: status.migrationsToExecute.length > 1 && !yes,
-							schemaVersionBuilder,
-							migrationDescriber,
-							contentMigrationFactoryArgs: {
-								apiToken,
-								apiBaseUrl: instance.baseUrl.replace(/\/$/, ''),
-								projectName: project.name,
-							},
-						})
-					}
-					return 0
-				} catch (e) {
-					if (e instanceof InvalidSchemaException) {
-						printValidationErrors(e.validationErrors, e.message)
-						return 1
-					}
-					throw e
+			if (!yes) {
+				const { action } = await prompts({
+					type: 'select',
+					name: 'action',
+					message: 'Do you want to continue?',
+					choices: [
+						{ value: 'yes', title: 'Yes' },
+						...(!shouldExecute ? [{ value: 'execute', title: 'Yes and execute immediately' }] : []),
+						{ value: 'no', title: 'Abort' },
+					],
+				})
+				if (!action || action === 'no') {
+					console.log('Aborting')
+					return
+				}
+				if (action === 'execute') {
+					shouldExecute = true
 				}
-			},
-		)
+			}
+
+			const filename = await this.migrationCreator.saveMigration(result.migration)
+
+			console.log(`${filename} created`)
+
+		} catch (e) {
+			if (e instanceof InvalidSchemaException) {
+				printValidationErrors(e.validationErrors, e.message)
+
+				return
+			}
+			throw e
+		}
+
+		if (shouldExecute) {
+			await this.migrationExecutorFacade.execute({
+				force: false,
+				requireConfirmation: !yes,
+			})
+		}
 	}
 }

package/src/commands/migrations/MigrationExecuteCommand.ts

@@ -1,103 +1,43 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
-import {
-	configureExecuteMigrationCommand,
-	ExecuteMigrationOptions,
-	executeMigrations,
-	resolveMigrationStatus,
-} from '../../utils/migrations/MigrationExecuteHelper'
-import { createMigrationStatusTable } from '../../utils/migrations/migrations'
-import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
-import { interactiveResolveApiToken, TenantClient } from '../../utils/tenant'
-import { SystemClient } from '@contember/migrations-client'
-import { MigrationVersionHelper } from '@contember/schema-migrations'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade'
 
 type Args = {
-	project?: string
 }
 
-type Options = ExecuteMigrationOptions & {
+type Options = {
 	until?: string
 	force: boolean
+	yes?: boolean
 }
 
 export class MigrationExecuteCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationExecutorFacade: MigrationExecutionFacade,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
-		configuration.description('Executes migrations on an instance')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
-		configuration.option('force').description('Ignore migrations order and missing migrations (dev only)')
-		configuration.option('until').valueRequired().description('Execute all migrations leading up to, and inclusive of, a specified migration')
-		configureExecuteMigrationCommand(configuration)
+		configuration.description('Executes migrations on Contember server.')
+		configuration.option('force')
+			.description('Ignore migrations order and missing migrations (dev only)')
+		configuration.option('until')
+			.valueRequired()
+			.description('Execute all migrations leading up to, and inclusive of, a specified migration')
+		configuration //
+			.option('yes')
+			.valueNone()
+			.description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
-		const projectName = input.getArgument('project')
+	protected async execute(input: Input<Args, Options>): Promise<void> {
+		const force = input.getOption('force')
+		const until = input.getOption('until')
 
-		const workspace = this.workspace
-
-		const allProjects = projectName === '.'
-		const remoteProjectOption = input?.getOption('remote-project')
-		if (remoteProjectOption && allProjects) {
-			throw 'Option remote-project can be used only for a single project'
-		}
-		const projects = allProjects
-			? await workspace.projects.listProjects()
-			: [await workspace.projects.getProject(projectName, { fuzzy: true })]
-		let code = 0
-		for (const project of projects) {
-			const migrationsDir = project.migrationsDir
-			const container = new MigrationsContainerFactory(migrationsDir).create()
-
-			const instance = await interactiveResolveInstanceEnvironmentFromInput(workspace, input?.getOption('instance'))
-			const apiToken = await interactiveResolveApiToken({ workspace, instance })
-			const remoteProject = remoteProjectOption || project.name
-			const tenantClient = TenantClient.create(instance.baseUrl, apiToken)
-			await tenantClient.createProject(remoteProject, true)
-			const systemClient = SystemClient.create(instance.baseUrl, remoteProject, apiToken)
-
-			const force = input.getOption('force')
-			const status = await resolveMigrationStatus(systemClient, container.migrationsResolver, force)
-			if (status.errorMigrations.length > 0) {
-				console.error(createMigrationStatusTable(status.errorMigrations))
-				if (!force) {
-					throw `Cannot execute migrations`
-				}
-			}
-			const until = input.getOption('until')
-			const untilNormalized = until ? MigrationVersionHelper.extractVersion(until) : null
-
-			const migrations = untilNormalized
-				? status.migrationsToExecute.filter(it => it.version <= MigrationVersionHelper.extractVersion(untilNormalized))
-				: status.migrationsToExecute
-
-			if (migrations.length === 0) {
-				console.log('No migrations to execute')
-				continue
-			}
-
-			const singleCode = await executeMigrations({
-				migrationDescriber: container.migrationDescriber,
-				schemaVersionBuilder: container.schemaVersionBuilder,
-				client: systemClient,
-				migrations,
-				requireConfirmation: !input.getOption('yes'),
-				force: force,
-				contentMigrationFactoryArgs: {
-					apiToken,
-					apiBaseUrl: instance.baseUrl.replace(/\/$/, ''),
-					projectName: remoteProject,
-				},
-			})
-			code ||= singleCode
-		}
-		return code
+		await this.migrationExecutorFacade.execute({
+			force,
+			until,
+			requireConfirmation: !input.getOption('yes'),
+		})
 	}
 }

package/src/commands/migrations/MigrationRebaseCommand.ts

@@ -1,12 +1,8 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { MigrationVersionHelper } from '@contember/schema-migrations'
-import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
-import { resolveSystemApiClient } from './SystemApiClientResolver'
-import { emptySchema } from '@contember/schema-utils'
-import { validateMigrations } from './MigrationValidationHelper'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { Migration, MigrationsResolver } from '@contember/migrations-client'
+import { MigrationRebaseFacade } from '../../lib/migrations/MigrationRebaseFacade'
 
 type Args = {
-	project?: string
 	migration: string[]
 }
 
@@ -16,7 +12,8 @@ type Options = {
 
 export class MigrationRebaseCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationsResolver: MigrationsResolver,
+		private readonly migrationRebaseFacade: MigrationRebaseFacade,
 	) {
 		super()
 	}
@@ -24,9 +21,6 @@ export class MigrationRebaseCommand extends Command<Args, Options> {
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Rebase migrations on filesystem and in local instance')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
 		configuration.argument('migration').variadic()
 		configuration //
 			.option('yes')
@@ -34,57 +28,21 @@ export class MigrationRebaseCommand extends Command<Args, Options> {
 			.description('Do not ask for confirmation.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
-		return await executeCreateMigrationCommand(
-			input,
-			{ workspace: this.workspace },
-			async ({
-				schemaVersionBuilder,
-				migrationsResolver,
-				workspace,
-				project,
-				migrationCreator,
-				migrationDescriber,
-				schemaMigrator,
-				migrationFilesManager,
-			}) => {
-				const migrationNames = input.getArgument('migration')
-				const migrations = []
-				for (const migrationName of migrationNames) {
-					const migration = await migrationsResolver.findSchemaMigrationByVersion(migrationName)
-					if (!migration) {
-						throw `Migration ${migrationName} not found`
-					}
-					migrations.push(migration)
-				}
-				console.log('Rebasing: ' + migrations.map(it => it.name).join(', '))
-				const versions = migrations.map(it => it.version)
-				const schemaWithoutMigrations = await schemaVersionBuilder.buildSchemaAdvanced(
-					emptySchema,
-					version => !versions.includes(version),
-				)
-				const valid = await validateMigrations(schemaWithoutMigrations, migrations, migrationDescriber, schemaMigrator)
-				if (!valid) {
-					throw `Cannot rebase migrations`
-				}
-				const client = await resolveSystemApiClient(workspace, project)
-				let i = 0
-				for (const migration of migrations) {
-					const name = migration.name.substring(MigrationVersionHelper.prefixLength + 1)
-					const [version, fullName] = MigrationVersionHelper.createVersion(name, i++)
-					const newMigration = {
-						name: fullName,
-						version: version,
-						formatVersion: migration.formatVersion,
-						modifications: migration.modifications,
-					}
-					await client.migrationModify(migration.version, newMigration)
-					await migrationFilesManager.moveFile(migration.name, newMigration.name)
-				}
-				console.log('Done')
+	protected async execute(input: Input<Args, Options>): Promise<void> {
+
+		const migrationNames = input.getArgument('migration')
+
+		const migrations: Migration[] = []
+		for (const migrationName of migrationNames) {
+			const migration = await this.migrationsResolver.findSchemaMigrationByVersion(migrationName)
+			if (!migration) {
+				throw `Migration ${migrationName} not found`
+			}
+			migrations.push(migration)
+		}
 
-				return 0
-			},
-		)
+		console.log('Rebasing: ' + migrations.map(it => it.name).join(', '))
+		await this.migrationRebaseFacade.rebase(migrations)
+		console.log('Done')
 	}
 }

package/src/commands/migrations/MigrationStatusCommand.ts

@@ -1,20 +1,14 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
-import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
-import { interactiveResolveApiToken } from '../../utils/tenant'
-import { SystemClient } from '@contember/migrations-client'
-import { MigrationState, sortMigrations } from '@contember/migrations-client'
-import { createMigrationStatusTable } from '../../utils/migrations/migrations'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { MigrationFilesManager, MigrationState, sortMigrations, SystemClient } from '@contember/migrations-client'
 import chalk from 'chalk'
-import { resolveMigrationStatus } from '../../utils/migrations/MigrationExecuteHelper'
+import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade'
+import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
+import { SystemClientProvider } from '../../lib/SystemClientProvider'
 
 type Args = {
-	project?: string
 }
 
 type Options = {
-	instance?: string
-	['remote-project']?: string
 	['only-to-execute']?: true
 	['only-errors']?: true
 	['restore-missing']?: true
@@ -22,24 +16,16 @@ type Options = {
 
 export class MigrationStatusCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationsStatusFacade: MigrationsStatusFacade,
+		private readonly migrationFilesManager: MigrationFilesManager,
+		private readonly systemClientProvider: SystemClientProvider,
+		private readonly migrationPrinter: MigrationPrinter,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Shows status of executed migrations on an instance & sync status')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
-		configuration //
-			.option('instance')
-			.valueRequired()
-			.description('Local instance name or remote Contember API URL')
-		configuration //
-			.option('remote-project')
-			.valueRequired()
-			.description('Specify this when remote project name does not match local project name.')
 		configuration //
 			.option('only-errors')
 			.valueNone()
@@ -55,26 +41,19 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<number> {
-		const projectName = input.getArgument('project')
 
-		const workspace = this.workspace
-		const project = await workspace.projects.getProject(projectName, { fuzzy: true })
-		const migrationsDir = await project.migrationsDir
-		const container = new MigrationsContainerFactory(migrationsDir).create()
+		const onlyErrors = input.getOption('only-errors')
+		const onlyToExecute = input.getOption('only-to-execute')
+		const restoreMissing = input.getOption('restore-missing')
 
-		const instance = await interactiveResolveInstanceEnvironmentFromInput(workspace, input.getOption('instance'))
-		const apiToken = await interactiveResolveApiToken({ workspace, instance })
-		const remoteProject = input.getOption('remote-project') || project.name
-		const client = SystemClient.create(instance.baseUrl, remoteProject, apiToken)
+		let status = await this.migrationsStatusFacade.resolveMigrationsStatus({})
 
-		let status = await resolveMigrationStatus(client, container.migrationsResolver)
-		const restoreMissing = input.getOption('restore-missing')
 		if (restoreMissing) {
 			const missing = status.errorMigrations.filter(it => it.state === MigrationState.EXECUTED_MISSING)
 			for (const migration of missing) {
 				console.log(`Restoring migration ${migration.name}`)
-				const fullMigration = await client.getExecutedMigration(migration.version)
-				await container.migrationFilesManager.createFile(
+				const fullMigration = await this.systemClientProvider.get().getExecutedMigration(migration.version)
+				await this.migrationFilesManager.createFile(
 					JSON.stringify(
 						{
 							formatVersion: fullMigration.formatVersion,
@@ -86,11 +65,10 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 					fullMigration.name,
 				)
 			}
-			status = await resolveMigrationStatus(client, container.migrationsResolver)
+			status = await this.migrationsStatusFacade.resolveMigrationsStatus({})
 		}
 
-		const onlyErrors = input.getOption('only-errors')
-		const onlyToExecute = input.getOption('only-to-execute')
+
 
 		const filtered =
 			onlyErrors || onlyToExecute
@@ -99,7 +77,9 @@ export class MigrationStatusCommand extends Command<Args, Options> {
 					...(onlyToExecute ? status.migrationsToExecute : []),
 				  ])
 				: status.allMigrations
-		console.log(createMigrationStatusTable(filtered))
+
+		this.migrationPrinter.printStatusTable(filtered)
+
 		const hasErrors = status.errorMigrations.length > 0
 
 		if (hasErrors) {

package/src/commands/misc/VersionCommand.ts

@@ -1,12 +1,17 @@
-import { Command, CommandConfiguration, getPackageVersion } from '@contember/cli-common'
+import { Command, CommandConfiguration } from '@contember/cli-common'
 
 export class VersionCommand extends Command<{}, {}> {
+	constructor(
+		private readonly version: string,
+	) {
+		super()
+	}
 	protected configure(configuration: CommandConfiguration<{}, {}>): void {
 		configuration.description('Prints Contember CLI version')
 	}
 
 	protected async execute(): Promise<void | number> {
-		console.log(getPackageVersion())
+		console.log(this.version)
 		return 0
 	}
 }

package/src/commands/project/ProjectGenerateDocumentationCommand.ts

@@ -0,0 +1,47 @@
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { renderProjectInfoHtml } from '../../lib/project/docs/projectDescribe'
+import { writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader'
+import { validateSchemaAndPrintErrors } from '../../lib/schema/SchemaValidationHelper'
+
+type Args = {
+}
+
+type Options = {
+	name?: string
+	output?: string
+}
+
+export class ProjectGenerateDocumentationCommand extends Command<Args, Options> {
+	constructor(
+		private readonly schemaLoader: SchemaLoader,
+	) {
+		super()
+	}
+
+	protected configure(configuration: CommandConfiguration<Args, Options>): void {
+		configuration.description('Generates HTML documentation from project schema')
+		configuration.option('output').valueRequired().description('file name or "-" for stdout')
+		configuration.option('name').valueRequired().description('project name (for the title)')
+	}
+
+	protected async execute(input: Input<Args, Options>): Promise<number> {
+		const schema = await this.schemaLoader.loadSchema()
+		if (!validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:')) {
+			return 1
+		}
+		const name = input.getOption('name') ?? 'Contember project'
+
+		const html = await renderProjectInfoHtml(schema, name)
+		const output = input.getOption('output') ?? `${name.toLowerCase().replace(/\s+/g, '-')}.html`
+		if (output === '-') {
+			console.log(html)
+		} else {
+			console.log(`Documentation saved to ${output}`)
+			await writeFile(join(process.cwd(), output), html)
+		}
+
+		return 0
+	}
+}

package/src/commands/project/ProjectPrintSchemaCommand.ts

@@ -1,5 +1,4 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { validateSchemaAndPrintErrors } from '../../utils/schema'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
 import {
 	Authorizator,
 	EntityRulesResolver,
@@ -10,12 +9,12 @@ import {
 } from '@contember/engine-content-api'
 import { printSchema } from 'graphql'
 import { mergeSchemas } from '@graphql-tools/schema'
-import { loadSchema } from '../../utils/project/loadSchema'
 import { normalizeSchema } from '@contember/schema-utils'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader'
+import { SchemaVersionBuilder } from '@contember/migrations-client'
+import { validateSchemaAndPrintErrors } from '../../lib/schema/SchemaValidationHelper'
 
 type Args = {
-	project?: string
 }
 
 type Options = {
@@ -27,16 +26,14 @@ type Options = {
 
 export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly schemaLoader: SchemaLoader,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Prints project schema')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
 		configuration.option('format').valueRequired().description('graphql|introspection|schema')
 		configuration.option('source').valueRequired().description('migrations|definition')
 		configuration.option('role').valueArray()
@@ -44,20 +41,17 @@ export class ProjectPrintSchemaCommand extends Command<Args, Options> {
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<number> {
-		const projectName = input.getArgument('project')
-		const workspace = this.workspace
 		const format = input.getOption('format') || 'graphql'
 
-		const project = await workspace.projects.getProject(projectName, { fuzzy: true })
-		const migrationsDir = await project.migrationsDir
-		const container = new MigrationsContainerFactory(migrationsDir).create()
+
 		const schema = input.getOption('source') === 'migrations'
-			? await container.schemaVersionBuilder.buildSchema()
-			: await loadSchema(project)
+			? await this.schemaVersionBuilder.buildSchema()
+			: await this.schemaLoader.loadSchema()
 
 		if (!validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:')) {
 			return 1
 		}
+
 		const permissionFactory = new PermissionFactory()
 		const inputRoles = input.getOption('role')
 		const schemaNormalized = input.getOption('normalize') ? normalizeSchema(schema) : schema