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

package/src/commands/project/ProjectValidateCommand.ts

@@ -1,78 +1,57 @@
-import { Command, CommandConfiguration, Input, validateProjectName, Workspace } from '@contember/cli-common'
-import { MigrationsContainerFactory } from '../../utils/migrations/MigrationsContainer'
-import { validateSchemaAndPrintErrors } from '../../utils/schema'
+import { Command, CommandConfiguration } from '@contember/cli-common'
 import { emptySchema } from '@contember/schema-utils'
-import { validateMigrations } from '../migrations/MigrationValidationHelper'
-import { loadSchema } from '../../utils/project/loadSchema'
+import { SchemaLoader } from '../../lib/schema/SchemaLoader'
+import { validateSchemaAndPrintErrors } from '../../lib/schema/SchemaValidationHelper'
+import { MigrationsValidator } from '../../lib/migrations/MigrationsValidator'
+import { MigrationsResolver, SchemaVersionBuilder } from '@contember/migrations-client'
+import { SchemaDiffer } from '@contember/schema-migrations'
 
-type Args = {
-	project?: string
-}
+type Args = {}
 
 type Options = {}
 
 export class ProjectValidateCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly schemaLoader: SchemaLoader,
+		private readonly migrationValidator: MigrationsValidator,
+		private readonly migrationsResolver: MigrationsResolver,
+		private readonly schemaDiffer: SchemaDiffer,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Validates project schema')
-		if (!this.workspace.isSingleProjectMode()) {
-			configuration.argument('project')
-		}
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<number> {
-		const [projectName] = [input.getArgument('project')]
-		const workspace = this.workspace
+	protected async execute(): Promise<number> {
+		let projectValid = true
 
-		const allProjects = projectName === '.'
-		const projects = allProjects
-			? await workspace.projects.listProjects()
-			: [await workspace.projects.getProject(projectName, { fuzzy: true })]
-		let valid = true
-		const invalidProjects = []
-		for (const project of projects) {
-			console.group(`Project ${project.name}:`)
-			const migrationsDir = await project.migrationsDir
-			const container = new MigrationsContainerFactory(migrationsDir).create()
-			const migrations = await container.migrationsResolver.getSchemaMigrations()
-			let projectValid = await validateMigrations(
-				emptySchema,
-				migrations,
-				container.migrationDescriber,
-				container.schemaMigrator,
-			)
-			const schema = await loadSchema(project)
-			projectValid = validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:') && projectValid
+		const migrations = await this.migrationsResolver.getSchemaMigrations()
+		projectValid = this.migrationValidator.validate(emptySchema, migrations)
+			&& projectValid
 
-			const builtSchema = await container.schemaVersionBuilder.buildSchema()
-			projectValid =
-				validateSchemaAndPrintErrors(builtSchema, 'Schema built from migrations is invalid:') && projectValid
+		const schema = await this.schemaLoader.loadSchema()
+		projectValid = validateSchemaAndPrintErrors(schema, 'Defined schema is invalid:')
+			&& projectValid
 
-			if (projectValid) {
-				const diff = await container.schemaDiffer.diffSchemas(builtSchema, schema)
-				if (diff.length > 0) {
-					console.log('Migrations are not in sync with a defined schema')
-					projectValid = false
-				}
-			}
+		const builtSchema = await this.schemaVersionBuilder.buildSchema()
+		projectValid = validateSchemaAndPrintErrors(builtSchema, 'Schema built from migrations is invalid:')
+			&& projectValid
 
-			if (projectValid) {
-				console.log('Project schema is valid')
-			} else {
-				invalidProjects.push(project.name)
+		if (projectValid) {
+			const diff = await this.schemaDiffer.diffSchemas(builtSchema, schema)
+			if (diff.length > 0) {
+				console.log('Migrations are not in sync with a defined schema')
+				projectValid = false
 			}
-			console.groupEnd()
-			valid = valid && projectValid
 		}
-		if (invalidProjects.length) {
-			console.log('Following projects failed the validation:')
-			invalidProjects.forEach(it => console.log(it))
+
+		if (projectValid) {
+			console.log('Project schema is valid')
 		}
-		return valid ? 0 : 1
+
+		return projectValid ? 0 : 1
 	}
 }

package/src/commands/project/index.ts

@@ -1,3 +1,3 @@
-export * from './ProjectGenerateDocumentation'
+export * from './ProjectGenerateDocumentationCommand'
 export * from './ProjectPrintSchemaCommand'
 export * from './ProjectValidateCommand'

package/src/commands/transfer/ExportCommand.ts

@@ -1,10 +1,11 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
 import { createWriteStream } from 'node:fs'
-import { dataExport, resolveProject } from './utils'
-import { maskToken } from '../../utils/token'
+import { maskToken } from '../../lib/maskToken'
 import { pipeline } from 'node:stream/promises'
-import { printProgressLine } from '../../utils/stdio'
+import { printProgressLine } from '../../lib/transfer/stdio'
 import { createGunzip, createGzip } from 'node:zlib'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
+import { DataTransferClient } from '../../lib/transfer/DataTransferClient'
 
 type Args = {
 	source?: string
@@ -20,17 +21,15 @@ type Options = {
 
 export class ExportCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly remoteProjectResolver: RemoteProjectResolver,
+		private readonly dataTransferClient: DataTransferClient,
 	) {
 		super()
 	}
 
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Export data from a project')
-		const from = configuration.argument('source')
-		if (this.workspace.isSingleProjectMode()) {
-			from.optional()
-		}
+		configuration.argument('source').optional()
 		configuration.option('include-system').valueNone()
 		configuration.option('no-gzip').valueNone().deprecated()
 		configuration.option('no-gzip-transfer').valueNone()
@@ -40,13 +39,16 @@ export class ExportCommand extends Command<Args, Options> {
 
 	protected async execute(input: Input<Args, Options>): Promise<void | number> {
 		const from = input.getArgument('source')
-		const project = await resolveProject({ workspace: this.workspace, projectOrDsn: from })
+		const project = await this.remoteProjectResolver.resolve(from)
+		if (!project) {
+			throw `Project not defined`
+		}
 
 		console.log('')
 		console.log('Exporting data from a following project')
 		console.log('')
-		console.log(`Project name: ${project.project}`)
-		console.log(`API URL: ${project.baseUrl}`)
+		console.log(`Project name: ${project.name}`)
+		console.log(`API URL: ${project.endpoint}`)
 		console.log(`Token: ${maskToken(project.token)}`)
 
 		const gzipOutput = !input.getOption('no-gzip-output') && !input.getOption('no-gzip')
@@ -54,7 +56,7 @@ export class ExportCommand extends Command<Args, Options> {
 
 		const includeSystem = input.getOption('include-system') === true
 
-		const response = await dataExport({
+		const response = await this.dataTransferClient.dataExport({
 			project,
 			includeSystem,
 			gzip: gzipTransfer,
@@ -74,7 +76,7 @@ export class ExportCommand extends Command<Args, Options> {
 			}
 		})
 
-		const fileName = input.getOption('output') ?? `${project.project}.jsonl${gzipOutput ? '.gz' : ''}`
+		const fileName = input.getOption('output') ?? `${project.name}.jsonl${gzipOutput ? '.gz' : ''}`
 		const fileStream = createWriteStream(fileName)
 
 		const responseStream = gzipOutput === gzipTransfer

package/src/commands/transfer/ImportCommand.ts

@@ -1,10 +1,12 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
 import { createReadStream } from 'node:fs'
 import { createGunzip } from 'node:zlib'
-import { confirmImport, dataImport, resolveProject } from './utils'
-import { maskToken } from '../../utils/token'
-import { printProgressLine } from '../../utils/stdio'
-import { readStream } from '../../utils/stream'
+import { confirmImport } from './utils'
+import { maskToken } from '../../lib/maskToken'
+import { printProgressLine } from '../../lib/transfer/stdio'
+import { readStream } from '../../lib/stream'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
+import { DataTransferClient } from '../../lib/transfer/DataTransferClient'
 
 type Args = {
 	file: string
@@ -17,7 +19,8 @@ type Options = {
 
 export class ImportCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly remoteProjectResolver: RemoteProjectResolver,
+		private readonly dataTransferClient: DataTransferClient,
 	) {
 		super()
 	}
@@ -25,22 +28,22 @@ export class ImportCommand extends Command<Args, Options> {
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Import data into a project')
 		configuration.argument('file')
-		const from = configuration.argument('target')
-		if (this.workspace.isSingleProjectMode()) {
-			from.optional()
-		}
+		configuration.argument('target').optional()
 		configuration.option('no-gzip-transfer').valueNone()
 		configuration.option('yes').valueNone()
 	}
 
 	protected async execute(input: Input<Args, Options>): Promise<void | number> {
-		const from = input.getArgument('target')
-		const project = await resolveProject({ projectOrDsn: from, workspace: this.workspace })
+		const target = input.getArgument('target')
+		const project = await this.remoteProjectResolver.resolve(target)
+		if (!project) {
+			throw `Target project not defined`
+		}
 		console.log('')
 		console.log('Importing data into a following project')
 		console.log('')
-		console.log(`Project name: ${project.project}`)
-		console.log(`API URL: ${project.baseUrl}`)
+		console.log(`Project name: ${project.name}`)
+		console.log(`API URL: ${project.endpoint}`)
 		console.log(`Token: ${maskToken(project.token)}`)
 		console.log('')
 		if (!await confirmImport(input)) {
@@ -50,7 +53,7 @@ export class ImportCommand extends Command<Args, Options> {
 		const baseInputStream = createReadStream(file)
 		const stream = (file.endsWith('.gz') ? baseInputStream.pipe(createGunzip()) : baseInputStream)
 		const gzipTransfer = !input.getOption('no-gzip-transfer')
-		const response = await dataImport({
+		const response = await this.dataTransferClient.dataImport({
 			stream: stream,
 			project,
 			printProgress: printProgressLine,

package/src/commands/transfer/TransferCommand.ts

@@ -1,9 +1,11 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { confirmImport, dataExport, dataImport, resolveProject } from './utils'
-import { maskToken } from '../../utils/token'
-import { printProgressLine } from '../../utils/stdio'
-import { readStream } from '../../utils/stream'
+import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { confirmImport } from './utils'
+import { maskToken } from '../../lib/maskToken'
+import { printProgressLine } from '../../lib/transfer/stdio'
+import { readStream } from '../../lib/stream'
 import { createGunzip } from 'node:zlib'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
+import { DataTransferClient } from '../../lib/transfer/DataTransferClient'
 
 type Args = {
 	source: string
@@ -17,7 +19,8 @@ type Options = {
 
 export class TransferCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly remoteProjectResolver: RemoteProjectResolver,
+		private readonly dataTransferClient: DataTransferClient,
 	) {
 		super()
 	}
@@ -25,10 +28,7 @@ export class TransferCommand extends Command<Args, Options> {
 	protected configure(configuration: CommandConfiguration<Args, Options>): void {
 		configuration.description('Transfer data between projects')
 		configuration.argument('source')
-		const target = configuration.argument('target')
-		if (this.workspace.isSingleProjectMode()) {
-			target.optional()
-		}
+		configuration.argument('target').optional()
 		configuration.option('include-system').valueNone()
 		configuration.option('no-gzip-transfer').valueNone()
 		configuration.option('yes').valueNone()
@@ -36,20 +36,27 @@ export class TransferCommand extends Command<Args, Options> {
 
 	protected async execute(input: Input<Args, Options>): Promise<void | number> {
 		const source = input.getArgument('source')
-		const sourceProject = await resolveProject({ projectOrDsn: source, workspace: this.workspace })
+		const sourceProject = await this.remoteProjectResolver.resolve(source)
+		if (!sourceProject) {
+			throw `Source project not defined`
+		}
 
 		const target = input.getArgument('target')
-		const targetProject = await resolveProject({ projectOrDsn: target, workspace: this.workspace })
+		const targetProject = await this.remoteProjectResolver.resolve(target)
+		if (!targetProject) {
+			throw `Target project not defined`
+		}
+
 
 		console.log('')
 		console.log('Transferring data between projects:')
 		console.log('')
-		console.log(`Source project name: ${sourceProject.project}`)
-		console.log(`Source API URL: ${sourceProject.baseUrl}`)
+		console.log(`Source project name: ${sourceProject.name}`)
+		console.log(`Source API URL: ${sourceProject.endpoint}`)
 		console.log(`Source token: ${maskToken(sourceProject.token)}`)
 		console.log('')
-		console.log(`Target project name: ${targetProject.project}`)
-		console.log(`Target API URL: ${targetProject.baseUrl}`)
+		console.log(`Target project name: ${targetProject.name}`)
+		console.log(`Target API URL: ${targetProject.endpoint}`)
 		console.log(`Target token: ${maskToken(targetProject.token)}`)
 		console.log('')
 		if (!await confirmImport(input)) {
@@ -58,9 +65,13 @@ export class TransferCommand extends Command<Args, Options> {
 
 		const includeSystem = input.getOption('include-system') === true
 		const gzipTransfer = !input.getOption('no-gzip-transfer')
-		const exportResponse = (await dataExport({ project: sourceProject, includeSystem, gzip: gzipTransfer }))
+		const exportResponse = (await this.dataTransferClient.dataExport({
+			project: sourceProject,
+			includeSystem,
+			gzip: gzipTransfer,
+		}))
 		const ungzipedResponse = gzipTransfer ? exportResponse.pipe(createGunzip()) : exportResponse
-		const importResponse = await dataImport({
+		const importResponse = await this.dataTransferClient.dataImport({
 			stream: ungzipedResponse,
 			project: targetProject,
 			printProgress: printProgressLine,

package/src/commands/transfer/utils.ts

@@ -1,122 +1,6 @@
-import { Readable, Stream } from 'node:stream'
-import { LineTransform, readStream } from '../../utils/stream'
-import https from 'node:https'
-import http from 'node:http'
-import { Input, Workspace } from '@contember/cli-common'
-import { parseDsn } from '../../utils/dsn'
-import { interactiveResolveInstanceEnvironmentFromInput } from '../../utils/instance'
-import { interactiveResolveApiToken } from '../../utils/tenant'
+import { Input } from '@contember/cli-common'
 import prompts from 'prompts'
-import { createGzip } from 'node:zlib'
 
-export type ProjectEndpoint = {
-	token: string
-	project: string
-	baseUrl: string
-}
-
-export const resolveProject = async ({ projectOrDsn, workspace }: { projectOrDsn?: string; workspace: Workspace }): Promise<ProjectEndpoint> => {
-	let endpoint: string | undefined = undefined
-	let token: string | undefined = undefined
-	let project: string | undefined
-	if (projectOrDsn?.includes('://')) {
-		({ endpoint, project, token } = parseDsn(projectOrDsn))
-	} else if (projectOrDsn !== undefined && projectOrDsn !== '.') {
-		project = projectOrDsn
-	}
-	const instance = await interactiveResolveInstanceEnvironmentFromInput(workspace, endpoint)
-	token ??= await interactiveResolveApiToken({ workspace, instance })
-	project ??= (await workspace.projects.getSingleProject()).name
-	return { project, token, baseUrl: instance.baseUrl }
-
-}
-
-export const dataImport = async ({ printProgress, stream, project: { project, token, baseUrl }, gzip }: { stream: Readable; project: ProjectEndpoint; printProgress: (message: string) => void; gzip: boolean }) => {
-	let table = ''
-	let rowCount = 0
-	let rowTotal = 0
-	let transferred = 0
-	let start = Date.now()
-	const inputStream = stream.pipe(new LineTransform(line => {
-		transferred += line.length + 1
-		if (line === '') {
-			return ''
-		}
-		const data = JSON.parse(line)
-		switch (data[0]) {
-			case 'importSystemSchemaBegin':
-				return JSON.stringify([data[0], { ...data[1], project }])
-			case 'importContentSchemaBegin':
-				return JSON.stringify([data[0], { ...data[1], project }])
-			case 'insertBegin':
-				table = data[1].table
-				rowCount = 0
-				break
-			case 'insertRow':
-				rowCount++
-				rowTotal++
-				break
-			case 'insertEnd':
-				break
-		}
-		if ((rowCount % 1000) === 0 || data[0] !== 'insertRow') {
-			const mbs = Math.floor(transferred / 1024 / 1024).toString()
-			const durationS = Math.floor((Date.now() - start) / 1000)
-			printProgress(`transferred ${mbs} MiB; inserted ${rowCount} ${table} rows, ${rowTotal} total; ${durationS} seconds`)
-		}
-		return line
-	}))
-
-	return await executeRequest({
-		url: `${baseUrl}/import`,
-		token,
-		headers: {
-			'Content-type': 'application/x-ndjson',
-			...(gzip ? { 'Content-Encoding': 'gzip' } : {}),
-		},
-		body: gzip ? inputStream.pipe(createGzip()) : inputStream,
-	})
-}
-
-export const dataExport = async ({ project: { project, token, baseUrl }, gzip, includeSystem }: { project: ProjectEndpoint; includeSystem: boolean; gzip: boolean }) => {
-	return await executeRequest({
-		url: `${baseUrl}/export`,
-		token,
-		headers: {
-			'Accept-Encoding': gzip ? 'gzip' : 'identity',
-			'Content-type': 'application/json',
-		},
-		body: JSON.stringify({
-			projects: [{ slug: project, system: includeSystem }],
-		}),
-	})
-}
-
-const executeRequest = async ({ url, token, headers, body }: { url: string; token: string; headers: Record<string, string >; body: any }) => {
-	return await new Promise<http.IncomingMessage>((resolve, reject) => {
-		const req = (url.startsWith('https://') ? https : http).request(url, {
-			method: 'POST',
-			headers: {
-				Authorization: `Bearer ${token}`,
-				...headers,
-			},
-		}, async res => {
-			if (res.statusCode !== 200) {
-				const responseBody = (await readStream(res)).toString()
-				reject(new Error(`Invalid response: ${res.statusMessage}\n${responseBody}`))
-			} else {
-				resolve(res)
-			}
-		})
-
-		if (body instanceof Stream) {
-			body.pipe(req)
-		} else {
-			req.write(body)
-			req.end()
-		}
-	})
-}
 
 export const confirmImport = async (input: Input<{}, { yes: boolean }>): Promise<boolean> => {
 	if (input.getOption('yes')) {

package/src/commands/workspace/WorkspaceUpdateApiCommand.ts

@@ -1,6 +1,6 @@
-import { Command, CommandConfiguration, Input, Workspace } from '@contember/cli-common'
-import { updateWorkspaceApiVersion } from '../../utils/workspace'
-import { contemberDockerImages, updateMainDockerComposeConfig } from '../../utils/dockerCompose'
+import { Command, CommandConfiguration, Input, PackageWorkspaceResolver } from '@contember/cli-common'
+import { DockerComposeManager } from '../../lib/fs/DockerComposeManager'
+import { contemberDockerImages } from '../../consts'
 
 type Args = {
 	version: string
@@ -10,7 +10,8 @@ type Options = {}
 
 export class WorkspaceUpdateApiCommand extends Command<Args, Options> {
 	constructor(
-		private readonly workspace: Workspace,
+		private readonly packageWorkspaceResolver: PackageWorkspaceResolver,
+		private readonly dockerComposeManager: DockerComposeManager,
 	) {
 		super()
 	}
@@ -22,8 +23,7 @@ export class WorkspaceUpdateApiCommand extends Command<Args, Options> {
 
 	protected async execute(input: Input<Args, Options>): Promise<void> {
 		const version = input.getArgument('version')
-		const workspace = this.workspace
-		const packageWorkspace = await workspace.resolvePackageWorkspace()
+		const packageWorkspace = await this.packageWorkspaceResolver.resolve()
 
 		await packageWorkspace.updateEverywhere({
 			'@contember/schema': version,
@@ -31,24 +31,16 @@ export class WorkspaceUpdateApiCommand extends Command<Args, Options> {
 			'@contember/cli': version,
 		})
 
-		const updatedYaml = await updateWorkspaceApiVersion(workspace, version)
-
-		if (updatedYaml) {
-			console.log(`${updatedYaml} updated`)
-		} else {
-			console.log('contember.yaml not found, skipping')
-		}
-
 		console.log('Updating docker-compose')
 		const getNewImage = (currentImage: string): string | null => {
 			for (const candidate of contemberDockerImages) {
 				if (currentImage.startsWith(`${candidate}:`)) {
-					return `${candidate}:${version}`
+					return `${candidate.replace(/-ee$/, '')}:${version}`
 				}
 			}
 			return null
 		}
-		await updateMainDockerComposeConfig(workspace.directory, data => ({
+		await this.dockerComposeManager.updateMainDockerComposeConfig(data => ({
 			...data,
 			services: Object.fromEntries(Object.entries(data?.services ?? {}).map(([name, service]: [string, any]) => {
 				const newImage = getNewImage(service.image)

package/src/consts.ts

@@ -0,0 +1,5 @@
+import { join } from 'node:path'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+export const packageRoot = process.env.CONTEMBER_CLI_PACKAGE_ROOT || join(dirname(fileURLToPath(import.meta.url)), '../')
+export const contemberDockerImages = ['contember/engine', 'contember/engine-ee', 'contember/cli']