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

package/src/commands/deploy/DeployCommand.ts

@@ -1,34 +1,33 @@
-import { Command, CommandConfiguration, Input, pathExists, Workspace } from '@contember/cli-common'
-import {
-	configureExecuteMigrationCommand,
-	ExecuteMigrationOptions,
-	executeMigrations,
-	resolveMigrationStatus,
-} from '../../utils/migrations/MigrationExecuteHelper'
-import { interactiveResolveApiToken, TenantClient } from '../../utils/tenant'
-import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
-import { SystemClient } from '@contember/migrations-client'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
-import { AdminClient, readAdminFiles } from '../../utils/admin'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
 import prompts from 'prompts'
-import { createMigrationStatusTable } from '../../utils/migrations/migrations'
-import { maskToken } from '../../utils/token'
-import { parseDsn } from '../../utils/dsn'
+import { maskToken } from '../../lib/maskToken'
+import { MigrationExecutionFacade } from '../../lib/migrations/MigrationExecutionFacade'
+import { AdminDeployer } from '../../lib/admin/AdminDeployer'
+import { FileSystem } from '../../lib/fs/FileSystem'
+import { RemoteProject } from '../../lib/project/RemoteProject'
+import { Workspace } from '../../lib/workspace/Workspace'
+import { RemoteProjectProvider } from '../../lib/project/RemoteProjectProvider'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
 
 type Args = {
 	dsn: string
-	project?: string
 }
 
-type Options = ExecuteMigrationOptions & {
+type Options = {
 	admin?: string
 	['no-admin']?: boolean
 	['no-migrations']?: boolean
 	root?: boolean
+	yes?: boolean
 }
 
 export class DeployCommand extends Command<Args, Options> {
 	constructor(
+		private readonly adminDeployer: AdminDeployer,
+		private readonly migrationExecutionFacade: MigrationExecutionFacade,
+		private readonly fs: FileSystem,
+		private readonly remoteProjectProvider: RemoteProjectProvider,
+		private readonly remoteProjectResolver: RemoteProjectResolver,
 		private readonly workspace: Workspace,
 	) {
 		super()
@@ -38,79 +37,62 @@ export class DeployCommand extends Command<Args, Options> {
 		configuration.description('Deploy Contember project')
 		configuration.argument('dsn')
 
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project').optional()
-		}
-
 		configuration.option('admin').valueRequired()
 		configuration.option('root').valueNone()
 		configuration.option('no-admin').valueNone()
 		configuration.option('no-migrations').valueNone()
-
-		configureExecuteMigrationCommand(configuration)
+		configuration //
+			.option('yes')
+			.valueNone()
+			.description('Do not ask for confirmation.')
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<void | number> {
-		const [dsn, projectName] = this.getNormalizedInput(input)
-		const project = await this.workspace.projects.getProject(projectName, { fuzzy: true })
-
-		let apiUrl = input.getOption('instance')
-		let adminEndpoint = input.getOption('admin')
-
-		let apiTokenFromDsn: string | undefined = undefined
-
-		let remoteProject = input.getOption('remote-project') || project.name
 
-		if (dsn) {
-			({ project: remoteProject, endpoint: adminEndpoint, token: apiTokenFromDsn  } = parseDsn(dsn))
+		const dsn = input.getArgument('dsn')
+		const remoteProject = this.remoteProjectResolver.resolve(dsn)
+		if (!remoteProject) {
+			throw `Project not defined. Please provide DSN or environment variables CONTEMBER_*`
 		}
+		this.remoteProjectProvider.setRemoteProject(remoteProject)
+
+		let adminEndpoint = input.getOption('admin')
+		const deployMigration = input.getOption('no-migrations') !== true
+		const yes = input.getOption('yes') === true
+		const projectAdminDistDir = this.workspace.adminDistDir
+		const deployAdmin = input.getOption('no-admin') !== true && !!adminEndpoint && !!projectAdminDistDir
 
-		const instance = await interactiveResolveInstanceEnvironmentFromInput(this.workspace, apiUrl ?? (adminEndpoint ? adminEndpoint + '/_api' : undefined))
-		const apiToken = await interactiveResolveApiToken({ workspace: this.workspace, instance, apiToken: apiTokenFromDsn })
 
 		console.log('')
 		console.log('Contember project deployment configuration:')
-		console.log(`Local project name: ${project.name}`)
-		console.log(`Target project name: ${remoteProject}`)
-		console.log(`API URL: ${instance.baseUrl}`)
+		console.log(`Target project name: ${remoteProject.name}`)
+		console.log(`API URL: ${remoteProject.endpoint}`)
 		console.log(`Admin URL: ${adminEndpoint ?? 'none'}`)
-		console.log(`Deploy token: ${maskToken(apiToken)}`)
+		console.log(`Deploy token: ${maskToken(remoteProject.token)}`)
 		console.log('')
 
-		const projectAdminDistDir = `${project.adminDir}/dist`
 
-		const noAdmin = input.getOption('no-admin') === true
-
-		if (adminEndpoint && !noAdmin && !(await pathExists(`${projectAdminDistDir}/index.html`))) {
+		if (deployAdmin && !(await this.fs.pathExists(`${projectAdminDistDir}/index.html`))) {
 			throw `Missing ${projectAdminDistDir}/index.html. Please build admin before deploying.`
 		}
 
-		if (input.getOption('no-migrations') !== true) {
-			const migrationsDir = project.migrationsDir
-			const container = new MigrationsContainerFactory(migrationsDir).create()
-
-			const tenantClient = TenantClient.create(instance.baseUrl, apiToken)
-			await tenantClient.createProject(remoteProject, true)
-			const systemClient = SystemClient.create(instance.baseUrl, remoteProject, apiToken)
-
-			const status = await resolveMigrationStatus(systemClient, container.migrationsResolver, false)
-
-			if (status.errorMigrations.length > 0) {
-				console.error(createMigrationStatusTable(status.errorMigrations))
-				throw `Cannot execute migrations`
+		if (deployMigration) {
+			const result = await this.migrationExecutionFacade.execute({
+				force: false,
+				requireConfirmation: !yes,
+				additionalMessage: deployAdmin ? 'Admin will be deployed.' : 'Admin will NOT be deployed.',
+			})
+			if (!result) {
+				return
 			}
+		}
 
-			if (status.migrationsToExecute.length === 0 && !adminEndpoint) {
-				console.log('Nothing to do.')
-				return 0
-			}
-			if (!input.getOption('yes')) {
+		if (deployAdmin) {
+			if (!deployMigration && !yes) {
 				if (!process.stdin.isTTY) {
 					throw 'TTY not available. Pass --yes option to confirm execution.'
 				}
-				console.log('Following migrations will be executed:')
-				console.log(status.migrationsToExecute.length ? status.migrationsToExecute.map(it => it.name).join(' ') : 'none')
-				console.log(adminEndpoint && !noAdmin ? 'Admin will be deployed.' : 'Admin will NOT be deployed.')
+				console.log('Admin will be deployed.')
 				console.log('(to skip this dialog, you can pass --yes option)')
 				console.log('')
 				const { ok } = await prompts({
@@ -122,55 +104,17 @@ export class DeployCommand extends Command<Args, Options> {
 					return 1
 				}
 			}
-			const migrationExitCode = await executeMigrations({
-				migrationDescriber: container.migrationDescriber,
-				schemaVersionBuilder: container.schemaVersionBuilder,
-				client: systemClient,
-				migrations: status.migrationsToExecute,
-				requireConfirmation: false,
-				force: false,
-				contentMigrationFactoryArgs: {
-					apiToken,
-					apiBaseUrl: instance.baseUrl.replace(/\/$/, ''),
-					projectName: remoteProject,
-				},
+			await this.adminDeployer.deploy({
+				dir: projectAdminDistDir,
+				root: input.getOption('root') === true,
 			})
-
-			if (migrationExitCode !== 0) {
-				return migrationExitCode
-			}
-		}
-
-		if (adminEndpoint && !noAdmin) {
-			console.log('Deploying admin...')
-
-			const client = AdminClient.create(adminEndpoint, apiToken)
-			const files = await readAdminFiles(projectAdminDistDir)
-
-			// in some cases you need deploy whole folder with custom build etc.
-			// with root option you can build app on your own and simply deploy it with subprojects
-			await client.deploy(
-				input.getOption('root') ? null : remoteProject, files,
-			)
-
-			console.log(`Admin deployed (${files.length} files)`)
 		}
 
 		console.log('')
 		console.log('Deployment successful')
-		console.log(`API URL: ${instance.baseUrl}`)
+		console.log(`API URL: ${remoteProject.endpoint}`)
 		console.log(`Admin URL: ${adminEndpoint ?? 'none'}`)
 
 		return 0
 	}
-
-	private getNormalizedInput(input: Input<Args, Options>): [string | undefined, string | undefined] {
-		const projectOrDsnInput = input.getArgument('dsn')
-		const secondInput = input.getArgument('project')
-
-		const isUriLike = projectOrDsnInput.includes('://')
-		const dsn = isUriLike ? projectOrDsnInput : undefined
-		const projectName = !isUriLike ? projectOrDsnInput : secondInput
-		return [dsn, projectName]
-	}
 }

package/src/commands/index.ts

@@ -2,5 +2,4 @@ export * from './deploy'
 export * from './migrations'
 export * from './misc'
 export * from './project'
-export * from './tenant'
 export * from './workspace'

package/src/commands/migrations/MigrationAmendCommand.ts

@@ -1,17 +1,16 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { printValidationErrors } from '../../utils/schema'
-import { InvalidSchemaException } from '@contember/schema-migrations'
-import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
-import { createMigrationStatusTable, printMigrationDescription } from '../../utils/migrations/migrations'
-import { resolveMigrationStatus } from '../../utils/migrations/MigrationExecuteHelper'
-import { resolveSystemApiClient } from './SystemApiClientResolver'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { InvalidSchemaException, SchemaMigrator } from '@contember/schema-migrations'
 import prompts from 'prompts'
 import { emptySchema } from '@contember/schema-utils'
-import { validateMigrations } from './MigrationValidationHelper'
-import { loadSchema } from '../../utils/project/loadSchema'
+import { MigrationCreator, MigrationsResolver, SchemaVersionBuilder, SystemClient } from '@contember/migrations-client'
+import { MigrationsStatusFacade } from '../../lib/migrations/MigrationsStatusFacade'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader'
+import { MigrationsValidator } from '../../lib/migrations/MigrationsValidator'
+import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
+import { printValidationErrors } from '../../lib/schema/SchemaValidationPrinter'
+import { SystemClientProvider } from '../../lib/SystemClientProvider'
 
 type Args = {
-	project?: string
 	migration?: string
 }
 
@@ -22,16 +21,21 @@ type Options = {
 
 export class MigrationAmendCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationsResolver: MigrationsResolver,
+		private readonly systemApiClientProvider: SystemClientProvider,
+		private readonly migrationsStatusFacade: MigrationsStatusFacade,
+		private readonly schemaLoader: SchemaLoader,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly migrationCreator: MigrationCreator,
+		private readonly migrationsValidator: MigrationsValidator,
+		private readonly migrationPrinter: MigrationPrinter,
+		private readonly schemaMigrator: SchemaMigrator,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Amends latest migration')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
 		configuration.argument('migration').optional()
 		configuration.option('force').description('Ignore migrations order and missing migrations (dev only)')
 		configuration //
@@ -41,112 +45,90 @@ export class MigrationAmendCommand extends Command<Args, Options> {
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<number> {
-		return await executeCreateMigrationCommand(
-			input,
-			{ workspace: this.workspace },
-			async ({
-				schemaVersionBuilder,
-				migrationsResolver,
-				workspace,
-				project,
-				migrationCreator,
-				migrationDescriber,
-				schemaMigrator,
-			}) => {
-				const migrationName = input.getArgument('migration')
-				const amendMigration = migrationName
-					? await migrationsResolver.findSchemaMigrationByVersion(migrationName)
-					: await migrationsResolver.findLatestSchemaMigration()
+		const migrationName = input.getArgument('migration')
+		const amendMigration = migrationName
+			? await this.migrationsResolver.findSchemaMigrationByVersion(migrationName)
+			: await this.migrationsResolver.findLatestSchemaMigration()
+		if (!amendMigration) {
+			throw 'No migration to amend'
+		}
+		const force = input.getOption('force')
+		const status = await this.migrationsStatusFacade.resolveMigrationsStatus({ force })
+		if (status.migrationsToExecute.length > 0) {
+			throw `Some migrations are not executed. Unable to amend.`
+		}
 
-				if (!amendMigration) {
-					throw 'No migration to amend'
-				}
-				const client = await resolveSystemApiClient(workspace, project)
-				const status = await resolveMigrationStatus(client, migrationsResolver)
-				const force = input.getOption('force')
-				if (status.errorMigrations.length > 0) {
-					console.error(createMigrationStatusTable(status.errorMigrations))
-					if (!force) {
-						throw `Cannot execute migrations`
-					}
-				}
-				if (status.migrationsToExecute.length > 0) {
-					throw `Some migrations are not executed. Unable to amend.`
-				}
-				const schema = await loadSchema(project)
-				try {
-					const initialSchema = await schemaVersionBuilder.buildSchema()
-					const intermediateResult = await migrationCreator.prepareMigration(initialSchema, schema, '')
-					if (intermediateResult === null) {
-						console.log('Nothing to do')
-						return 0
-					}
-					if (amendMigration.formatVersion !== intermediateResult.migration.formatVersion) {
-						throw 'Incompatible migration format version'
-					}
-					const prevSchema = await schemaVersionBuilder.buildSchemaAdvanced(
-						emptySchema,
-						version => version < amendMigration.version,
-					)
-					const newSchema = await schemaMigrator.applyModifications(
-						prevSchema,
-						[...amendMigration.modifications, ...intermediateResult.migration.modifications],
-						amendMigration.formatVersion,
-					)
-					const newMigrationResult = await migrationCreator.prepareMigration(prevSchema, newSchema, '')
-					const followingMigrations = (await migrationsResolver.getSchemaMigrations()).filter(
-						it => it.version > amendMigration.version,
-					)
 
-					const valid = await validateMigrations(
-						prevSchema,
-						[...(newMigrationResult ? [newMigrationResult.migration] : []), ...followingMigrations],
-						migrationDescriber,
-						schemaMigrator,
-					)
-					if (!valid) {
-						throw `Cannot amend migration`
-					}
+		const schema = await this.schemaLoader.loadSchema()
+		try {
+			const initialSchema = await this.schemaVersionBuilder.buildSchema()
+			const intermediateResult = await this.migrationCreator.prepareMigration(initialSchema, schema, '')
+			if (intermediateResult === null) {
+				console.log('Nothing to do')
+				return 0
+			}
+			if (amendMigration.formatVersion !== intermediateResult.migration.formatVersion) {
+				throw 'Incompatible migration format version'
+			}
+			const prevSchema = await this.schemaVersionBuilder.buildSchemaAdvanced(
+				emptySchema,
+				version => version < amendMigration.version,
+			)
+			const newSchema = await this.schemaMigrator.applyModifications(
+				prevSchema,
+				[...amendMigration.modifications, ...intermediateResult.migration.modifications],
+				amendMigration.formatVersion,
+			)
+			const newMigrationResult = await this.migrationCreator.prepareMigration(prevSchema, newSchema, '')
+			const followingMigrations = (await this.migrationsResolver.getSchemaMigrations()).filter(
+				it => it.version > amendMigration.version,
+			)
 
-					await printMigrationDescription(
-						migrationDescriber,
-						intermediateResult.initialSchema,
-						intermediateResult.migration,
-						{ noSql: true },
-					)
-					console.log(`Amending ${amendMigration.name}`)
-					if (!(await this.shouldContinue(input))) {
-						console.log('Aborting')
-						return 1
-					}
-					await client.migrate([intermediateResult.migration], force)
-					await client.migrationDelete(intermediateResult.migration.version)
+			const valid = await this.migrationsValidator.validate(
+				prevSchema,
+				[...(newMigrationResult ? [newMigrationResult.migration] : []), ...followingMigrations],
+			)
+			if (!valid) {
+				throw `Cannot amend migration`
+			}
 
-					if (!newMigrationResult) {
-						await migrationCreator.removeMigration(amendMigration.name)
-						await client.migrationDelete(amendMigration.version)
-						console.log('Latest migration was removed')
-						return 0
-					}
-					const newMigration = {
-						name: amendMigration.name,
-						version: amendMigration.version,
-						formatVersion: newMigrationResult.migration.formatVersion,
-						modifications: newMigrationResult.migration.modifications,
-					}
-					await migrationCreator.saveMigration(newMigration)
-					await client.migrationModify(amendMigration.version, newMigration)
+			this.migrationPrinter.printMigrationDescription(
+				intermediateResult.initialSchema,
+				intermediateResult.migration,
+				{ noSql: true },
+			)
+			console.log(`Amending ${amendMigration.name}`)
+			if (!(await this.shouldContinue(input))) {
+				console.log('Aborting')
+				return 1
+			}
+			const systemClient = this.systemApiClientProvider.get()
+			await systemClient.migrate([intermediateResult.migration], force)
+			await systemClient.migrationDelete(intermediateResult.migration.version)
 
-					return 0
-				} catch (e) {
-					if (e instanceof InvalidSchemaException) {
-						printValidationErrors(e.validationErrors, e.message)
-						return 1
-					}
-					throw e
-				}
-			},
-		)
+			if (!newMigrationResult) {
+				await this.migrationCreator.removeMigration(amendMigration.name)
+				await systemClient.migrationDelete(amendMigration.version)
+				console.log('Latest migration was removed')
+				return 0
+			}
+			const newMigration = {
+				name: amendMigration.name,
+				version: amendMigration.version,
+				formatVersion: newMigrationResult.migration.formatVersion,
+				modifications: newMigrationResult.migration.modifications,
+			}
+			await this.migrationCreator.saveMigration(newMigration)
+			await systemClient.migrationModify(amendMigration.version, newMigration)
+
+			return 0
+		} catch (e) {
+			if (e instanceof InvalidSchemaException) {
+				printValidationErrors(e.validationErrors, e.message)
+				return 1
+			}
+			throw e
+		}
 	}
 
 	private async shouldContinue(input: Input<{}, { yes?: true }>): Promise<boolean> {

package/src/commands/migrations/MigrationBlankCommand.ts

@@ -1,8 +1,7 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { executeCreateMigrationCommand } from '../../utils/migrations/MigrationCreateHelper'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { MigrationCreator } from '@contember/migrations-client'
 
 type Args = {
-	project?: string
 	migrationName: string
 	format?: string
 }
@@ -12,35 +11,24 @@ type Options = {
 
 export class MigrationBlankCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationCreator: MigrationCreator,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Creates new blank migration file')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-
-		}
 		configuration.argument('migrationName')
 		configuration.argument('format').optional().validator(it => !it || ['js', 'ts', 'json'].includes(it))
 			.description('Migration file format (js, ts, json), default is ts.')
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<number> {
-		return await executeCreateMigrationCommand(
-			input,
-			{ workspace: this.workspace },
-			async ({
-				migrationCreator,
-			}) => {
-				const filename = await migrationCreator.createEmptyMigrationFile(input.getArgument('migrationName'), input.getArgument('format') || 'ts')
-				console.log(`${filename} created`)
-
-				return 0
-			},
-		)
+		const migrationName = input.getArgument('migrationName')
+		const migrationFormat = input.getArgument('format') || 'ts'
+		const filename = await this.migrationCreator.createEmptyMigrationFile(migrationName, migrationFormat)
+		console.log(`${filename} created`)
+		return 0
 	}
 }
 

package/src/commands/migrations/MigrationDescribeCommand.ts

@@ -1,9 +1,8 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
-import { printMigrationDescription } from '../../utils/migrations/migrations'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { MigrationPrinter } from '../../lib/migrations/MigrationPrinter'
+import { MigrationsResolver, SchemaVersionBuilder } from '@contember/migrations-client'
 
 type Args = {
-	project?: string
 	migration?: string
 }
 
@@ -15,42 +14,33 @@ type Options = {
 
 export class MigrationDescribeCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly migrationPrinter: MigrationPrinter,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly migrationsResolver: MigrationsResolver,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Describes a migration')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
 		configuration.argument('migration').optional()
 		configuration.option('sql-only').valueNone()
 		configuration.option('no-sql').valueNone()
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<void> {
-		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 migrationArg = input.getArgument('migration')
-		const migrationsResolver = container.migrationsResolver
+		const sqlOnly = input.getOption('sql-only')
+		const noSql = input.getOption('no-sql')
 
 		const migration = migrationArg
-			? await migrationsResolver.findSchemaMigrationByVersion(migrationArg)
-			: await migrationsResolver.findLatestSchemaMigration()
+			? await this.migrationsResolver.findSchemaMigrationByVersion(migrationArg)
+			: await this.migrationsResolver.findLatestSchemaMigration()
 
 		if (!migration) {
 			throw 'Undefined migration'
 		}
-		const schema = await container.schemaVersionBuilder.buildSchemaUntil(migration.version)
-		const sqlOnly = input.getOption('sql-only')
-		const noSql = input.getOption('no-sql')
-		printMigrationDescription(container.migrationDescriber, schema, migration, { sqlOnly, noSql })
+		const schema = await this.schemaVersionBuilder.buildSchemaUntil(migration.version)
+		this.migrationPrinter.printMigrationDescription(schema, migration, { sqlOnly, noSql })
 	}
 }