wehub-resource-sync
598 lines
18 KiB
TypeScript
598 lines
18 KiB
TypeScript
import {
|
|
output,
|
|
PackageManager,
|
|
ProjectConfiguration,
|
|
TargetConfiguration,
|
|
} from '@nx/devkit';
|
|
import { ChildProcess, exec, execSync, ExecSyncOptions } from 'child_process';
|
|
import { existsSync } from 'fs-extra';
|
|
import * as isCI from 'is-ci';
|
|
import { join } from 'node:path';
|
|
import { stripVTControlCharacters } from 'node:util';
|
|
import { gte } from 'semver';
|
|
import { packageInstall, tmpProjPath } from './create-project-utils';
|
|
import {
|
|
ensureCypressInstallation,
|
|
ensurePlaywrightBrowsersInstallation,
|
|
} from './ensure-browser-installation';
|
|
import { fileExists, readJson, updateJson } from './file-utils';
|
|
import {
|
|
detectPackageManager,
|
|
getNpmMajorVersion,
|
|
getPnpmVersion,
|
|
getPublishedVersion,
|
|
getStrippedEnvironmentVariables,
|
|
getYarnMajorVersion,
|
|
isVerboseE2ERun,
|
|
} from './get-env-info';
|
|
import { logError, logInfo } from './log-utils';
|
|
|
|
export interface RunCmdOpts {
|
|
silenceError?: boolean;
|
|
env?: Record<string, string | undefined>;
|
|
cwd?: string;
|
|
silent?: boolean;
|
|
verbose?: boolean;
|
|
redirectStderr?: boolean;
|
|
timeout?: number;
|
|
/** Override daemon mode for this call. Defaults to `true`; set `false` to exercise the non-daemon path. */
|
|
daemon?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Caps maxWorkers in CI for node/web/jest builds so they don't spawn ~34 workers.
|
|
*/
|
|
export function setMaxWorkers(projectJsonPath: string) {
|
|
if (isCI) {
|
|
updateJson<ProjectConfiguration>(projectJsonPath, (project) => {
|
|
const { build } = project.targets as {
|
|
[targetName: string]: TargetConfiguration<any>;
|
|
};
|
|
|
|
if (!build) {
|
|
return project;
|
|
}
|
|
|
|
const executor = build.executor as string;
|
|
if (
|
|
executor.startsWith('@nx/node') ||
|
|
executor.startsWith('@nx/web') ||
|
|
executor.startsWith('@nx/jest')
|
|
) {
|
|
build.options.maxWorkers = 4;
|
|
}
|
|
|
|
return project;
|
|
});
|
|
}
|
|
}
|
|
|
|
export function runCommand(
|
|
command: string,
|
|
options?: Partial<ExecSyncOptions> & { failOnError?: boolean }
|
|
): string {
|
|
const {
|
|
failOnError,
|
|
env: optionsEnv,
|
|
...childProcessOptions
|
|
} = options ?? {};
|
|
try {
|
|
const r = execSync(command, {
|
|
cwd: tmpProjPath(),
|
|
stdio: 'pipe',
|
|
env: {
|
|
// Use new versioning by default in e2e tests
|
|
NX_INTERNAL_USE_LEGACY_VERSIONING: 'false',
|
|
...getStrippedEnvironmentVariables(),
|
|
...optionsEnv,
|
|
FORCE_COLOR: 'false',
|
|
},
|
|
encoding: 'utf-8',
|
|
...childProcessOptions,
|
|
});
|
|
|
|
if (isVerboseE2ERun()) {
|
|
output.log({
|
|
title: `Command: ${command}`,
|
|
bodyLines: [r as string],
|
|
color: 'green',
|
|
});
|
|
}
|
|
|
|
return stripVTControlCharacters(r as string);
|
|
} catch (e) {
|
|
// Intentional: some commands (e.g. `npm ls`) exit non-zero but still produce useful output.
|
|
logError(`Original command: ${command}`, `${e.stdout}\n\n${e.stderr}`);
|
|
if (!failOnError && (e.stdout || e.stderr)) {
|
|
return stripVTControlCharacters(e.stdout + e.stderr);
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
export function getPackageManagerCommand({
|
|
path = tmpProjPath(),
|
|
packageManager = detectPackageManager(path),
|
|
} = {}): {
|
|
createWorkspace: string;
|
|
run: (script: string, args: string) => string;
|
|
runNx: string;
|
|
runNxSilent: string;
|
|
runUninstalledPackage: string;
|
|
install: string;
|
|
ciInstall: string;
|
|
addProd: string;
|
|
addDev: string;
|
|
list: string;
|
|
runLerna: string;
|
|
exec: string;
|
|
} {
|
|
const npmMajorVersion = getNpmMajorVersion();
|
|
const yarnMajorVersion = getYarnMajorVersion(path);
|
|
const pnpmVersion = getPnpmVersion();
|
|
const publishedVersion = getPublishedVersion();
|
|
const isYarnWorkspace = fileExists(join(path, 'package.json'))
|
|
? readJson('package.json').workspaces
|
|
: false;
|
|
const isPnpmWorkspace = existsSync(join(path, 'pnpm-workspace.yaml'));
|
|
|
|
return {
|
|
npm: {
|
|
createWorkspace: `npx ${
|
|
npmMajorVersion && +npmMajorVersion >= 7 ? '--yes' : ''
|
|
} create-nx-workspace@${publishedVersion}`,
|
|
run: (script: string, args: string) => `npm run ${script} -- ${args}`,
|
|
runNx: `npx nx`,
|
|
runNxSilent: `npx nx`,
|
|
runUninstalledPackage: `npx --yes`,
|
|
install: 'npm install',
|
|
ciInstall: 'npm ci',
|
|
addProd: `npm install`,
|
|
addDev: `npm install -D`,
|
|
list: 'npm ls --depth 10',
|
|
runLerna: `npx lerna`,
|
|
exec: 'npx',
|
|
},
|
|
yarn: {
|
|
createWorkspace: `npx ${
|
|
npmMajorVersion && +npmMajorVersion >= 7 ? '--yes' : ''
|
|
} create-nx-workspace@${publishedVersion}`,
|
|
run: (script: string, args: string) => `yarn ${script} ${args}`,
|
|
runNx: `yarn nx`,
|
|
runNxSilent:
|
|
yarnMajorVersion && +yarnMajorVersion >= 2
|
|
? 'yarn nx'
|
|
: `yarn --silent nx`,
|
|
runUninstalledPackage: 'npx --yes',
|
|
install: 'yarn',
|
|
ciInstall: 'yarn --frozen-lockfile',
|
|
addProd: isYarnWorkspace ? 'yarn add -W' : 'yarn add',
|
|
addDev: isYarnWorkspace ? 'yarn add -DW' : 'yarn add -D',
|
|
list: 'yarn list --pattern',
|
|
runLerna:
|
|
yarnMajorVersion && +yarnMajorVersion >= 2
|
|
? 'yarn lerna'
|
|
: `yarn --silent lerna`,
|
|
exec: 'yarn',
|
|
},
|
|
pnpm: {
|
|
createWorkspace: `pnpm dlx create-nx-workspace@${publishedVersion}`,
|
|
run: (script: string, args: string) => `pnpm run ${script} -- ${args}`,
|
|
runNx: `pnpm exec nx`,
|
|
runNxSilent: `pnpm exec nx`,
|
|
runUninstalledPackage: 'pnpm dlx',
|
|
// --no-frozen-lockfile: pnpm detects CI and would otherwise default to --frozen-lockfile.
|
|
install: 'pnpm install --no-frozen-lockfile',
|
|
ciInstall: 'pnpm install --frozen-lockfile',
|
|
addProd: isPnpmWorkspace ? 'pnpm add -w' : 'pnpm add',
|
|
addDev: isPnpmWorkspace ? 'pnpm add -Dw' : 'pnpm add -D',
|
|
list: 'pnpm ls --depth 10',
|
|
runLerna: `pnpm exec lerna`,
|
|
exec: pnpmVersion && gte(pnpmVersion, '6.13.0') ? 'pnpm exec' : 'pnpx',
|
|
},
|
|
bun: {
|
|
// See note in runCreateWorkspace in create-project-utils.ts for why we don't set @{version} for `bunx create-nx-workspace` right now
|
|
createWorkspace: `bunx create-nx-workspace`,
|
|
run: (script: string, args: string) => `bun run ${script} -- ${args}`,
|
|
runNx: `bunx nx`,
|
|
runNxSilent: `bunx nx`,
|
|
runUninstalledPackage: `bunx --yes`,
|
|
install: 'bun install',
|
|
ciInstall: 'bun install --no-cache',
|
|
addProd: 'bun install',
|
|
addDev: 'bun install -D',
|
|
list: 'bun pm ls',
|
|
runLerna: `bunx lerna`,
|
|
exec: 'bun',
|
|
},
|
|
}[packageManager.trim() as PackageManager];
|
|
}
|
|
|
|
export function runE2ETests(runner?: 'cypress' | 'playwright') {
|
|
if (process.env.NX_E2E_RUN_E2E === 'true') {
|
|
if (!runner || runner === 'cypress') {
|
|
ensureCypressInstallation();
|
|
}
|
|
if (!runner || runner === 'playwright') {
|
|
ensurePlaywrightBrowsersInstallation();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
console.warn(
|
|
'Not running E2E tests because NX_E2E_RUN_E2E is not set to true.'
|
|
);
|
|
|
|
if (process.env.NX_E2E_RUN_CYPRESS) {
|
|
console.warn(
|
|
'NX_E2E_RUN_CYPRESS is deprecated, use NX_E2E_RUN_E2E instead.'
|
|
);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
export function runCommandAsync(
|
|
command: string,
|
|
opts: RunCmdOpts = {
|
|
silenceError: false,
|
|
env: process['env'],
|
|
}
|
|
): Promise<{ stdout: string; stderr: string; combinedOutput: string }> {
|
|
return new Promise((resolve, reject) => {
|
|
exec(
|
|
command,
|
|
{
|
|
cwd: opts.cwd || tmpProjPath(),
|
|
env: {
|
|
CI: 'true',
|
|
// Force daemon on under CI (matches runCLI); override via opts.daemon = false.
|
|
NX_DAEMON: opts.daemon === false ? 'false' : 'true',
|
|
// Use new versioning by default in e2e tests
|
|
NX_INTERNAL_USE_LEGACY_VERSIONING: 'false',
|
|
...(opts.env || getStrippedEnvironmentVariables()),
|
|
FORCE_COLOR: 'false',
|
|
},
|
|
encoding: 'utf-8',
|
|
},
|
|
(err, stdout, stderr) => {
|
|
if (!opts.silenceError && err) {
|
|
logError(`Original command: ${command}`, `${stdout}\n\n${stderr}`);
|
|
reject(err);
|
|
}
|
|
|
|
const outputs = {
|
|
stdout: stripVTControlCharacters(stdout),
|
|
stderr: stripVTControlCharacters(stderr),
|
|
combinedOutput: stripVTControlCharacters(`${stdout}${stderr}`),
|
|
};
|
|
|
|
if (opts.verbose ?? isVerboseE2ERun()) {
|
|
output.log({
|
|
title: `Original command: ${command}`,
|
|
bodyLines: [outputs.combinedOutput],
|
|
color: 'green',
|
|
});
|
|
}
|
|
|
|
resolve(outputs);
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
export function runCommandUntil(
|
|
command: string,
|
|
criteria: (output: string) => boolean,
|
|
opts: RunCmdOpts & { timeout?: number } = {}
|
|
): Promise<ChildProcess> {
|
|
const pm = getPackageManagerCommand();
|
|
const timeout = opts.timeout ?? 30_000;
|
|
const p = exec(`${pm.runNx} ${command}`, {
|
|
cwd: tmpProjPath(),
|
|
encoding: 'utf-8',
|
|
env: {
|
|
CI: 'true',
|
|
NX_DAEMON: 'true',
|
|
// Use new versioning by default in e2e tests
|
|
NX_INTERNAL_USE_LEGACY_VERSIONING: 'false',
|
|
...getStrippedEnvironmentVariables(),
|
|
...opts.env,
|
|
FORCE_COLOR: 'false',
|
|
},
|
|
windowsHide: false,
|
|
});
|
|
return new Promise((res, rej) => {
|
|
let output = '';
|
|
let complete = false;
|
|
|
|
const timeoutId = setTimeout(() => {
|
|
if (!complete) {
|
|
complete = true;
|
|
p.kill();
|
|
logError(
|
|
`Output did not meet the criteria:`,
|
|
output
|
|
.split('\n')
|
|
.map((l) => ` ${l}`)
|
|
.join('\n')
|
|
);
|
|
rej(new Error(`Timed out after ${timeout}ms waiting for criteria`));
|
|
}
|
|
}, timeout);
|
|
|
|
function checkCriteria(c) {
|
|
output += c.toString();
|
|
const strippedOutput = stripVTControlCharacters(output);
|
|
if (criteria(strippedOutput) && !complete) {
|
|
complete = true;
|
|
clearTimeout(timeoutId);
|
|
res(p);
|
|
}
|
|
}
|
|
|
|
p.stdout?.on('data', checkCriteria);
|
|
p.stderr?.on('data', checkCriteria);
|
|
p.on('close', (code) => {
|
|
if (!complete) {
|
|
complete = true;
|
|
clearTimeout(timeoutId);
|
|
logError(
|
|
`Original output:`,
|
|
output
|
|
.split('\n')
|
|
.map((l) => ` ${l}`)
|
|
.join('\n')
|
|
);
|
|
rej(new Error(`Exited with ${code}`));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
export function runCLIAsync(
|
|
command: string,
|
|
opts: RunCmdOpts = {
|
|
silenceError: false,
|
|
env: getStrippedEnvironmentVariables(),
|
|
silent: false,
|
|
}
|
|
): Promise<{ stdout: string; stderr: string; combinedOutput: string }> {
|
|
const pm = getPackageManagerCommand();
|
|
const commandToRun = `${opts.silent ? pm.runNxSilent : pm.runNx} ${command} ${
|
|
(opts.verbose ?? isVerboseE2ERun()) ? ' --verbose' : ''
|
|
}${opts.redirectStderr ? ' 2>&1' : ''}`;
|
|
|
|
return runCommandAsync(commandToRun, opts);
|
|
}
|
|
|
|
export function runNgAdd(
|
|
packageName: string,
|
|
command?: string,
|
|
version: string = getPublishedVersion(),
|
|
opts: RunCmdOpts = {
|
|
silenceError: false,
|
|
env: undefined,
|
|
cwd: tmpProjPath(),
|
|
}
|
|
): string {
|
|
try {
|
|
const pmc = getPackageManagerCommand();
|
|
packageInstall(packageName, undefined, version);
|
|
const fullCommand = pmc.run(`ng g ${packageName}:ng-add`, command ?? '');
|
|
const result = execSync(fullCommand, {
|
|
cwd: tmpProjPath(),
|
|
stdio: 'pipe',
|
|
env: { ...(opts.env || getStrippedEnvironmentVariables()) },
|
|
encoding: 'utf-8',
|
|
});
|
|
|
|
const r = stripVTControlCharacters(result);
|
|
|
|
if (opts.verbose ?? isVerboseE2ERun()) {
|
|
output.log({
|
|
title: `Original command: ${fullCommand}`,
|
|
bodyLines: [result as string],
|
|
color: 'green',
|
|
});
|
|
}
|
|
|
|
return r;
|
|
} catch (e) {
|
|
if (opts.silenceError) {
|
|
return e.stdout;
|
|
} else {
|
|
logError(`Ng Add failed: ${command}`, `${e.stdout}\n\n${e.stderr}`);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Replaces the run-to-run durations / core counts in Nx's performance report with
|
|
* stable placeholders so the report can stay in snapshots. Scoped to the report
|
|
* block (from `Run duration:` to the next `NX` section header or end of output);
|
|
* no-op when no report is present.
|
|
*/
|
|
export function normalizePerformanceReport(output: string): string {
|
|
return output.replace(
|
|
/\n[ \t]*Run duration:[\s\S]*?(?=\n[ \t]*\n(?:[ \t]*\n)*[ \t]*NX |\s*$)/g,
|
|
(block) =>
|
|
block
|
|
// Durations: match the minute form ("1m 30s") first so its "30s" isn't matched
|
|
// alone; the optional "<" also captures a "<1ms" (sub-millisecond) duration.
|
|
.replace(/<?(?:\b\d+m \d+s\b|\b\d+(?:\.\d+)?m?s\b)/g, '{DURATION}')
|
|
.replace(/\b\d+(?= cores?\b)/g, '{CORES}')
|
|
// Longest-tasks list right-aligns durations (padStart); collapse the varying
|
|
// id→duration gap back to a fixed 4-space separator so the table is deterministic.
|
|
.replace(/^([ \t]+\S+) {4,}(\{DURATION\})$/gm, '$1 $2')
|
|
// Stat rows align values by padding the label column, whose width may change;
|
|
// collapse the label→value gap so the snapshot doesn't depend on that padding.
|
|
.replace(
|
|
/^([ \t]*(?:Run duration|Cache|Critical path|Recoverable time):) +/gm,
|
|
'$1 '
|
|
)
|
|
);
|
|
}
|
|
|
|
export function runCLI(
|
|
command: string,
|
|
opts: RunCmdOpts = {
|
|
silenceError: false,
|
|
env: undefined,
|
|
verbose: undefined,
|
|
redirectStderr: undefined,
|
|
}
|
|
): string {
|
|
const timeoutMs = opts.timeout ?? 5 * 60 * 1000;
|
|
try {
|
|
const pm = getPackageManagerCommand();
|
|
const commandToRun = `${pm.runNxSilent} ${command} ${
|
|
(opts.verbose ?? isVerboseE2ERun()) ? ' --verbose' : ''
|
|
}${opts.redirectStderr ? ' 2>&1' : ''}`;
|
|
logInfo(`Run Command: ${command}`);
|
|
const startTime = performance.now();
|
|
const result = execSync(commandToRun, {
|
|
cwd: opts.cwd || tmpProjPath(),
|
|
env: {
|
|
CI: 'true',
|
|
// Daemon is normally off under CI; force it on so e2e exercises the same
|
|
// daemon-driven graph + watcher path real users hit. Override via opts.daemon = false.
|
|
NX_DAEMON: opts.daemon === false ? 'false' : 'true',
|
|
// Use new versioning by default in e2e tests
|
|
NX_INTERNAL_USE_LEGACY_VERSIONING: 'false',
|
|
...getStrippedEnvironmentVariables(),
|
|
...opts.env,
|
|
},
|
|
encoding: 'utf-8',
|
|
stdio: 'pipe',
|
|
maxBuffer: 50 * 1024 * 1024,
|
|
timeout: timeoutMs,
|
|
});
|
|
const elapsed = ((performance.now() - startTime) / 1000).toFixed(1);
|
|
logInfo(`Run Command: ${command} (${elapsed}s)`);
|
|
|
|
if (opts.verbose ?? isVerboseE2ERun()) {
|
|
output.log({
|
|
title: `Original command: ${command}`,
|
|
bodyLines: [result as string],
|
|
color: 'green',
|
|
});
|
|
}
|
|
|
|
const r = stripVTControlCharacters(result);
|
|
|
|
runCLI.lastExitCode = 0;
|
|
return r;
|
|
} catch (e) {
|
|
if (e.killed || e.signal) {
|
|
const timeoutSec = Math.round(timeoutMs / 1000);
|
|
const processOutput = stripVTControlCharacters(
|
|
`${e.stdout ?? ''}\n\n${e.stderr ?? ''}`
|
|
).trim();
|
|
const msg = `Command timed out after ${timeoutSec}s: ${command}\n\nProcess output:\n${processOutput}`;
|
|
logError(`Command timed out`, msg);
|
|
throw new Error(msg);
|
|
}
|
|
if (opts.silenceError) {
|
|
runCLI.lastExitCode = (e.status ?? 1) as number;
|
|
// Without redirectStderr the shell didn't merge stderr into stdout, so concat both.
|
|
const output = opts.redirectStderr ? e.stdout : e.stdout + e.stderr;
|
|
return stripVTControlCharacters(output);
|
|
} else {
|
|
logError(`Original command: ${command}`, `${e.stdout}\n\n${e.stderr}`);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
runCLI.lastExitCode = 0 as number;
|
|
|
|
export function runLernaCLI(
|
|
command: string,
|
|
opts: RunCmdOpts = {
|
|
silenceError: false,
|
|
env: undefined,
|
|
}
|
|
): string {
|
|
const timeoutMs = opts.timeout ?? 2 * 60 * 1000;
|
|
try {
|
|
const pm = getPackageManagerCommand();
|
|
const fullCommand = `${pm.runLerna} ${command}`;
|
|
const logs = execSync(fullCommand, {
|
|
cwd: opts.cwd || tmpProjPath(),
|
|
env: {
|
|
CI: 'true',
|
|
...(opts.env || getStrippedEnvironmentVariables()),
|
|
},
|
|
encoding: 'utf-8',
|
|
stdio: 'pipe',
|
|
maxBuffer: 50 * 1024 * 1024,
|
|
timeout: timeoutMs,
|
|
});
|
|
|
|
if (opts.verbose ?? isVerboseE2ERun()) {
|
|
output.log({
|
|
title: `Original command: ${fullCommand}`,
|
|
bodyLines: [logs as string],
|
|
color: 'green',
|
|
});
|
|
}
|
|
const r = stripVTControlCharacters(logs);
|
|
|
|
return r;
|
|
} catch (e) {
|
|
if (e.killed || e.signal) {
|
|
const timeoutSec = Math.round(timeoutMs / 1000);
|
|
const processOutput = stripVTControlCharacters(
|
|
`${e.stdout ?? ''}\n\n${e.stderr ?? ''}`
|
|
).trim();
|
|
const msg = `Command timed out after ${timeoutSec}s: ${command}\n\nProcess output:\n${processOutput}`;
|
|
logError(`Command timed out`, msg);
|
|
throw new Error(msg);
|
|
}
|
|
if (opts.silenceError) {
|
|
return stripVTControlCharacters(e.stdout + e.stderr);
|
|
} else {
|
|
logError(`Original command: ${command}`, `${e.stdout}\n\n${e.stderr}`);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
export function waitUntil(
|
|
predicate: () => boolean,
|
|
opts: { timeout: number; ms: number; allowError?: boolean } = {
|
|
timeout: 5000,
|
|
ms: 50,
|
|
}
|
|
): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const t = setInterval(() => {
|
|
const run = () => {};
|
|
try {
|
|
run();
|
|
if (predicate()) {
|
|
clearInterval(t);
|
|
resolve();
|
|
}
|
|
} catch (e) {
|
|
if (opts.allowError) reject(e);
|
|
}
|
|
}, opts.ms);
|
|
|
|
setTimeout(() => {
|
|
clearInterval(t);
|
|
reject(new Error(`Timed out waiting for condition to return true`));
|
|
}, opts.timeout);
|
|
});
|
|
}
|
|
|
|
export function isDockerAvailable() {
|
|
try {
|
|
const dockerVersionInfo = runCommand(`docker info -f json`);
|
|
return !dockerVersionInfo.includes('Cannot connect to the Docker daemon');
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|