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

package/src/commands/tenant/project/jsonConfigOption.ts

@@ -0,0 +1,33 @@
+import { CliError, ExitCode } from '@contember/cli-common'
+import { readStdinText, type StdinReader } from '../../../lib/tenant/stdin.js'
+
+/**
+ * Resolves a `--config` / `--config-stdin` option pair into a parsed JSON value. A bare `-` cannot be used
+ * as a stdin sentinel here — the parser treats any value starting with `-` as the start of the next flag
+ * (`InputParser.tryParseValue`) — so stdin gets its own boolean flag instead. `undefined` in (neither flag
+ * given), `undefined` out — lets callers tell "not provided" apart from "explicitly cleared".
+ */
+export const resolveJsonConfigOption = async (
+	value: string | undefined,
+	fromStdin: boolean,
+	readStdinFn: StdinReader = readStdinText,
+): Promise<unknown> => {
+	if (value !== undefined && fromStdin) {
+		throw new CliError('Pass either --config or --config-stdin, not both.', {
+			code: 'CONFIG_CONFLICTING_SOURCE',
+			exitCode: ExitCode.InputError,
+		})
+	}
+	if (value === undefined && !fromStdin) {
+		return undefined
+	}
+	const raw = value !== undefined ? value : await readStdinFn()
+	try {
+		return JSON.parse(raw)
+	} catch (e) {
+		throw new CliError(`Invalid JSON in --config: ${e instanceof Error ? e.message : String(e)}`, {
+			code: 'INVALID_CONFIG_JSON',
+			exitCode: ExitCode.InputError,
+		})
+	}
+}

package/src/commands/tenant/tenantOutput.ts

@@ -0,0 +1,35 @@
+import { CliError, escapeTerminalText, ExitCode } from '@contember/cli-common'
+
+/** Escapes an untrusted fragment before it is interpolated into human-readable stdout. */
+export const humanText = (value: string): string => escapeTerminalText(value)
+
+export const requireNonEmptyTenantName = (value: string | undefined, subject: 'Person' | 'Project'): string | undefined => {
+	if (value !== undefined && value.trim() === '') {
+		throw new CliError(`${subject} name must not be empty.`, {
+			code: 'EMPTY_NAME',
+			exitCode: ExitCode.InputError,
+		})
+	}
+	return value
+}
+
+export const assertTenantCredentialContract = (valid: boolean, kind: 'API key' | 'deployer' | 'session'): void => {
+	if (!valid) {
+		invalidTenantCredential(kind)
+	}
+}
+
+/** Generated tenant credentials are 20 random bytes encoded as lowercase hexadecimal. */
+export const assertGeneratedTenantToken = (token: string, kind: 'API key' | 'deployer' | 'session'): string => {
+	if (!/^[0-9a-f]{40}$/.test(token)) {
+		invalidTenantCredential(kind)
+	}
+	return token
+}
+
+const invalidTenantCredential = (kind: 'API key' | 'deployer' | 'session'): never => {
+	throw new CliError(`The tenant API returned an invalid ${kind} token.`, {
+		code: 'TENANT_API_INVALID_CREDENTIAL',
+		exitCode: ExitCode.InternalError,
+	})
+}

package/src/commands/transfer/ExportCommand.ts

@@ -1,12 +1,12 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, escapeTerminalText, ExitCode, Input, Output } from '@contember/cli-common'
 import { createWriteStream } from 'node:fs'
-import { maskToken } from '../../lib/maskToken'
+import { maskToken } from '../../lib/maskToken.js'
 import { pipeline } from 'node:stream/promises'
-import { printProgressLine } from '../../lib/transfer/stdio'
-import { createGunzip, createGzip } from 'node:zlib'
-import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver'
-import { DataTransferClient } from '../../lib/transfer/DataTransferClient'
-import { Readable } from 'node:stream'
+import { createProgressReporter } from '../../lib/transfer/stdio.js'
+import { createGzip } from 'node:zlib'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver.js'
+import { DataTransferClient, toDataExportStream, toDataTransferStreamError } from '../../lib/transfer/DataTransferClient.js'
+import { PassThrough } from 'node:stream'
 
 type Args = {
 	source?: string
@@ -21,6 +21,13 @@ type Options = {
 	'exclude-table'?: string[]
 }
 
+export interface ExportResult {
+	readonly project: string
+	readonly endpoint: string
+	readonly file: string
+	readonly exported: true
+}
+
 export class ExportCommand extends Command<Args, Options> {
 	constructor(
 		private readonly remoteProjectResolver: RemoteProjectResolver,
@@ -40,19 +47,19 @@ export class ExportCommand extends Command<Args, Options> {
 		configuration.option('exclude-table').valueArray()
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void | number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void | number> {
 		const from = input.getArgument('source')
 		const project = await this.remoteProjectResolver.resolve(from)
 		if (!project) {
-			throw `Project not defined`
+			throw new CliError('Project not defined', { code: 'PROJECT_NOT_DEFINED', exitCode: ExitCode.NotFound })
 		}
 
-		console.log('')
-		console.log('Exporting data from a following project')
-		console.log('')
-		console.log(`Project name: ${project.name}`)
-		console.log(`API URL: ${project.endpoint}`)
-		console.log(`Token: ${maskToken(project.token)}`)
+		output.info('')
+		output.info('Exporting data from a following project')
+		output.info('')
+		output.info(`Project name: ${project.name}`)
+		output.info(`API URL: ${project.endpoint}`)
+		output.info(`Token: ${maskToken(project.token)}`)
 
 		const gzipOutput = !input.getOption('no-gzip-output') && !input.getOption('no-gzip')
 		const gzipTransfer = !input.getOption('no-gzip-transfer')
@@ -65,21 +72,19 @@ export class ExportCommand extends Command<Args, Options> {
 			includeSystem,
 			gzip: gzipTransfer,
 		})
-		if (!response.body) {
-			throw new Error('Response does not contain a readable stream.')
-		}
-
 		let transferred = 0
 		let start = Date.now()
 		let lastMbReported = 0
-		console.log('')
-		const stream = Readable.fromWeb(response.body as any)
-		stream.on('data', chunk => {
-			transferred += chunk.length
+		output.info('')
+		const printProgress = createProgressReporter(output)
+		const stream = toDataExportStream(response)
+		const progressStream = new PassThrough()
+		progressStream.on('data', chunk => {
+			transferred += chunk instanceof Uint8Array ? chunk.byteLength : 0
 			const currentMb = Math.floor(transferred / 1024 / 1024)
 			if (currentMb > lastMbReported) {
 				const durationS = Math.floor((Date.now() - start) / 1000)
-				printProgressLine(`transferred ${currentMb} MiB; ${durationS} seconds`)
+				printProgress(`transferred ${currentMb} MiB; ${durationS} seconds`)
 				lastMbReported = currentMb
 			}
 		})
@@ -87,13 +92,25 @@ export class ExportCommand extends Command<Args, Options> {
 		const fileName = input.getOption('output') ?? `${project.name}.jsonl${gzipOutput ? '.gz' : ''}`
 		const fileStream = createWriteStream(fileName)
 
-		const responseStream = !gzipOutput
-			? stream
-			: stream.pipe(createGzip())
-
-		await pipeline(responseStream, fileStream)
+		try {
+			if (gzipOutput) {
+				await pipeline(stream, progressStream, createGzip(), fileStream)
+			} else {
+				await pipeline(stream, progressStream, fileStream)
+			}
+		} catch (cause) {
+			throw toDataTransferStreamError('Export', cause)
+		}
 
-		console.log('\nExport done.')
-		console.log(`Data saved to ${fileName}`)
+		const result: ExportResult = {
+			project: project.name,
+			endpoint: project.endpoint,
+			file: fileName,
+			exported: true,
+		}
+		output.data(result, {
+			human: it => ['', 'Export done.', `Data saved to ${escapeTerminalText(it.file)}`].join('\n'),
+			quiet: it => it.file,
+		})
 	}
 }

package/src/commands/transfer/ImportCommand.ts

@@ -1,12 +1,19 @@
-import { Command, CommandConfiguration, Input } from '@contember/cli-common'
+import { CliError, Command, CommandConfiguration, escapeTerminalText, ExitCode, Input, Output } from '@contember/cli-common'
 import { createReadStream } from 'node:fs'
 import { createGunzip } from 'node:zlib'
-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'
+import { PassThrough, Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { confirmImport } from './utils.js'
+import { maskToken } from '../../lib/maskToken.js'
+import { createProgressReporter } from '../../lib/transfer/stdio.js'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver.js'
+import { DataTransferClient, toDataTransferStreamError } from '../../lib/transfer/DataTransferClient.js'
+
+export interface ImportResult {
+	readonly source: string
+	readonly target: { readonly project: string; readonly endpoint: string }
+	readonly imported: true
+}
 
 type Args = {
 	file: string
@@ -15,12 +22,16 @@ type Args = {
 type Options = {
 	'yes': boolean
 	'no-gzip-transfer'?: boolean
+	'dry-run'?: boolean
 }
 
+type InputStreamFactory = (path: string) => Readable
+
 export class ImportCommand extends Command<Args, Options> {
 	constructor(
 		private readonly remoteProjectResolver: RemoteProjectResolver,
 		private readonly dataTransferClient: DataTransferClient,
+		private readonly inputStreamFactory: InputStreamFactory = path => createReadStream(path),
 	) {
 		super()
 	}
@@ -31,46 +42,88 @@ export class ImportCommand extends Command<Args, Options> {
 		configuration.argument('target').optional()
 		configuration.option('no-gzip-transfer').valueNone()
 		configuration.option('yes').valueNone()
+		configuration.option('dry-run').valueNone().description('Print what would happen without importing any data.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void | number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void | number> {
 		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.name}`)
-		console.log(`API URL: ${project.endpoint}`)
-		console.log(`Token: ${maskToken(project.token)}`)
-		console.log('')
-		if (!await confirmImport(input)) {
-			return 1
+			throw new CliError('Target project not defined', { code: 'PROJECT_NOT_DEFINED', exitCode: ExitCode.NotFound })
 		}
 		const file = input.getArgument('file')
-		const baseInputStream = createReadStream(file)
-		const stream = file.endsWith('.gz') ? baseInputStream.pipe(createGunzip()) : baseInputStream
-		stream.on('error', (err: any) => {
-			console.error('Error in import stream:', err)
-		})
 
+		if (input.getOption('dry-run') === true) {
+			output.data(
+				{
+					dryRun: true,
+					source: file,
+					target: { project: project.name, endpoint: project.endpoint },
+					wipesTarget: true,
+				},
+				{
+					human: it =>
+						[
+							'Would import data into the following project',
+							'',
+							`Source file: ${escapeTerminalText(it.source)}`,
+							`Project name: ${escapeTerminalText(it.target.project)}`,
+							`API URL: ${escapeTerminalText(it.target.endpoint)}`,
+							`Token: ${escapeTerminalText(maskToken(project.token))}`,
+							'',
+							'This would completely wipe the target project.',
+							'No data was imported.',
+						].join('\n'),
+					quiet: it => it.target.project,
+				},
+			)
+			return ExitCode.Success
+		}
+
+		output.info('')
+		output.info('Importing data into a following project')
+		output.info('')
+		output.info(`Project name: ${project.name}`)
+		output.info(`API URL: ${project.endpoint}`)
+		output.info(`Token: ${maskToken(project.token)}`)
+		output.info('')
+		if (!await confirmImport(input, output)) {
+			return ExitCode.InputError
+		}
+		const baseInputStream = this.inputStreamFactory(file)
 		const gzipTransfer = !input.getOption('no-gzip-transfer')
-		const response = await this.dataTransferClient.dataImport({
-			stream: stream,
-			project,
-			printProgress: printProgressLine,
-			gzip: gzipTransfer,
-		})
-		console.log('')
-		const responseData = await response.json()
-		if (responseData.ok) {
-			console.log('Import done.')
+		const runImport = (stream: Readable): Promise<void> =>
+			this.dataTransferClient.dataImport({
+				stream,
+				project,
+				printProgress: createProgressReporter(output),
+				gzip: gzipTransfer,
+			})
+		if (file.endsWith('.gz')) {
+			const decompressedStream = new PassThrough()
+			const sourcePipeline = pipeline(baseInputStream, createGunzip(), decompressedStream).catch(cause => {
+				throw toDataTransferStreamError('Import', cause)
+			})
+			const importOperation = runImport(decompressedStream)
+			try {
+				await Promise.all([sourcePipeline, importOperation])
+			} catch (cause) {
+				baseInputStream.destroy()
+				decompressedStream.destroy()
+				await Promise.allSettled([sourcePipeline, importOperation])
+				throw cause instanceof CliError ? cause : toDataTransferStreamError('Import', cause)
+			}
 		} else {
-			console.error('Import failed:')
-			console.log(responseData)
-			return 1
+			await runImport(baseInputStream)
 		}
+		const result: ImportResult = {
+			source: file,
+			target: { project: project.name, endpoint: project.endpoint },
+			imported: true,
+		}
+		output.data(result, {
+			human: () => '\nImport done.',
+			quiet: it => it.target.project,
+		})
 	}
 }

package/src/commands/transfer/TransferCommand.ts

@@ -1,12 +1,9 @@
-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'
-import { Duplex, Readable } from 'node:stream'
+import { CliError, Command, CommandConfiguration, escapeTerminalText, ExitCode, Input, Output } from '@contember/cli-common'
+import { confirmImport } from './utils.js'
+import { maskToken } from '../../lib/maskToken.js'
+import { createProgressReporter } from '../../lib/transfer/stdio.js'
+import { RemoteProjectResolver } from '../../lib/project/RemoteProjectResolver.js'
+import { DataTransferClient, toDataExportStream } from '../../lib/transfer/DataTransferClient.js'
 
 type Args = {
 	source: string
@@ -17,8 +14,34 @@ type Options = {
 	'no-gzip-transfer'?: boolean
 	yes: boolean
 	'exclude-table'?: string[]
+	'dry-run'?: boolean
 }
 
+export interface TransferResult {
+	readonly source: { readonly project: string; readonly endpoint: string }
+	readonly target: { readonly project: string; readonly endpoint: string }
+	readonly transferred: true
+}
+
+const canonicalEndpoint = (endpoint: string): string => {
+	try {
+		const url = new URL(endpoint)
+		url.username = ''
+		url.password = ''
+		url.search = ''
+		url.hash = ''
+		url.pathname = url.pathname.replace(/\/+$/, '')
+		return url.toString().replace(/\/$/, '')
+	} catch {
+		return endpoint.replace(/\/+$/, '')
+	}
+}
+
+const isSameProject = (
+	source: { readonly name: string; readonly endpoint: string },
+	target: { readonly name: string; readonly endpoint: string },
+): boolean => source.name === target.name && canonicalEndpoint(source.endpoint) === canonicalEndpoint(target.endpoint)
+
 export class TransferCommand extends Command<Args, Options> {
 	constructor(
 		private readonly remoteProjectResolver: RemoteProjectResolver,
@@ -35,34 +58,72 @@ export class TransferCommand extends Command<Args, Options> {
 		configuration.option('no-gzip-transfer').valueNone()
 		configuration.option('yes').valueNone()
 		configuration.option('exclude-table').valueArray()
+		configuration.option('dry-run').valueNone().description('Print what would happen without transferring any data.')
 	}
 
-	protected async execute(input: Input<Args, Options>): Promise<void | number> {
+	protected async execute(input: Input<Args, Options>, output: Output): Promise<void | number> {
 		const source = input.getArgument('source')
 		const sourceProject = await this.remoteProjectResolver.resolve(source)
 		if (!sourceProject) {
-			throw `Source project not defined`
+			throw new CliError('Source project not defined', { code: 'PROJECT_NOT_DEFINED', exitCode: ExitCode.NotFound })
 		}
 
 		const target = input.getArgument('target')
 		const targetProject = await this.remoteProjectResolver.resolve(target)
 		if (!targetProject) {
-			throw `Target project not defined`
+			throw new CliError('Target project not defined', { code: 'PROJECT_NOT_DEFINED', exitCode: ExitCode.NotFound })
+		}
+		if (isSameProject(sourceProject, targetProject)) {
+			throw new CliError('Source and target resolve to the same project', {
+				code: 'TRANSFER_SOURCE_EQUALS_TARGET',
+				exitCode: ExitCode.InputError,
+				details: { project: sourceProject.name },
+			})
+		}
+
+		if (input.getOption('dry-run') === true) {
+			output.data(
+				{
+					dryRun: true,
+					source: { project: sourceProject.name, endpoint: sourceProject.endpoint },
+					target: { project: targetProject.name, endpoint: targetProject.endpoint },
+					wipesTarget: true,
+				},
+				{
+					human: it =>
+						[
+							'Would transfer data between projects',
+							'',
+							`Source project name: ${escapeTerminalText(it.source.project)}`,
+							`Source API URL: ${escapeTerminalText(it.source.endpoint)}`,
+							`Source token: ${escapeTerminalText(maskToken(sourceProject.token))}`,
+							'',
+							`Target project name: ${escapeTerminalText(it.target.project)}`,
+							`Target API URL: ${escapeTerminalText(it.target.endpoint)}`,
+							`Target token: ${escapeTerminalText(maskToken(targetProject.token))}`,
+							'',
+							'This would completely wipe the target project.',
+							'No data was transferred.',
+						].join('\n'),
+					quiet: it => it.target.project,
+				},
+			)
+			return ExitCode.Success
 		}
 
-		console.log('')
-		console.log('Transferring data between projects:')
-		console.log('')
-		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.name}`)
-		console.log(`Target API URL: ${targetProject.endpoint}`)
-		console.log(`Target token: ${maskToken(targetProject.token)}`)
-		console.log('')
-		if (!await confirmImport(input)) {
-			return 1
+		output.info('')
+		output.info('Transferring data between projects:')
+		output.info('')
+		output.info(`Source project name: ${sourceProject.name}`)
+		output.info(`Source API URL: ${sourceProject.endpoint}`)
+		output.info(`Source token: ${maskToken(sourceProject.token)}`)
+		output.info('')
+		output.info(`Target project name: ${targetProject.name}`)
+		output.info(`Target API URL: ${targetProject.endpoint}`)
+		output.info(`Target token: ${maskToken(targetProject.token)}`)
+		output.info('')
+		if (!await confirmImport(input, output)) {
+			return ExitCode.InputError
 		}
 
 		const includeSystem = input.getOption('include-system') === true
@@ -73,21 +134,20 @@ export class TransferCommand extends Command<Args, Options> {
 			excludeTables: input.getOption('exclude-table') ?? [],
 			gzip: gzipTransfer,
 		})
-		const stream = Readable.fromWeb(exportResponse.body! as any)
-		const importResponse = await this.dataTransferClient.dataImport({
-			stream: stream,
+		await this.dataTransferClient.dataImport({
+			stream: toDataExportStream(exportResponse),
 			project: targetProject,
-			printProgress: printProgressLine,
+			printProgress: createProgressReporter(output),
 			gzip: gzipTransfer,
 		})
-		console.log('')
-
-		const responseData = await importResponse.json()
-		if (responseData.ok) {
-			console.log('Transfer done.')
-		} else {
-			console.error('Transfer failed:')
-			console.log(responseData)
+		const result: TransferResult = {
+			source: { project: sourceProject.name, endpoint: sourceProject.endpoint },
+			target: { project: targetProject.name, endpoint: targetProject.endpoint },
+			transferred: true,
 		}
+		output.data(result, {
+			human: () => '\nTransfer done.',
+			quiet: it => it.target.project,
+		})
 	}
 }

package/src/commands/transfer/index.ts

@@ -1,3 +1,3 @@
-export * from './ExportCommand'
-export * from './ImportCommand'
-export * from './TransferCommand'
+export * from './ExportCommand.js'
+export * from './ImportCommand.js'
+export * from './TransferCommand.js'

package/src/commands/transfer/utils.ts

@@ -1,19 +1,20 @@
-import { Input } from '@contember/cli-common'
-import prompts from 'prompts'
+import { CliError, ExitCode, Input, Output } from '@contember/cli-common'
+import { promptConfirm } from '../../lib/prompt/index.js'
 
-export const confirmImport = async (input: Input<{}, { yes: boolean }>): Promise<boolean> => {
+export const confirmImport = async (input: Input<{}, { yes: boolean }>, output: Output): Promise<boolean> => {
 	if (input.getOption('yes')) {
 		return true
 	}
-	if (!process.stdin.isTTY) {
-		throw 'TTY not available. Pass --yes option to confirm execution.'
+	if (!output.canPrompt()) {
+		throw new CliError('TTY not available. Pass --yes to confirm execution.', {
+			code: 'TTY_UNAVAILABLE',
+			exitCode: ExitCode.InputError,
+		})
 	}
-	console.log('This will completely wipe the target project.')
-	console.log('(to skip this dialog, you can pass --yes option)')
-	console.log('')
-	const { ok } = await prompts({
-		type: 'confirm',
-		name: 'ok',
+	output.warn('This will completely wipe the target project.')
+	output.info('(to skip this dialog, you can pass --yes option)')
+	output.info('')
+	const ok = await promptConfirm(output, {
 		message: `Do you want to continue?`,
 	})
 	return ok