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

package/src/dic.ts

@@ -0,0 +1,258 @@
+import { Builder } from '@contember/dic'
+import {
+	JsLoader,
+	JsonLoader,
+	MigrationCreator,
+	MigrationDescriber,
+	MigrationExecutor,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	MigrationsStatusResolver,
+	ModificationHandlerFactory,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaVersionBuilder,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { JsCodeRunner } from './lib/js/JsCodeRunner'
+import { EsBuildBuilder } from './lib/js/EsBuildBuilder'
+import { EvalExecutor } from './lib/js/EvalExecutor'
+import { AdminDeployer } from './lib/admin/AdminDeployer'
+import { RemoteProjectResolver } from './lib/project/RemoteProjectResolver'
+import { CliEnv } from './lib/env'
+import { AdminClient } from './lib/admin/AdminClient'
+import { FileSystem } from './lib/fs/FileSystem'
+import { WorkspaceResolver } from './lib/workspace/WorkspaceResolver'
+import { YamlHandler } from './lib/fs/YamlHandler'
+import {
+	DeployCommand,
+	MigrationAmendCommand,
+	MigrationBlankCommand,
+	MigrationDescribeCommand,
+	MigrationDiffCommand,
+	MigrationExecuteCommand,
+	MigrationRebaseCommand,
+	MigrationStatusCommand,
+	ProjectGenerateDocumentationCommand,
+	ProjectPrintSchemaCommand,
+	ProjectValidateCommand,
+	VersionCommand,
+	WorkspaceUpdateApiCommand,
+} from './commands'
+import { MigrationExecutionFacade } from './lib/migrations/MigrationExecutionFacade'
+import { MigrationPrinter } from './lib/migrations/MigrationPrinter'
+import { MigrationsStatusFacade } from './lib/migrations/MigrationsStatusFacade'
+import { ImportSchemaLoader, SchemaLoader, TranspilingSchemaLoader } from './lib/schema/SchemaLoader'
+import { MigrationsValidator } from './lib/migrations/MigrationsValidator'
+import { MigrationRebaseFacade } from './lib/migrations/MigrationRebaseFacade'
+import { DataTransferClient } from './lib/transfer/DataTransferClient'
+import { ExportCommand, ImportCommand, TransferCommand } from './commands/transfer'
+import {
+	Application,
+	CommandFactoryList,
+	CommandManager,
+	CommandRunner,
+	Npm,
+	PackageWorkspaceResolver,
+	Pnpm,
+	Yarn,
+	YarnClassic,
+} from '@contember/cli-common'
+import { VersionChecker } from './lib/VersionChecker'
+import { DockerComposeManager } from './lib/fs/DockerComposeManager'
+import { RemoteProjectProvider } from './lib/project/RemoteProjectProvider'
+import { SystemClientProvider } from './lib/SystemClientProvider'
+import { TenantClientProvider } from './lib/TenantClientProvider'
+import { Workspace } from './lib/workspace/Workspace'
+
+const jsSample = `
+export const query = \`\`
+export const variables = {}
+
+// or multiple queries
+// export const queries = []
+
+// or a factory
+// export default async () => ({ queries: [] })
+`
+
+export const createContainer = ({ env, version, runtime, workspace }: {
+	workspace: Workspace
+	env: CliEnv
+	version: string
+	runtime: 'node' | 'bun'
+}) => {
+	return new Builder({})
+		.addService('env', () =>
+			env)
+		.addService('version', () =>
+			version)
+		.addService('runtime', () =>
+			runtime)
+		.addService('workspace', () =>
+			workspace)
+		.addService('fs', () =>
+			new FileSystem())
+		.addService('yamlHandler', ({ fs }) =>
+			new YamlHandler(fs))
+		.addService('jsExecutor', () =>
+			new EvalExecutor())
+		.addService('jsBuilder', () =>
+			new EsBuildBuilder())
+		.addService('jsCodeRunner', ({ jsExecutor, jsBuilder }) =>
+			new JsCodeRunner(jsBuilder, jsExecutor))
+
+		.addService('workspaceResolver', ({ yamlHandler }) =>
+			new WorkspaceResolver(yamlHandler))
+
+		.addService('remoteProjectResolver', ({ env }) =>
+			new RemoteProjectResolver(env))
+		.addService('remoteProjectProvider', ({ remoteProjectResolver }) => {
+			const provider = new RemoteProjectProvider()
+			const remoteProject = remoteProjectResolver.resolve()
+			if (remoteProject) {
+				provider.setRemoteProject(remoteProject)
+			}
+			return provider
+		})
+		.addService('systemClientProvider', ({ remoteProjectProvider }) =>
+			new SystemClientProvider(remoteProjectProvider))
+		.addService('tenantClientProvider', ({ remoteProjectProvider }) =>
+			new TenantClientProvider(remoteProjectProvider))
+		.addService('adminClient', ({ remoteProjectProvider }) =>
+			new AdminClient(remoteProjectProvider))
+		.addService('migrationFilesManager', ({ jsCodeRunner, workspace }) => {
+			const runJs = runtime === 'bun' ? (file: string) => import(file) : jsCodeRunner.run
+			return new MigrationFilesManager(workspace.migrationsDir, {
+				json: new JsonLoader(new MigrationParser()),
+				ts: new JsLoader(new MigrationParser(), runJs),
+				js: new JsLoader(new MigrationParser(), runJs),
+			})
+		})
+		.addService('packageWorkspaceResolver', ({ workspace, fs }) => {
+			const commandRunner = new CommandRunner()
+			return new PackageWorkspaceResolver(workspace.baseDir, fs, [
+				new Yarn(fs, commandRunner),
+				new YarnClassic(fs, commandRunner),
+				new Pnpm(fs, commandRunner),
+				new Npm(fs, commandRunner),
+			])
+		})
+		.addService('dockerComposeManager', ({ workspace, env, fs, yamlHandler }) =>
+			new DockerComposeManager(workspace.baseDir, env.dockerComposeFile, fs, yamlHandler))
+		.addService('modificationHandlerFactory', () =>
+			new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
+		.addService('schemaMigrator', ({ modificationHandlerFactory }) =>
+			new SchemaMigrator(modificationHandlerFactory))
+		.addService('migrationsResolver', ({ migrationFilesManager }) =>
+			new MigrationsResolver(migrationFilesManager))
+		.addService('schemaVersionBuilder', ({ migrationsResolver, schemaMigrator }) =>
+			new SchemaVersionBuilder(migrationsResolver, schemaMigrator))
+		.addService('schemaDiffer', ({ schemaMigrator }) =>
+			new SchemaDiffer(schemaMigrator))
+		.addService('migrationCreator', ({ migrationFilesManager, schemaDiffer }) =>
+			new MigrationCreator(migrationFilesManager, schemaDiffer, {
+				json: JSON.stringify({ formatVersion: VERSION_LATEST, modifications: [] }, undefined, '\t') + '\n',
+				ts: jsSample,
+				js: jsSample,
+			}))
+		.addService('migrationDescriber', ({ modificationHandlerFactory }) =>
+			new MigrationDescriber(modificationHandlerFactory))
+		.addService('migrationPrinter', ({ migrationDescriber }) =>
+			new MigrationPrinter(migrationDescriber))
+		.addService('migrationsExecutor', () =>
+			new MigrationExecutor())
+		.addService('migrationsStatusResolver', () =>
+			new MigrationsStatusResolver())
+		.addService('migrationsStatusFacade', ({ systemClientProvider, migrationsResolver, migrationsStatusResolver }) =>
+			new MigrationsStatusFacade(systemClientProvider, migrationsResolver, migrationsStatusResolver))
+		.addService('migrationExecutionFacade', ({ systemClientProvider, tenantClientProvider, remoteProjectProvider, schemaVersionBuilder, migrationPrinter, migrationsExecutor, migrationsStatusFacade }) =>
+			new MigrationExecutionFacade(systemClientProvider, tenantClientProvider, remoteProjectProvider, schemaVersionBuilder, migrationPrinter, migrationsExecutor, migrationsStatusFacade))
+		.addService('migrationsValidator', ({ migrationDescriber, schemaMigrator }) =>
+			new MigrationsValidator(migrationDescriber, schemaMigrator))
+		.addService('migrationRebaseFacade', ({ schemaVersionBuilder, migrationsValidator, systemClientProvider, migrationFilesManager }) =>
+			new MigrationRebaseFacade(schemaVersionBuilder, migrationsValidator, systemClientProvider, migrationFilesManager))
+		.addService('schemaLoader', ({ workspace, jsCodeRunner, runtime }) =>
+			runtime === 'bun' ? new ImportSchemaLoader(workspace) : new TranspilingSchemaLoader(workspace, jsCodeRunner))
+
+		.addService('adminDeployer', ({ remoteProjectProvider, adminClient, fs }) =>
+			new AdminDeployer(remoteProjectProvider, adminClient, fs))
+		.addService('dataTransferClient', () =>
+			new DataTransferClient())
+
+
+		.addService('deployCommand', ({ adminDeployer, migrationExecutionFacade, fs, remoteProjectProvider, remoteProjectResolver, workspace }) =>
+		 	new DeployCommand(adminDeployer, migrationExecutionFacade, fs, remoteProjectProvider, remoteProjectResolver, workspace))
+		.addService('migrationAmendCommand', ({ migrationsResolver, systemClientProvider, migrationsStatusFacade, schemaLoader, schemaVersionBuilder, migrationCreator, migrationsValidator, migrationPrinter, schemaMigrator }) =>
+			new MigrationAmendCommand(migrationsResolver, systemClientProvider, migrationsStatusFacade, schemaLoader, schemaVersionBuilder, migrationCreator, migrationsValidator, migrationPrinter, schemaMigrator))
+		.addService('migrationBlankCommand', ({ migrationCreator }) =>
+			new MigrationBlankCommand(migrationCreator))
+		.addService('migrationDescribeCommand', ({ migrationPrinter, schemaVersionBuilder, migrationsResolver }) =>
+			new MigrationDescribeCommand(migrationPrinter, schemaVersionBuilder, migrationsResolver))
+		.addService('migrationDiffCommand', ({ schemaLoader, schemaVersionBuilder, migrationCreator, migrationPrinter, migrationExecutionFacade }) =>
+			new MigrationDiffCommand(schemaLoader, schemaVersionBuilder, migrationCreator, migrationPrinter, migrationExecutionFacade))
+		.addService('migrationExecuteCommand', ({ migrationExecutionFacade }) =>
+			new MigrationExecuteCommand(migrationExecutionFacade))
+		.addService('migrationRebaseCommand', ({ migrationsResolver, migrationRebaseFacade }) =>
+			new MigrationRebaseCommand(migrationsResolver, migrationRebaseFacade))
+		.addService('migrationStatusCommand', ({ migrationsStatusFacade, migrationFilesManager, systemClientProvider, migrationPrinter }) =>
+			new MigrationStatusCommand(migrationsStatusFacade, migrationFilesManager, systemClientProvider, migrationPrinter))
+		.addService('versionCommand', ({ version }) =>
+			new VersionCommand(version))
+		.addService('projectGenerateDocumentationCommand', ({ schemaLoader }) =>
+			new ProjectGenerateDocumentationCommand(schemaLoader))
+		.addService('projectPrintSchemaCommand', ({ schemaLoader, schemaVersionBuilder }) =>
+			new ProjectPrintSchemaCommand(schemaLoader, schemaVersionBuilder))
+		.addService('projectValidateCommand', ({ schemaLoader, migrationsValidator, migrationsResolver, schemaDiffer, schemaVersionBuilder }) =>
+			new ProjectValidateCommand(schemaLoader, migrationsValidator, migrationsResolver, schemaDiffer, schemaVersionBuilder))
+		.addService('exportCommand', ({ dataTransferClient, remoteProjectResolver }) =>
+			new ExportCommand(remoteProjectResolver, dataTransferClient))
+		.addService('importCommand', ({ dataTransferClient, remoteProjectResolver }) =>
+			new ImportCommand(remoteProjectResolver, dataTransferClient))
+		.addService('transferCommand', ({ dataTransferClient, remoteProjectResolver }) =>
+			new TransferCommand(remoteProjectResolver, dataTransferClient))
+		.addService('workspaceUpdateCommand', ({ packageWorkspaceResolver, dockerComposeManager }) =>
+			new WorkspaceUpdateApiCommand(packageWorkspaceResolver, dockerComposeManager))
+		.addService('commandList', dic => {
+			const commands: CommandFactoryList = {
+				['deploy']: () => dic.deployCommand,
+				['version']: () => dic.versionCommand,
+				['data:export']: () => dic.exportCommand,
+				['data:import']: () => dic.importCommand,
+				['data:transfer']: () => dic.transferCommand,
+				['migrations:diff']: () => dic.migrationDiffCommand,
+				['migrations:amend']: () => dic.migrationAmendCommand,
+				['migrations:blank']: () => dic.migrationBlankCommand,
+				['migrations:describe']: () => dic.migrationDescribeCommand,
+				['migrations:execute']: () => dic.migrationExecuteCommand,
+				['migrations:rebase']: () => dic.migrationRebaseCommand,
+				['migrations:status']: () => dic.migrationStatusCommand,
+				['workspace:update:api']: () => dic.workspaceUpdateCommand,
+				['project:validate']: () => dic.projectValidateCommand,
+				['project:print-schema']: () => dic.projectPrintSchemaCommand,
+				['project:generate-doc']: () => dic.projectGenerateDocumentationCommand,
+			}
+			return commands
+		})
+		.addService('commandManager', ({ commandList }) =>
+			new CommandManager(commandList))
+
+		.addService('versionChecker', ({ version, workspace, packageWorkspaceResolver, dockerComposeManager }) =>
+			new VersionChecker(version, workspace.baseDir, packageWorkspaceResolver, dockerComposeManager))
+		.addService('application', ({ commandManager, versionChecker }) => {
+			const app = new Application(
+				commandManager,
+				`Contember CLI version ${version}`,
+				{
+					beforeRun: async ({ name }) => {
+						if (!process.env.CONTEMBER_SKIP_VERSION_CHECK && !['deploy', 'version', 'data:export', 'data:import', 'data:transfer'].includes(name)) {
+							await versionChecker.checkVersions()
+						}
+					},
+				},
+			)
+			return app
+		})
+		.build()
+}

package/src/lib/SystemClientProvider.ts

@@ -0,0 +1,14 @@
+import { RemoteProjectProvider } from './project/RemoteProjectProvider'
+import { SystemClient } from '@contember/migrations-client'
+
+export class SystemClientProvider {
+	constructor(
+		private readonly remoteProjectProvider: RemoteProjectProvider,
+	) {
+	}
+
+	public get(): SystemClient {
+		const project = this.remoteProjectProvider.get()
+		return SystemClient.create(project.endpoint, project.name, project.token)
+	}
+}

package/src/lib/TenantClientProvider.ts

@@ -0,0 +1,14 @@
+import { TenantClient } from './tenant/TenantClient'
+import { RemoteProjectProvider } from './project/RemoteProjectProvider'
+
+export class TenantClientProvider {
+	constructor(
+		private readonly remoteProjectProvider: RemoteProjectProvider,
+	) {
+	}
+
+	public get(): TenantClient {
+		const project = this.remoteProjectProvider.get()
+		return TenantClient.create(project.endpoint, project.token)
+	}
+}

package/src/lib/VersionChecker.ts

@@ -0,0 +1,71 @@
+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'
+
+export class VersionChecker {
+	constructor(
+		private readonly version: string,
+		private readonly dir: string,
+		private readonly packageWorkspaceResolver: PackageWorkspaceResolver,
+		private readonly dockerComposeManager: DockerComposeManager,
+	) {
+	}
+
+	checkVersions = async () => {
+		const cliVersion = this.version
+		const packageWorkspace = await this.packageWorkspaceResolver.resolve()
+
+		const errors: string[] = []
+
+		for (const packageName of ['@contember/schema', '@contember/schema-definition']) {
+			const installedPackages = await packageWorkspace.findInstalledDependencies(packageName)
+			for (const pckg of installedPackages) {
+				const jsonPath = relative(this.dir, join(pckg.defined.pckg.dir, 'package.json'))
+
+				if (!pckg.installed) {
+					errors.push(`Package ${packageName} defined in ${jsonPath} is not installed.`)
+					continue
+				}
+				if (pckg.defined.version !== 'workspace:*' && !semver.satisfies(pckg.installed.version, pckg.defined.version)) {
+					errors.push(`Package ${packageName}@${pckg.installed.version} does not match constraint ${pckg.defined.version} defined in ${jsonPath}.`)
+					continue
+				}
+				if (cliVersion !== pckg.installed.version) {
+					errors.push(`Package ${packageName}@${pckg.installed.version} does not match version of CLI ${cliVersion}.`)
+				}
+			}
+		}
+		const dockerCompose = await this.dockerComposeManager.tryReadMainDockerComposeConfig()
+
+		if (!dockerCompose) {
+			errors.push('docker-compose.yaml not found.')
+		} else {
+			for (const [name, def] of Object.entries(dockerCompose.services ?? {})) {
+				if (!def.image) {
+					continue
+				}
+				const [image, version] = def.image.split(':')
+				if (!version || !contemberDockerImages.includes(image)) {
+					continue
+				}
+				const versionParts = version.split(/[.-]/)
+				if (versionParts[versionParts.length - 1] === 'debian') {
+					versionParts.pop()
+				}
+				const cliVersionParts = cliVersion.split(/[.-]/).slice(0, versionParts.length)
+				if (versionParts.join('.') !== cliVersionParts.join('.')) {
+					errors.push(`Docker service ${name} with image ${image}:${version} does not match version of CLI ${cliVersion}.`)
+				}
+			}
+		}
+
+		if (errors.length) {
+			throw `${errors.map(it => `${it}`).join('\n')}
+
+Please make sure all dependencies are up to date.\nIf you are really certain about the compatibility, you can disable this version check by running the CLI with the CONTEMBER_SKIP_VERSION_CHECK=1 environment variable`
+		}
+	}
+
+}

package/src/lib/admin/AdminClient.ts

@@ -0,0 +1,33 @@
+import { maskToken } from '../maskToken'
+import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+
+export type AdminFiles = Array<{ path: string; data: string }>
+export class AdminClient {
+	constructor(
+		private readonly remoteProjectProvider: RemoteProjectProvider,
+	) {
+	}
+
+	public async deploy(project: string | null, files: AdminFiles): Promise<void> {
+		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.endpoint}/_deploy with token ${maskedToken} returned status ${response.status} ${response.statusText}\n${await response.text()}`
+		}
+	}
+
+	private async execute(path: string, method: string, body: any): Promise<Response> {
+		const project = this.remoteProjectProvider.get()
+		if (!project.adminEndpoint) {
+			throw new Error('Admin endpoint not set')
+		}
+		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

@@ -0,0 +1,45 @@
+import { AdminClient, AdminFiles } from './AdminClient'
+import { FileSystem } from '../fs/FileSystem'
+import { RemoteProjectProvider } from '../project/RemoteProjectProvider'
+
+export class AdminDeployer {
+	constructor(
+		private readonly remoteProjectProvider: RemoteProjectProvider,
+		private readonly adminClient: AdminClient,
+		private readonly fs: FileSystem,
+	) {
+	}
+
+	public deploy = async ({ dir, root }: {
+		dir: string
+		root: boolean
+	}) => {
+		console.log('Deploying admin...')
+		const files = await this.readAdminFiles(dir)
+		const project = root ? null : this.remoteProjectProvider.get().name
+
+		// 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 this.adminClient.deploy(project, files)
+
+		console.log(`Admin deployed (${files.length} files)`)
+	}
+
+
+	private readAdminFiles = async (dir: string, prefix: string = ''): Promise<AdminFiles> => {
+		const files = []
+		for (const fileName of await this.fs.readDir(dir, { withFileTypes: true })) {
+			if (fileName.isDirectory()) {
+				const subFiles = await this.readAdminFiles(`${dir}/${fileName.name}`, prefix + fileName.name + '/')
+				files.push(...subFiles)
+			} else if (fileName.isFile()) {
+				files.push({
+					path: prefix + fileName.name,
+					data: (await this.fs.readFile(`${dir}/${fileName.name}`)).toString('base64'),
+				})
+			}
+		}
+
+		return files
+	}
+}

package/src/lib/dsn.ts

@@ -0,0 +1,13 @@
+import { URL } from 'node:url'
+
+export const parseDsn = (dsn: string): { endpoint: string; project: string; token: string } => {
+	const uri = new URL(dsn)
+	if (uri.protocol !== 'contember:' && uri.protocol !== 'contember-unsecure:') {
+		throw 'Invalid DSN'
+	}
+	return {
+		project: uri.username,
+		token: uri.password,
+		endpoint: (uri.protocol === 'contember-unsecure:' ? 'http://' : 'https://') + uri.host,
+	}
+}

package/src/lib/env.ts

@@ -0,0 +1,21 @@
+export interface CliEnv {
+	apiToken?: string
+	loginToken?: string
+	apiUrl?: string
+	projectName?: string
+	dockerComposeFile?: string
+	dsn?: string
+	dir?: string
+}
+
+export const readCliEnv = (): CliEnv => {
+	return {
+		dir: process.env.CONTEMBER_DIR,
+		apiToken: process.env.CONTEMBER_API_TOKEN,
+		loginToken: process.env.CONTEMBER_LOGIN_TOKEN,
+		apiUrl: process.env.CONTEMBER_API_URL ?? process.env.CONTEMBER_INSTANCE,
+		projectName: process.env.CONTEMBER_PROJECT_NAME,
+		dockerComposeFile: process.env.COMPOSE_FILE,
+		dsn: process.env.CONTEMBER_DSN,
+	}
+}

package/src/lib/fs/DockerComposeManager.ts

@@ -0,0 +1,63 @@
+import { dirname, join } from 'node:path'
+import jsyaml from 'js-yaml'
+import { FileSystem } from './FileSystem'
+import { JsonUpdateCallback, YamlHandler } from './YamlHandler'
+
+export interface DockerComposeServiceConfig {
+	image?: string
+	command?: string
+	user?: string
+	environment?: Record<string, string>
+	ports?: (string | {})[] // todo long syntax
+}
+
+export interface DockerComposeConfig {
+	[key: string]: unknown
+
+	version?: string
+	services?: Record<string, DockerComposeServiceConfig>
+}
+
+
+const MAIN_CONFIGS = ['docker-compose.yaml', 'docker-compose.yml']
+
+
+export class DockerComposeManager {
+	constructor(
+		private readonly dir: string,
+		private readonly composeFile: string | undefined,
+		private readonly fs: FileSystem,
+		private readonly yamlHandler: YamlHandler,
+	) {
+	}
+
+	tryReadMainDockerComposeConfig = async (dir: string = this.dir): Promise<DockerComposeConfig | null> => {
+		const path = await this.resolvePath(dir, MAIN_CONFIGS)
+		if (!path) {
+			if (dir === '/') {
+				return null
+			}
+			return await this.tryReadMainDockerComposeConfig(dirname(dir))
+		}
+		return jsyaml.load(await this.fs.readFile(path, 'utf8')) as DockerComposeConfig
+	}
+
+	updateMainDockerComposeConfig = async (
+		updater: JsonUpdateCallback<DockerComposeConfig>,
+		dir: string = this.dir,
+	): Promise<void> => {
+		const path = this.composeFile || (await this.resolvePath(dir, MAIN_CONFIGS)) || join(dir, MAIN_CONFIGS[0])
+		return this.yamlHandler.updateYaml(path, updater, { createMissing: true })
+	}
+
+	private resolvePath = async (dir: string, possibleFileNames: string[]): Promise<string | null> => {
+		for (const file of possibleFileNames) {
+			const path = join(dir, file)
+			if (await this.fs.pathExists(path)) {
+				return path
+			}
+		}
+		return null
+	}
+
+}

package/src/lib/fs/FileSystem.ts

@@ -0,0 +1,19 @@
+import * as fs from 'node:fs/promises'
+import { access } from 'node:fs/promises'
+import glob from 'fast-glob'
+
+export class FileSystem {
+	readDir = fs.readdir
+	readFile = fs.readFile
+	pathExists = async (path: string) => {
+		try {
+			await access(path)
+			return true
+		} catch {
+			return false
+		}
+	}
+	listDirectories = async (dir: string, patterns: string[]): Promise<string[]> => {
+		return await glob(patterns, { onlyDirectories: true, cwd: dir })
+	}
+}

package/src/lib/fs/YamlHandler.ts

@@ -0,0 +1,59 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import jsyaml from 'js-yaml'
+import { FileSystem } from './FileSystem'
+import YAWN from 'yawn-yaml'
+import { JSONObject, JSONPrimitive } from '../json'
+import { Merger } from '@contember/config-loader'
+
+export type JsonUpdateCallback<Value = JSONObject> = (
+	data: Partial<Value>,
+	utils: { merge: (a: JSONObject, b: JSONObject) => JSONObject },
+) => Value
+
+export class YamlHandler {
+	constructor(
+		private readonly fs: FileSystem,
+	) {
+	}
+
+	readYaml = async <T = unknown>(path: string): Promise<T> => {
+		const content = await this.fs.readFile(path, { encoding: 'utf8' })
+		return jsyaml.load(content) as unknown as T
+	}
+
+	tryReadYaml = async <T = unknown>(path: string): Promise<T | null> => {
+		try {
+			return await this.readYaml<T>(path)
+		} catch (e: any) {
+			if (e.code === 'ENOENT') {
+				return null
+			}
+			throw e
+		}
+	}
+
+	updateYaml = async <Value = JSONObject>(
+		path: string,
+		updater: JsonUpdateCallback<Value>,
+		options: { createMissing?: boolean } = {},
+	) => {
+		let config = ''
+		if (await this.fs.pathExists(path)) {
+			config = await readFile(path, { encoding: 'utf8' })
+		} else if (options.createMissing !== true) {
+			throw new Error(`File ${path} does not exist.`)
+		}
+
+		let newConfig = ''
+		const mergeUtils = { merge: (a: JSONObject, b: JSONObject) => Merger.merge<JSONPrimitive>(a, b) }
+		if (config) {
+			const yawn = new YAWN(config)
+			yawn.json = updater(yawn.json, mergeUtils)
+			newConfig = yawn.yaml
+		} else {
+			newConfig = jsyaml.dump(updater({}, mergeUtils))
+		}
+
+		await writeFile(path, newConfig, { encoding: 'utf8' })
+	}
+}

package/src/lib/js/EsBuildBuilder.ts

@@ -0,0 +1,17 @@
+import { JsBuilder } from './JsBuilder'
+import * as esbuild from 'esbuild'
+
+export class EsBuildBuilder implements JsBuilder {
+	async build(path: string): Promise<string> {
+		const response = await esbuild.build({
+			entryPoints: [path],
+			platform: 'node',
+			bundle: true,
+			treeShaking: true,
+			write: false,
+			loader: { '.sql': 'text' },
+			external: ['@contember/admin', 'react', 'react/jsx-runtime'],
+		})
+		return response.outputFiles[0].text
+	}
+}

package/src/lib/js/EvalExecutor.ts

@@ -0,0 +1,8 @@
+import { JsExecutor } from './JsExecutor'
+
+export class EvalExecutor implements JsExecutor {
+	public async execute(code: string): Promise<unknown> {
+		const fn = new Function(`var module = {}; ((module) => { ${code} })(module); return module`)
+		return fn().exports
+	}
+}

package/src/lib/js/JsBuilder.ts

@@ -0,0 +1,3 @@
+export interface JsBuilder {
+	build(path: string): Promise<string>
+}

package/src/lib/js/JsCodeRunner.ts

@@ -0,0 +1,15 @@
+import { JsBuilder } from './JsBuilder'
+import { JsExecutor } from './JsExecutor'
+
+export class JsCodeRunner {
+	constructor(
+		private readonly jsBuilder: JsBuilder,
+		private readonly jsExecutor: JsExecutor,
+	) {
+	}
+
+	run = async (path: string): Promise<unknown> => {
+		const builtCode = await this.jsBuilder.build(path)
+		return this.jsExecutor.execute(builtCode)
+	}
+}

package/src/lib/js/JsExecutor.ts

@@ -0,0 +1,3 @@
+export interface JsExecutor {
+	execute(code: string): Promise<unknown>
+}