@contember/cli-common 1.3.0-alpha.8 → 1.3.0-beta.1

package/dist/src/utils/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/utils/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,WAG7B,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/utils/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,QAAO,MAGpC,CAAA"}

package/dist/src/utils/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../src/utils/version.ts"],"names":[],"mappings":";;;AAAA,yCAAgC;AAChC,4CAA0C;AAEnC,MAAM,iBAAiB,GAAG,GAAG,EAAE;IACrC,8DAA8D;IAC9D,OAAO,OAAO,CAAC,IAAA,gBAAI,EAAC,uBAAW,EAAE,cAAc,CAAC,CAAC,CAAC,OAAO,CAAA;AAC1D,CAAC,CAAA;AAHY,QAAA,iBAAiB,qBAG7B"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../src/utils/version.ts"],"names":[],"mappings":";;;AAAA,yCAAgC;AAChC,4CAA0C;AAEnC,MAAM,iBAAiB,GAAG,GAAW,EAAE;IAC7C,8DAA8D;IAC9D,OAAO,OAAO,CAAC,IAAA,gBAAI,EAAC,uBAAW,EAAE,cAAc,CAAC,CAAC,CAAC,OAAO,CAAA;AAC1D,CAAC,CAAA;AAHY,QAAA,iBAAiB,qBAG7B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/cli-common",
-  "version": "1.3.0-alpha.8",
+  "version": "1.3.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -19,10 +19,11 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "download-tarball": "^2.0.0",
+    "fast-glob": "^3.2.12",
     "fs-extra": "^10.0.0",
     "get-package-json-from-registry": "^2.2.2",
     "js-yaml": "^4.1.0",
     "npm-package-arg": "^9.0.2",
     "registry-info": "^1.0.0"
   }
-}
+}

package/src/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports =  {
+	rules: {
+		"no-console": "off",
+	},
+};

package/src/index.ts

@@ -1,2 +1,3 @@
 export { Application, Input, Command, CommandManager, CommandConfiguration, CommandFactoryList } from './application'
 export * from './utils'
+export * from './npm'

package/src/npm/FsManager.ts

@@ -0,0 +1,38 @@
+import jsyaml from 'js-yaml'
+import fs from 'node:fs/promises'
+import glob from 'fast-glob'
+import { pathExists } from '../utils'
+
+export class FsManager {
+	constructor() {
+	}
+
+	public async exists(filename: string): Promise<boolean> {
+		return await pathExists(filename)
+	}
+
+	public async tryReadJson<T = any>(filename: string): Promise<T | null> {
+		const content = await this.tryReadFile(filename)
+		return content !== null ? JSON.parse(content) : null
+	}
+
+	public async tryReadYaml<T = any>(filename: string): Promise<T | null> {
+		const content = await this.tryReadFile(filename)
+		return content !== null ? jsyaml.load(content) as T : null
+	}
+
+	public async tryReadFile(filename: string): Promise<string | null> {
+		try {
+			return await fs.readFile(filename, 'utf8')
+		} catch (error: any) {
+			if (error.code === 'ENOENT') {
+				return null
+			}
+			throw error
+		}
+	}
+
+	public async listDirectories(dir: string, patterns: string[]): Promise<string[]> {
+		return await glob(patterns, { onlyDirectories: true, cwd: dir })
+	}
+}

package/src/npm/Package.ts

@@ -0,0 +1,10 @@
+import { PackageJson } from './PackageJson'
+
+export class Package {
+	constructor(
+		public readonly dir: string,
+		public readonly isRoot: boolean,
+		public readonly packageJson: PackageJson,
+	) {
+	}
+}

package/src/npm/PackageJson.ts

@@ -0,0 +1,11 @@
+export type PackageJson =
+	& {
+		name: string
+		version: string
+		dependencies?: Record<string, string>
+		devDependencies?: Record<string, string>
+		workspaces?: string[] | { packages?: string[]; nohoist?: string[] }
+	}
+	& {
+		[prop: string]: undefined
+	}

package/src/npm/PackageWorkspace.ts

@@ -0,0 +1,126 @@
+import { PackageManager } from './packageManagers/PackageManager'
+import { Package } from './Package'
+import { FsManager } from './FsManager'
+import { dirname, join } from 'node:path'
+import { PackageJson } from './PackageJson'
+import { pathExists } from '../utils'
+
+export type Dependency = {
+	pckg: Package
+	isDev: boolean
+	version: string
+	name: string
+}
+
+
+export class PackageWorkspace {
+	constructor(
+		private readonly packageManager: PackageManager,
+		private readonly fsManager: FsManager,
+		public readonly rootPackage: Package,
+		public readonly packages: Package[],
+	) {
+	}
+
+	get allPackages() {
+		return [this.rootPackage, ...this.packages]
+	}
+
+	public findDefinedDependencies(packageName: string): Dependency[] {
+		return this.allPackages.flatMap<Dependency>(it => {
+			for (const type of ['dependencies', 'devDependencies'] as const) {
+				const version = it.packageJson[type]?.[packageName]
+				if (version) {
+					return [{ pckg: it, isDev: type === 'devDependencies', version: version, name: packageName }]
+				}
+			}
+			return []
+		})
+	}
+
+	public async findInstalledDependencies(packageName: string): Promise<{ installed?: Dependency; defined: Dependency }[]> {
+		const definedDependencies = this.findDefinedDependencies(packageName)
+
+		const deps: { installed?: Dependency; defined: Dependency }[] = []
+		for (const defined of definedDependencies) {
+			const packageJsonPath = await this.resolvePackageJson(defined.pckg.dir, packageName)
+			if (!packageJsonPath) {
+				deps.push({ defined })
+				continue
+			}
+			const packageJson = await this.fsManager.tryReadJson<PackageJson>(packageJsonPath)
+			deps.push({ defined, installed: { ...defined, version: packageJson?.version ?? '' } })
+		}
+		return deps
+	}
+
+	private async resolvePackageJson(dir: string, packageName: string) {
+		while (true) {
+			const fullPath = join(dir, 'node_modules', packageName, 'package.json')
+			if (await pathExists(fullPath)) {
+				return fullPath
+			}
+			if (dir === '/') {
+				return null
+			}
+			dir = dirname(dir)
+		}
+	}
+
+	async updateEverywhere(updates: Record<string, string>): Promise<Dependency[]> {
+		const defined = Object.keys(updates).flatMap(it => this.findDefinedDependencies(it))
+		const byPckg = new Map<Package, Dependency[]>()
+		for (const it of defined) {
+			const arr = byPckg.get(it.pckg) ?? []
+			byPckg.set(it.pckg, arr)
+			arr.push(it)
+		}
+
+		const updated: Dependency[] = []
+		for (const [pckg, deps] of byPckg.entries()) {
+			const prod = deps.filter(it => !it.isDev)
+			const dev = deps.filter(it => it.isDev)
+			for (const [isDev, deps] of [[false, prod], [true, dev]] as const) {
+				if (deps.length === 0) {
+					continue
+				}
+				await this.packageManager.install({
+					pckg,
+					isDev,
+					dependencies: Object.fromEntries(deps.map(it => [it.name, updates[it.name]])),
+				})
+				updated.push(...deps)
+			}
+		}
+		return updated
+	}
+}
+
+export class PackageWorkspaceResolver {
+	constructor(
+		private fsManager: FsManager,
+		private packageManagers: PackageManager[],
+	) {
+	}
+
+	public async resolve(dir: string): Promise<PackageWorkspace> {
+		const packageJson = await this.fsManager.tryReadJson<PackageJson>(join(dir, 'package.json'))
+		if (!packageJson) {
+			throw `package.json not found.`
+		}
+		const pm = await this.resolvePackageManager({ dir, packageJson })
+		const rootPackage = new Package(dir, true, packageJson)
+		const workspacePackages = await pm.readWorkspacePackages({ dir, packageJson })
+
+		return new PackageWorkspace(pm, this.fsManager, rootPackage, workspacePackages)
+	}
+
+	private async resolvePackageManager(args: { dir: string; packageJson: PackageJson }): Promise<PackageManager> {
+		for (const pm of this.packageManagers) {
+			if (await pm.isActive(args)) {
+				return pm
+			}
+		}
+		throw `No lockfile found. Please install dependencies using package manager of your choice.`
+	}
+}

package/src/npm/index.ts

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

package/src/npm/packageManagers/Npm.ts

@@ -0,0 +1,39 @@
+import { PackageManager } from './PackageManager'
+import { FsManager } from '../FsManager'
+import { Package } from '../Package'
+import { PackageJson } from '../PackageJson'
+import { join } from 'node:path'
+import { PackageManagerHelpers } from './PackageManagerHelpers'
+import { runCommand } from '../../utils/commands'
+
+export class Npm implements PackageManager {
+	constructor(
+		private readonly fsManager: FsManager,
+	) {
+	}
+
+	async install({ pckg, dependencies, isDev }: { pckg: Package; isDev: boolean; dependencies: Record<string, string> }): Promise<void> {
+		const { output } = runCommand('npm', [
+			'install',
+			isDev ? '--save-dev' : '--save',
+			...PackageManagerHelpers.formatPackagesToInstall(dependencies),
+		], {
+			cwd: pckg.dir,
+			stderr: process.stderr,
+			stdout: process.stdout,
+		})
+		await output
+	}
+
+	async isActive({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<boolean> {
+		return await this.fsManager.exists(join(dir, 'package-lock.json'))
+	}
+
+	async readWorkspacePackages({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<Package[]> {
+		return await PackageManagerHelpers.readWorkspacePackages({
+			fsManager: this.fsManager,
+			dir,
+			workspaces: PackageManagerHelpers.getWorkspacesFromPackageJson({ packageJson }),
+		})
+	}
+}

package/src/npm/packageManagers/PackageManager.ts

@@ -0,0 +1,11 @@
+import { PackageJson } from '../PackageJson'
+
+import { Package } from '../Package'
+
+export interface PackageManager {
+	isActive(args: { dir: string; packageJson: PackageJson }): Promise<boolean>
+
+	readWorkspacePackages(args: { dir: string; packageJson: PackageJson }): Promise<Package[]>
+
+	install(args: { pckg: Package; isDev: boolean; dependencies: Record<string, string> }): Promise<void>
+}

package/src/npm/packageManagers/PackageManagerHelpers.ts

@@ -0,0 +1,35 @@
+import { FsManager } from '../FsManager'
+import { Package } from '../Package'
+import { PackageJson } from '../PackageJson'
+import { join } from 'node:path'
+
+export class PackageManagerHelpers {
+	static async readWorkspacePackages({ fsManager, dir, workspaces }: {
+		fsManager: FsManager
+		dir: string
+		workspaces: string[]
+	}): Promise<Package[]> {
+		const dirs = await fsManager.listDirectories(dir, workspaces)
+
+		const packageJson = await Promise.all(dirs.map(async it => {
+			const packageJson = await fsManager.tryReadJson<PackageJson>(join(it, 'package.json'))
+			return packageJson ? [packageJson, it] as const : null
+		}))
+
+		return packageJson.filter(<T>(it: T | null): it is T => it !== null).map(([packageJson, dir]) => new Package(dir, false, packageJson))
+	}
+
+	static getWorkspacesFromPackageJson({ packageJson }: { packageJson: PackageJson }): string[] {
+		if (!packageJson.workspaces) {
+			return []
+		}
+		if (Array.isArray(packageJson.workspaces)) {
+			return packageJson.workspaces
+		}
+		return [...packageJson.workspaces?.packages ?? [], ...packageJson.workspaces?.nohoist ?? []]
+	}
+
+	static formatPackagesToInstall(packages: Record<string, string>): string[] {
+		return Object.entries(packages).map(([name, version]) => `${name}@${version}`)
+	}
+}

package/src/npm/packageManagers/Pnpm.ts

@@ -0,0 +1,42 @@
+import { FsManager } from '../FsManager'
+import { join } from 'node:path'
+
+import { PackageJson } from '../PackageJson'
+import { PackageManager } from './PackageManager'
+import { Package } from '../Package'
+import { PackageManagerHelpers } from './PackageManagerHelpers'
+import { runCommand } from '../../utils/commands'
+
+export class Pnpm implements PackageManager {
+	constructor(
+		private readonly fsManager: FsManager,
+	) {
+	}
+
+	async install({ pckg, dependencies, isDev }: { pckg: Package; isDev: boolean; dependencies: Record<string, string> }): Promise<void> {
+		const { output } = runCommand('pnpm', [
+			'add',
+			isDev ? '--save-dev' : '--save',
+			pckg.isRoot ? '--ignore-workspace-root-check' : undefined,
+			...PackageManagerHelpers.formatPackagesToInstall(dependencies),
+		], {
+			cwd: pckg.dir,
+			stderr: process.stderr,
+			stdout: process.stdout,
+		})
+		await output
+	}
+
+	async isActive({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<boolean> {
+		return await this.fsManager.exists(join(dir, 'pnpm-lock.yaml'))
+	}
+
+	async readWorkspacePackages({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<Package[]> {
+		const pnpmWorkspaces = await this.fsManager.tryReadJson(join(dir, 'pnpm-workspace.yaml'))
+		return await PackageManagerHelpers.readWorkspacePackages({
+			fsManager: this.fsManager,
+			dir,
+			workspaces: pnpmWorkspaces.packages,
+		})
+	}
+}

package/src/npm/packageManagers/Yarn.ts

@@ -0,0 +1,40 @@
+import { PackageManager } from './PackageManager'
+import { FsManager } from '../FsManager'
+import { Package } from '../Package'
+import { PackageJson } from '../PackageJson'
+import { join } from 'node:path'
+import { PackageManagerHelpers } from './PackageManagerHelpers'
+import { runCommand } from '../../utils/commands'
+
+export class Yarn implements PackageManager {
+	constructor(
+		private readonly fsManager: FsManager,
+	) {
+	}
+
+	async install({ pckg, dependencies, isDev }: { pckg: Package; isDev: boolean; dependencies: Record<string, string> }): Promise<void> {
+		const { output } = runCommand('yarn', [
+			'add',
+			isDev ? '--dev' : undefined,
+			...PackageManagerHelpers.formatPackagesToInstall(dependencies),
+		], {
+			cwd: pckg.dir,
+			stderr: process.stderr,
+			stdout: process.stdout,
+		})
+		await output
+	}
+
+	async isActive({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<boolean> {
+		return await this.fsManager.exists(join(dir, 'yarn.lock'))
+			&& (!packageJson.packageManager || (packageJson.packageManager as string).startsWith('yarn@3') || (packageJson.packageManager as string).startsWith('yarn@2'))
+	}
+
+	async readWorkspacePackages({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<Package[]> {
+		return await PackageManagerHelpers.readWorkspacePackages({
+			fsManager: this.fsManager,
+			dir,
+			workspaces: PackageManagerHelpers.getWorkspacesFromPackageJson({ packageJson }),
+		})
+	}
+}

package/src/npm/packageManagers/YarnClassic.ts

@@ -0,0 +1,40 @@
+import { PackageManager } from './PackageManager'
+import { FsManager } from '../FsManager'
+import { Package } from '../Package'
+import { PackageJson } from '../PackageJson'
+import { join } from 'node:path'
+import { PackageManagerHelpers } from './PackageManagerHelpers'
+import { runCommand } from '../../utils/commands'
+
+export class YarnClassic implements PackageManager {
+	constructor(
+		private readonly fsManager: FsManager,
+	) {
+	}
+
+	async install({ pckg, dependencies, isDev }: { pckg: Package; isDev: boolean; dependencies: Record<string, string> }): Promise<void> {
+		const { output } = runCommand('yarn', [
+			'add',
+			isDev ? '--dev' : undefined,
+			pckg.isRoot ? '--ignore-workspace-root-check' : undefined,
+			...PackageManagerHelpers.formatPackagesToInstall(dependencies),
+		], {
+			cwd: pckg.dir,
+			stderr: process.stderr,
+			stdout: process.stdout,
+		})
+		await output
+	}
+
+	async isActive({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<boolean> {
+		return await this.fsManager.exists(join(dir, 'yarn.lock'))
+	}
+
+	async readWorkspacePackages({ dir, packageJson }: { dir: string; packageJson: PackageJson }): Promise<Package[]> {
+		return await PackageManagerHelpers.readWorkspacePackages({
+			fsManager: this.fsManager,
+			dir,
+			workspaces: PackageManagerHelpers.getWorkspacesFromPackageJson({ packageJson }),
+		})
+	}
+}

package/src/utils/Workspace.ts

@@ -6,6 +6,12 @@ import { getPackageVersion } from './version'
 import { readYaml } from './yaml'
 import { CliEnv, readCliEnv } from '../application'
 import { pathExists } from './fs'
+import { PackageWorkspace, PackageWorkspaceResolver } from '../npm/PackageWorkspace'
+import { FsManager } from '../npm/FsManager'
+import { Yarn } from '../npm/packageManagers/Yarn'
+import { YarnClassic } from '../npm/packageManagers/YarnClassic'
+import { Pnpm } from '../npm/packageManagers/Pnpm'
+import { Npm } from '../npm/packageManagers/Npm'
 
 export interface WorkspaceDirectoryArgument {
 	workspaceDirectory: string
@@ -28,7 +34,6 @@ export const createWorkspace = async ({ workspaceDirectory, workspaceName, templ
 
 export interface WorkspaceConfig {
 	api?: {
-		version?: string
 		configFile?: string
 	}
 	admin?: {
@@ -45,11 +50,20 @@ export class Workspace {
 		public readonly directory: string,
 		public readonly env: CliEnv,
 		public readonly config: WorkspaceConfig,
+		private readonly packageWorkspaceResolver: PackageWorkspaceResolver,
 	) {}
 
 	public static async get(workspaceDirectory: string) {
 		const config = await readWorkspaceConfig({ workspaceDirectory })
-		return new Workspace(workspaceDirectory, readCliEnv(), config)
+		const fsManager = new FsManager()
+		const packageWorkspaceResolver = new PackageWorkspaceResolver(fsManager, [
+			new Yarn(fsManager),
+			new YarnClassic(fsManager),
+			new Pnpm(fsManager),
+			new Npm(fsManager),
+		])
+
+		return new Workspace(workspaceDirectory, readCliEnv(), config, packageWorkspaceResolver)
 	}
 
 	get name() {
@@ -60,14 +74,13 @@ export class Workspace {
 		return this.config?.admin?.enabled || false
 	}
 
-	get apiVersion(): string | undefined {
-		return this.config?.api?.version || undefined
-	}
-
-
 	public isSingleProjectMode(): boolean {
 		return !!this.env.projectName
 	}
+
+	public async resolvePackageWorkspace(): Promise<PackageWorkspace> {
+		return await this.packageWorkspaceResolver.resolve(this.directory)
+	}
 }
 
 export const formatWorkspaceConfigPath = (workspaceDirectory: string) => [

package/src/utils/commands.ts

@@ -0,0 +1,65 @@
+import { ChildProcessWithoutNullStreams, spawn } from 'node:child_process'
+import { Readable, Writable } from 'node:stream'
+import chalk from 'chalk'
+
+export type RunningCommand = { child: ChildProcessWithoutNullStreams; output: Promise<string> }
+export const runCommand = (
+	command: string,
+	args: (string | undefined)[],
+	options: {
+		cwd: string
+		stdin?: Readable
+		stdout?: Writable
+		stderr?: Writable
+		env?: NodeJS.ProcessEnv
+		detached?: boolean
+	},
+): RunningCommand => {
+	const args2 = args.filter((it): it is string => it !== undefined)
+	if (!process.env.DISABLE_COMMAND_PRINTING) {
+		console.error(chalk.gray(`$ ${command} ${args2.map(it => `'${it.replace(/'/g, `'\\''`)}'`).join(' ')}`))
+	}
+	const child = spawn(command, args2, {
+		cwd: options.cwd,
+		env: { ...process.env, ...(options.env || {}) },
+		detached: options.detached,
+	})
+	if (options.stdin) {
+		options.stdin.pipe(child.stdin)
+	}
+
+	let stdout = ''
+	let stderr = ''
+
+	child.stdout.on('data', (chunk): void => {
+		stdout += chunk.toString()
+	})
+
+	child.stderr.on('data', (chunk): void => {
+		stderr += chunk.toString()
+	})
+	if (options.stdout) {
+		child.stdout.pipe(options.stdout)
+	}
+	if (options.stderr) {
+		child.stderr.pipe(options.stderr)
+	}
+
+	const output = new Promise<string>((resolve, reject) => {
+		child.on('exit', (exitCode): void => {
+			if (exitCode === 0) {
+				resolve(stdout)
+			} else {
+				reject(new ChildProcessError(exitCode, stderr))
+			}
+		})
+	})
+
+	return { output, child }
+}
+
+export class ChildProcessError extends Error {
+	constructor(public readonly exitCode: number | null, public readonly stderr: string) {
+		super(`Command has failed(${exitCode}): ${stderr} `)
+	}
+}

package/src/utils/version.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path'
 import { packageRoot } from '../pathUtils'
 
-export const getPackageVersion = () => {
+export const getPackageVersion = (): string => {
 	// eslint-disable-next-line @typescript-eslint/no-var-requires
 	return require(join(packageRoot, 'package.json')).version
 }