@contember/cli 2.2.0-alpha.2 → 2.2.0-alpha.4

package/src/lib/SystemClientProvider.ts

@@ -1,14 +1,88 @@
 import { RemoteProjectProvider } from './project/RemoteProjectProvider.js'
 import { SystemClient } from '@contember/migrations-client'
+import { GraphQlClient, GraphQlClientError } from '@contember/graphql-client'
+import { toTransportError, TransportErrorContext } from './errors/TransportError.js'
+
+type SystemClientFactory = (baseUrl: string, projectName: string, apiToken: string) => SystemClient
 
 export class SystemClientProvider {
 	constructor(
 		private readonly remoteProjectProvider: RemoteProjectProvider,
+		private readonly systemClientFactory: SystemClientFactory = SystemClient.create,
 	) {
 	}
 
 	public get(): SystemClient {
 		const project = this.remoteProjectProvider.get()
-		return SystemClient.create(project.endpoint, project.name, project.token)
+		return new TransportSystemClient(
+			this.systemClientFactory(project.endpoint, project.name, project.token),
+			createSystemApiUrl(project.endpoint, project.name),
+		)
+	}
+}
+
+class TransportSystemClient extends SystemClient {
+	private readonly context: TransportErrorContext
+
+	constructor(
+		private readonly inner: SystemClient,
+		apiUrl: string,
+	) {
+		super(new GraphQlClient({ url: apiUrl }))
+		this.context = {
+			service: 'System API',
+			codePrefix: 'SYSTEM_API',
+			url: apiUrl,
+		}
+	}
+
+	public override migrate(...args: Parameters<SystemClient['migrate']>): ReturnType<SystemClient['migrate']> {
+		return this.execute(() => this.inner.migrate(...args))
 	}
+
+	public override migrateFromSnapshot(
+		...args: Parameters<SystemClient['migrateFromSnapshot']>
+	): ReturnType<SystemClient['migrateFromSnapshot']> {
+		return this.execute(() => this.inner.migrateFromSnapshot(...args))
+	}
+
+	public override migrationDelete(
+		...args: Parameters<SystemClient['migrationDelete']>
+	): ReturnType<SystemClient['migrationDelete']> {
+		return this.execute(() => this.inner.migrationDelete(...args))
+	}
+
+	public override migrationModify(
+		...args: Parameters<SystemClient['migrationModify']>
+	): ReturnType<SystemClient['migrationModify']> {
+		return this.execute(() => this.inner.migrationModify(...args))
+	}
+
+	public override listExecutedMigrations(
+		...args: Parameters<SystemClient['listExecutedMigrations']>
+	): ReturnType<SystemClient['listExecutedMigrations']> {
+		return this.execute(() => this.inner.listExecutedMigrations(...args))
+	}
+
+	public override getExecutedMigration(
+		...args: Parameters<SystemClient['getExecutedMigration']>
+	): ReturnType<SystemClient['getExecutedMigration']> {
+		return this.execute(() => this.inner.getExecutedMigration(...args))
+	}
+
+	private async execute<T>(request: () => Promise<T>): Promise<T> {
+		try {
+			return await request()
+		} catch (error) {
+			if (error instanceof GraphQlClientError) {
+				throw toTransportError(error, this.context)
+			}
+			throw error
+		}
+	}
+}
+
+const createSystemApiUrl = (baseUrl: string, projectName: string): string => {
+	const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
+	return `${normalizedBaseUrl}/system/${projectName}`
 }

package/src/lib/TenantClientProvider.ts

@@ -1,14 +1,52 @@
-import { TenantClient } from './tenant/TenantClient.js'
-import { RemoteProjectProvider } from './project/RemoteProjectProvider.js'
+import { TenantApiTransport } from './tenant/TenantApiTransport.js'
+import {
+	createTenantClients,
+	TenantApiKeyClient,
+	TenantClients,
+	TenantMemberClient,
+	TenantPersonClient,
+	TenantPolicyClient,
+	TenantProjectClient,
+} from './tenant/clients/index.js'
+import type { TenantConnectionSource } from './tenant/TenantConnection.js'
 
 export class TenantClientProvider {
 	constructor(
-		private readonly remoteProjectProvider: RemoteProjectProvider,
+		private readonly connectionSource: TenantConnectionSource,
 	) {
 	}
 
-	public get(): TenantClient {
-		const project = this.remoteProjectProvider.get()
-		return TenantClient.create(project.endpoint, project.token)
+	/** Kept as the historical accessor — `tenant apply` and the migration facade only ever needed the project domain. */
+	public get(): TenantProjectClient {
+		return this.project()
+	}
+
+	public project(): TenantProjectClient {
+		return this.clients().project
+	}
+
+	public person(): TenantPersonClient {
+		return this.clients().person
+	}
+
+	public member(): TenantMemberClient {
+		return this.clients().member
+	}
+
+	public apiKey(): TenantApiKeyClient {
+		return this.clients().apiKey
+	}
+
+	public policy(): TenantPolicyClient {
+		return this.clients().policy
+	}
+
+	public clients(): TenantClients {
+		return createTenantClients(this.transport())
+	}
+
+	public transport(): TenantApiTransport {
+		const connection = this.connectionSource.get()
+		return TenantApiTransport.create(connection.endpoint, connection.token)
 	}
 }

package/src/lib/actions/ActionsClient.ts

@@ -1,4 +1,6 @@
-import { GraphQlClient } from '@contember/graphql-client'
+import type { JsonValue } from '@contember/cli-common'
+import { GraphQlClient, GraphQlClientVariables } from '@contember/graphql-client'
+import { toTransportError } from '../errors/TransportError.js'
 
 const createActionsApiUrl = (url: string, project: string) => {
 	if (url.endsWith('/')) {
@@ -16,26 +18,27 @@ export class ActionsClient {
 		return new ActionsClient(graphqlClient)
 	}
 
-	public async listVariables(): Promise<{ name: string; value: string }[]> {
+	public async listVariables(): Promise<Variable[]> {
 		const query = `query {
   variables {
   	name
   	value
+  	source
   }
 }`
-		const result = await this.apiClient.execute<{
-			variables: Array<{ name: string; value: string }>
+		const result = await this.execute<{
+			variables: Array<Variable>
 		}>(query)
 		return result.variables
 	}
 
-	public async setVariables(variables: { name: string; value: string }[], mode: 'MERGE' | 'SET' | 'APPEND_ONLY_MISSING'): Promise<boolean> {
+	public async setVariables(variables: { name: string; value: string }[], mode: SetVariablesMode): Promise<boolean> {
 		const query = `mutation($variables: [VariableInput!]!, $mode: SetVariablesMode) {
   setVariables(args: { variables: $variables, mode: $mode }) {
 	ok
   }
   }`
-		const result = await this.apiClient.execute<{ setVariables: { ok: boolean } }>(query, { variables: { mode, variables } })
+		const result = await this.execute<{ setVariables: { ok: boolean } }>(query, { mode, variables })
 		return result.setVariables.ok
 	}
 
@@ -53,9 +56,9 @@ export class ActionsClient {
   	log
   }
 }`
-		const result = await this.apiClient.execute<{
+		const result = await this.execute<{
 			failedEvents: Event[]
-		}>(query, { variables: { offset, limit } })
+		}>(query, { offset, limit })
 		return result.failedEvents
 	}
 
@@ -65,7 +68,7 @@ export class ActionsClient {
   	ok
   }
 }`
-		const result = await this.apiClient.execute<{ retryEvent: { ok: boolean } }>(query, { variables: { id } })
+		const result = await this.execute<{ retryEvent: { ok: boolean } }>(query, { id })
 		return result.retryEvent.ok
 	}
 
@@ -75,7 +78,7 @@ export class ActionsClient {
   	ok
   }
 }`
-		const result = await this.apiClient.execute<{ stopEvent: { ok: boolean } }>(query, { variables: { id } })
+		const result = await this.execute<{ stopEvent: { ok: boolean } }>(query, { id })
 		return result.stopEvent.ok
 	}
 
@@ -93,19 +96,40 @@ export class ActionsClient {
   	log
   }
 }`
-		const result = await this.apiClient.execute<{ event: Event | null }>(query, { variables: { id } })
+		const result = await this.execute<{ event: Event | null }>(query, { id })
 		return result.event
 	}
+
+	private async execute<T>(query: string, variables?: GraphQlClientVariables): Promise<T> {
+		try {
+			return await this.apiClient.execute<T>(query, variables === undefined ? {} : { variables })
+		} catch (error) {
+			throw toTransportError(error, {
+				service: 'Actions API',
+				codePrefix: 'ACTIONS_API',
+			})
+		}
+	}
 }
 
+/** The subset of ActionsClient commands depend on — structural, so tests can pass a plain fake without a cast. */
+export type ActionsApi = Pick<ActionsClient, 'listVariables' | 'setVariables' | 'listFailedEvents' | 'retryEvent' | 'stopEvent' | 'getEvent'>
+
+export type VariableSource = 'DATABASE' | 'ENVIRONMENT'
+
+/** An `ENVIRONMENT` value is not returned by the API — it stays in the operator's secret store. */
+export type Variable = { name: string; value: string | null; source: VariableSource }
+
+export type SetVariablesMode = 'MERGE' | 'SET' | 'APPEND_ONLY_MISSING'
+
 export type Event = {
 	id: string
 	createdAt: string
 	lastStateChange: string
 	visibleAt: string | null
 	numRetries: number
-	state: 'retrying' | 'failed'
+	state: 'created' | 'retrying' | 'processing' | 'succeed' | 'failed' | 'stopped'
 	target: string
-	payload: any
-	log: any
+	payload: JsonValue
+	log: JsonValue
 }

package/src/lib/actions/resolveActionsClient.ts

@@ -0,0 +1,15 @@
+import { CliError } from '@contember/cli-common'
+import { RemoteProjectResolver } from '../project/RemoteProjectResolver.js'
+import { ActionsApi, ActionsClient } from './ActionsClient.js'
+
+/** Injected by commands as a constructor default, so tests can substitute a fake {@link ActionsApi} without touching the network. */
+export type ActionsClientResolver = (remoteProjectResolver: RemoteProjectResolver, dsn: string | undefined) => Promise<ActionsApi>
+
+/** Resolves the target project and builds an {@link ActionsClient}; throws a typed error when the project is not configured. */
+export const resolveActionsClient: ActionsClientResolver = async (remoteProjectResolver, dsn) => {
+	const project = await remoteProjectResolver.resolve(dsn)
+	if (!project) {
+		throw new CliError('Project not defined', { code: 'PROJECT_NOT_DEFINED' })
+	}
+	return ActionsClient.create(project.endpoint, project.name, project.token)
+}

package/src/lib/actions/runActionMutationBatch.ts

@@ -0,0 +1,69 @@
+import { CliError, ExitCode } from '@contember/cli-common'
+
+export interface ActionMutationError {
+	readonly code: string
+	readonly retryable: boolean
+	readonly exitCode: ExitCode
+}
+
+export type ActionMutationResult =
+	| { readonly id: string; readonly ok: true }
+	| { readonly id: string; readonly ok: false; readonly error: ActionMutationError }
+
+export interface ActionMutationBatch {
+	readonly results: readonly ActionMutationResult[]
+	readonly exitCode: ExitCode
+}
+
+/** Runs every requested mutation and keeps transport failures attributable to their input id. */
+export const runActionMutationBatch = async (
+	ids: readonly string[],
+	operation: (id: string) => Promise<boolean>,
+	domainFailure: ActionMutationError,
+): Promise<ActionMutationBatch> => {
+	const results: ActionMutationResult[] = []
+	for (const id of ids) {
+		try {
+			results.push(
+				await operation(id)
+					? { id, ok: true }
+					: { id, ok: false, error: domainFailure },
+			)
+		} catch (error) {
+			results.push({ id, ok: false, error: safeMutationError(error) })
+		}
+	}
+	return { results, exitCode: aggregateExitCode(results) }
+}
+
+/** Batch precedence: internal, forbidden, transient, conflict, not-found, then invalid input. */
+const exitCodePrecedence: readonly ExitCode[] = [
+	ExitCode.InternalError,
+	ExitCode.Forbidden,
+	ExitCode.Transient,
+	ExitCode.Conflict,
+	ExitCode.NotFound,
+	ExitCode.InputError,
+]
+
+const aggregateExitCode = (results: readonly ActionMutationResult[]): ExitCode =>
+	exitCodePrecedence.find(exitCode => results.some(result => !result.ok && result.error.exitCode === exitCode)) ?? ExitCode.Success
+
+/** Rejects empty ids locally, before a command invokes the Actions API. */
+export const validateActionEventIds = (ids: readonly string[]): void => {
+	const position = ids.findIndex(id => id.trim().length === 0)
+	if (position === -1) {
+		return
+	}
+	throw new CliError(`Invalid event id at position ${position + 1}: empty value`, {
+		code: 'INVALID_EVENT_ID',
+		details: { argument: 'eventIds', position: position + 1, reason: 'empty' },
+	})
+}
+
+const safeMutationError = (error: unknown): ActionMutationError => {
+	if (error instanceof CliError) {
+		return { code: error.code, retryable: error.retryable, exitCode: error.exitCode }
+	}
+	return { code: 'ACTIONS_OPERATION_FAILED', retryable: false, exitCode: ExitCode.InternalError }
+}

package/src/lib/admin/AdminClient.ts

@@ -1,7 +1,13 @@
-import { maskToken } from '../maskToken.js'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { toHttpTransportError, toTransportError } from '../errors/TransportError.js'
 import { RemoteProjectProvider } from '../project/RemoteProjectProvider.js'
 
 export type AdminFiles = Array<{ path: string; data: string }>
+interface AdminDeployRequest {
+	readonly project: string | null
+	readonly files: AdminFiles
+}
+
 export class AdminClient {
 	constructor(
 		private readonly remoteProjectProvider: RemoteProjectProvider,
@@ -12,22 +18,43 @@ export class AdminClient {
 		const response = await this.execute('_deploy', 'POST', { project, files })
 
 		if (!response.ok) {
-			const project = this.remoteProjectProvider.get()
-			const maskedToken = maskToken(project.token)
-			throw `Failed to deploy admin, POST request to ${project.adminEndpoint}/_deploy with token ${maskedToken} returned status ${response.status} ${response.statusText}\n${await response
-				.text()}`
+			try {
+				await response.body?.cancel()
+			} catch {
+				// The HTTP classification is the primary error.
+			}
+			throw toHttpTransportError(
+				{ status: response.status, retryAfter: response.headers.get('retry-after') },
+				this.context('_deploy'),
+			)
 		}
 	}
 
-	private async execute(path: string, method: string, body: any): Promise<Response> {
+	private async execute(path: string, method: string, body: AdminDeployRequest): Promise<Response> {
 		const project = this.remoteProjectProvider.get()
 		if (!project.adminEndpoint) {
-			throw new Error('Admin endpoint not set')
+			throw new CliError('Admin endpoint not set', {
+				code: 'ADMIN_ENDPOINT_NOT_SET',
+				exitCode: ExitCode.InputError,
+			})
+		}
+		try {
+			return await fetch(`${project.adminEndpoint}/${path}`, {
+				method,
+				headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${project.token}` },
+				body: JSON.stringify(body),
+			})
+		} catch (error) {
+			throw toTransportError(error, this.context(path))
+		}
+	}
+
+	private context(path: string) {
+		const endpoint = this.remoteProjectProvider.get().adminEndpoint
+		return {
+			service: 'Admin API',
+			codePrefix: 'ADMIN_API',
+			...(endpoint === undefined ? {} : { url: `${endpoint}/${path}` }),
 		}
-		return await fetch(`${project.adminEndpoint}/${path}`, {
-			method: method,
-			headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${project.token}` },
-			body: JSON.stringify(body),
-		})
 	}
 }

package/src/lib/admin/AdminDeployer.ts

@@ -1,12 +1,14 @@
 import { AdminClient, AdminFiles } from './AdminClient.js'
 import { FileSystem } from '../fs/FileSystem.js'
 import { RemoteProjectProvider } from '../project/RemoteProjectProvider.js'
+import { Output } from '@contember/cli-common'
 
 export class AdminDeployer {
 	constructor(
 		private readonly remoteProjectProvider: RemoteProjectProvider,
 		private readonly adminClient: AdminClient,
 		private readonly fs: FileSystem,
+		private readonly output: Output = new Output(),
 	) {
 	}
 
@@ -14,7 +16,7 @@ export class AdminDeployer {
 		dir: string
 		root: boolean
 	}) => {
-		console.log('Deploying admin...')
+		this.output.info('Deploying admin...')
 		const files = await this.readAdminFiles(dir)
 		const project = root ? null : this.remoteProjectProvider.get().name
 
@@ -22,7 +24,7 @@ export class AdminDeployer {
 		// with root option you can build app on your own and simply deploy it with subprojects
 		await this.adminClient.deploy(project, files)
 
-		console.log(`Admin deployed (${files.length} files)`)
+		this.output.info(`Admin deployed (${files.length} files)`)
 	}
 
 	private readAdminFiles = async (dir: string, prefix: string = ''): Promise<AdminFiles> => {