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

package/src/lib/TenantClientProvider.ts

@@ -1,14 +1,52 @@
-import { TenantClient } from './tenant/TenantClient'
-import { RemoteProjectProvider } from './project/RemoteProjectProvider'
+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/VersionChecker.ts

@@ -1,8 +1,8 @@
 import { join, relative } from 'node:path'
 import * as semver from 'semver'
 import { PackageWorkspaceResolver } from '@contember/cli-common'
-import { DockerComposeManager } from './fs/DockerComposeManager'
-import { contemberDockerImages } from '../consts'
+import { DockerComposeManager } from './fs/DockerComposeManager.js'
+import { contemberDockerImages } from '../consts.js'
 
 export class VersionChecker {
 	constructor(

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'
-import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+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'
-import { FileSystem } from '../fs/FileSystem'
-import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+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> => {

package/src/lib/errors/TransportError.ts

@@ -0,0 +1,260 @@
+import { CliError, ExitCode } from '@contember/cli-common'
+import { GraphQlClientError, GraphQlErrorType } from '@contember/graphql-client'
+
+export interface TransportErrorContext {
+	/** Human-readable service name used in error messages. */
+	readonly service: string
+	/** Stable machine-readable prefix, for example `TENANT_API`. */
+	readonly codePrefix: string
+	/** Endpoint only. Credentials, query parameters, and fragments are removed. */
+	readonly url?: string
+}
+
+export type HttpErrorKind = 'forbidden' | 'not-found' | 'conflict' | 'transient' | 'input' | 'internal'
+
+export interface HttpStatusClassification {
+	readonly kind: HttpErrorKind
+	readonly codeSuffix: string
+	readonly exitCode: ExitCode
+}
+
+export interface HttpErrorResponse {
+	readonly status: number
+	readonly retryAfter?: string | null
+}
+
+/** Classifies HTTP failures independently of any particular API client. */
+export const classifyHttpStatus = (status: number): HttpStatusClassification => {
+	if (status === 401) {
+		return { kind: 'forbidden', codeSuffix: 'UNAUTHORIZED', exitCode: ExitCode.Forbidden }
+	}
+	if (status === 403) {
+		return { kind: 'forbidden', codeSuffix: 'FORBIDDEN', exitCode: ExitCode.Forbidden }
+	}
+	if (status === 404) {
+		return { kind: 'not-found', codeSuffix: 'NOT_FOUND', exitCode: ExitCode.NotFound }
+	}
+	if (status === 408) {
+		return { kind: 'transient', codeSuffix: 'TIMEOUT', exitCode: ExitCode.Transient }
+	}
+	if (status === 409) {
+		return { kind: 'conflict', codeSuffix: 'CONFLICT', exitCode: ExitCode.Conflict }
+	}
+	if (status === 425) {
+		return { kind: 'transient', codeSuffix: 'TOO_EARLY', exitCode: ExitCode.Transient }
+	}
+	if (status === 429) {
+		return { kind: 'transient', codeSuffix: 'RATE_LIMITED', exitCode: ExitCode.Transient }
+	}
+	if (status >= 500 && status <= 599) {
+		return { kind: 'transient', codeSuffix: 'SERVER_ERROR', exitCode: ExitCode.Transient }
+	}
+	if (status >= 400 && status <= 499) {
+		return { kind: 'input', codeSuffix: 'BAD_REQUEST', exitCode: ExitCode.InputError }
+	}
+	return { kind: 'internal', codeSuffix: 'HTTP_ERROR', exitCode: ExitCode.InternalError }
+}
+
+/** Creates a safe CLI error for a received HTTP failure without copying its body. */
+export const toHttpTransportError = (
+	response: HttpErrorResponse,
+	context: TransportErrorContext,
+	cause?: unknown,
+): CliError => {
+	const classification = classifyHttpStatus(response.status)
+	return new CliError(`${context.service} request failed with HTTP ${response.status}`, {
+		code: `${context.codePrefix}_${classification.codeSuffix}`,
+		exitCode: classification.exitCode,
+		details: createDetails(context, {
+			status: response.status,
+			retryAfter: sanitizeRetryAfter(response.retryAfter),
+		}),
+		cause: sanitizeCause(cause, context),
+	})
+}
+
+/**
+ * Normalizes an error thrown by a transport call. Call this only at a transport boundary: a plain
+ * thrown error is treated as a rejected network operation and is therefore retryable.
+ */
+export const toTransportError = (error: unknown, context: TransportErrorContext): CliError => {
+	if (error instanceof CliError) {
+		return error
+	}
+	if (error instanceof GraphQlClientError) {
+		return graphQlTransportError(error, context)
+	}
+	return new CliError(`${context.service} request failed: network error`, {
+		code: `${context.codePrefix}_UNREACHABLE`,
+		exitCode: ExitCode.Transient,
+		details: createDetails(context, { status: null }),
+		cause: sanitizeCause(error, context),
+	})
+}
+
+interface TransportErrorDetails {
+	readonly type?: GraphQlErrorType
+	readonly url?: string
+	readonly status: number | null
+	readonly retryAfter?: string
+}
+
+const graphQlTransportError = (error: GraphQlClientError, context: TransportErrorContext): CliError => {
+	const graphQlCodes = extractGraphQlCodes(error)
+	const semantic = classifyGraphQlCodes(graphQlCodes)
+	if (semantic !== null) {
+		return createGraphQlError(error, context, semantic)
+	}
+
+	if (error.type === 'aborted') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'transient', codeSuffix: 'ABORTED', exitCode: ExitCode.Transient },
+		)
+	}
+	if (error.type === 'network error') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'transient', codeSuffix: 'UNREACHABLE', exitCode: ExitCode.Transient },
+		)
+	}
+	if (error.type === 'invalid response body') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'internal', codeSuffix: 'INVALID_RESPONSE', exitCode: ExitCode.InternalError },
+		)
+	}
+	if (error.response !== undefined && error.response.status >= 400) {
+		return createGraphQlError(error, context, classifyHttpStatus(error.response.status))
+	}
+	if (error.type === 'server error') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'transient', codeSuffix: 'SERVER_ERROR', exitCode: ExitCode.Transient },
+		)
+	}
+	if (error.type === 'unauthorized') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'forbidden', codeSuffix: 'UNAUTHORIZED', exitCode: ExitCode.Forbidden },
+		)
+	}
+	if (error.type === 'forbidden') {
+		return createGraphQlError(
+			error,
+			context,
+			{ kind: 'forbidden', codeSuffix: 'FORBIDDEN', exitCode: ExitCode.Forbidden },
+		)
+	}
+	return createGraphQlError(
+		error,
+		context,
+		{ kind: 'input', codeSuffix: error.type === 'bad request' ? 'BAD_REQUEST' : 'ERROR', exitCode: ExitCode.InputError },
+	)
+}
+
+const createGraphQlError = (
+	error: GraphQlClientError,
+	context: TransportErrorContext,
+	classification: HttpStatusClassification,
+): CliError =>
+	new CliError(`${context.service} request failed: ${describeFailure(classification.kind)}`, {
+		code: `${context.codePrefix}_${classification.codeSuffix}`,
+		exitCode: classification.exitCode,
+		details: createDetails(
+			{ ...context, url: error.request.url },
+			{
+				type: error.type,
+				status: error.response?.status ?? null,
+				retryAfter: sanitizeRetryAfter(error.response?.headers.get('retry-after')),
+			},
+		),
+		cause: sanitizeCause(error, context),
+	})
+
+const describeFailure = (kind: HttpErrorKind): string => {
+	switch (kind) {
+		case 'forbidden':
+			return 'authentication or permission denied'
+		case 'not-found':
+			return 'resource not found'
+		case 'conflict':
+			return 'conflict'
+		case 'transient':
+			return 'temporary failure'
+		case 'input':
+			return 'request rejected'
+		case 'internal':
+			return 'invalid response'
+	}
+}
+
+const authGraphQlCodes = new Set(['ForbiddenError', 'FORBIDDEN', 'UNAUTHENTICATED', 'UNAUTHORIZED'])
+const serverGraphQlCodes = new Set(['INTERNAL_SERVER_ERROR', 'InternalServerError'])
+
+const classifyGraphQlCodes = (codes: readonly string[]): HttpStatusClassification | null => {
+	if (codes.some(code => authGraphQlCodes.has(code))) {
+		return { kind: 'forbidden', codeSuffix: 'FORBIDDEN', exitCode: ExitCode.Forbidden }
+	}
+	if (codes.some(code => serverGraphQlCodes.has(code))) {
+		return { kind: 'transient', codeSuffix: 'SERVER_ERROR', exitCode: ExitCode.Transient }
+	}
+	return null
+}
+
+const extractGraphQlCodes = (error: GraphQlClientError): readonly string[] => {
+	const values: readonly unknown[] = error.errors ?? []
+	return values.flatMap(value => {
+		if (typeof value !== 'object' || value === null || !('extensions' in value)) {
+			return []
+		}
+		const extensions = value.extensions
+		if (typeof extensions !== 'object' || extensions === null || !('code' in extensions) || typeof extensions.code !== 'string') {
+			return []
+		}
+		return [extensions.code]
+	})
+}
+
+const createDetails = (
+	context: TransportErrorContext,
+	values: Omit<TransportErrorDetails, 'url'>,
+): TransportErrorDetails => {
+	const safeUrl = context.url === undefined ? undefined : sanitizeUrl(context.url)
+	return {
+		status: values.status,
+		...(values.type === undefined ? {} : { type: values.type }),
+		...(safeUrl === undefined ? {} : { url: safeUrl }),
+		...(values.retryAfter === undefined ? {} : { retryAfter: values.retryAfter }),
+	}
+}
+
+const sanitizeUrl = (value: string): string | undefined => {
+	try {
+		const url = new URL(value)
+		return `${url.protocol}//${url.host}${url.pathname}`
+	} catch {
+		return undefined
+	}
+}
+
+const sanitizeCause = (cause: unknown, context: TransportErrorContext): Error | undefined =>
+	cause === undefined ? undefined : new Error(`${context.service} transport failure`)
+
+const sanitizeRetryAfter = (value: string | null | undefined): string | undefined => {
+	if (value === undefined || value === null) {
+		return undefined
+	}
+	if (/^\d{1,10}$/.test(value)) {
+		return value
+	}
+	if (/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/.test(value)) {
+		return value
+	}
+	return undefined
+}

package/src/lib/errors/index.ts

@@ -0,0 +1 @@
+export * from './TransportError.js'

package/src/lib/fs/DockerComposeManager.ts

@@ -1,7 +1,7 @@
 import { dirname, join } from 'node:path'
 import jsyaml from 'js-yaml'
-import { FileSystem } from './FileSystem'
-import { JsonUpdateCallback, YamlHandler } from './YamlHandler'
+import { FileSystem } from './FileSystem.js'
+import { JsonUpdateCallback, YamlHandler } from './YamlHandler.js'
 
 export interface DockerComposeServiceConfig {
 	image?: string

package/src/lib/fs/YamlHandler.ts

@@ -1,8 +1,8 @@
 import { readFile, writeFile } from 'node:fs/promises'
 import jsyaml from 'js-yaml'
-import { FileSystem } from './FileSystem'
+import { FileSystem } from './FileSystem.js'
 import YAWN from 'yawn-yaml'
-import { JSONObject, JSONPrimitive } from '../json'
+import { JSONObject, JSONPrimitive } from '../json.js'
 import { Merger } from '@contember/config-loader'
 
 export type JsonUpdateCallback<Value = JSONObject> = (

package/src/lib/js/EsBuildBuilder.ts

@@ -1,4 +1,4 @@
-import { JsBuilder } from './JsBuilder'
+import { JsBuilder } from './JsBuilder.js'
 
 export class EsBuildBuilder implements JsBuilder {
 	async build(path: string): Promise<string> {

package/src/lib/js/EvalExecutor.ts

@@ -1,4 +1,4 @@
-import { JsExecutor } from './JsExecutor'
+import { JsExecutor } from './JsExecutor.js'
 
 export class EvalExecutor implements JsExecutor {
 	public async execute(code: string): Promise<unknown> {