@aws/pdk
Version:
All documentation is located at: https://aws.github.io/aws-pdk
376 lines • 55.6 kB
JavaScript
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.NxConfigurator = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
/*! Copyright [Amazon.com](http://amazon.com/), Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0 */
const path = require("path");
const projen_1 = require("projen");
const java_1 = require("projen/lib/java");
const javascript_1 = require("projen/lib/javascript");
const python_1 = require("projen/lib/python");
const nx_project_1 = require("./nx-project");
const nx_workspace_1 = require("./nx-workspace");
const utils_1 = require("../utils");
const DEFAULT_PYTHON_VERSION = "3";
const DEFAULT_LICENSE = "Apache-2.0";
/**
* Configues common NX related tasks and methods.
*/
class NxConfigurator extends projen_1.Component {
constructor(project, options) {
super(project);
this.nxPlugins = {};
project.addGitIgnore(".nx/*");
project.addGitIgnore("!.nx/plugins");
project.addTask("run-many", {
receiveArgs: true,
exec: utils_1.NodePackageUtils.command.exec(utils_1.NodePackageUtils.getNodePackageManager(this.project, javascript_1.NodePackageManager.NPM), "nx", "run-many"),
description: "Run task against multiple workspace projects",
});
project.addTask("graph", {
receiveArgs: true,
exec: utils_1.NodePackageUtils.command.exec(utils_1.NodePackageUtils.getNodePackageManager(this.project, javascript_1.NodePackageManager.NPM), "nx", "graph"),
description: "Generate dependency graph for monorepo",
});
this.licenseOptions = options?.licenseOptions;
this.nx = nx_workspace_1.NxWorkspace.of(project) || new nx_workspace_1.NxWorkspace(project);
this.nx.affected.defaultBase = options?.defaultReleaseBranch ?? "mainline";
}
patchPoetryEnv(project) {
// Since the root monorepo is a poetry project and sets the VIRTUAL_ENV, and poetry env info -p will print
// the virtual env set in the VIRTUAL_ENV variable if set, we need to unset it to ensure the local project's
// env is used.
if (utils_1.ProjectUtils.isNamedInstanceOf(project.depsManager, python_1.Poetry)) {
["install", "install:ci"].forEach((t) => {
const task = project.tasks.tryFind(t);
// Setup env
const createVenvCmd = "poetry env use python$PYTHON_VERSION";
!task?.steps.find((s) => s.exec === createVenvCmd) &&
task?.prependExec(createVenvCmd);
// Ensure the projen & pdk bins are removed from the venv as we always want to use the npx variant
const removeBinsCmd = "rm -f `poetry env info -p`/bin/projen `poetry env info -p`/bin/pdk";
!task?.steps.find((s) => s.exec === removeBinsCmd) &&
task?.exec(removeBinsCmd);
const pythonVersion = project.deps.tryGetDependency("python")?.version;
task.env("PYTHON_VERSION", pythonVersion && !pythonVersion?.startsWith("^")
? pythonVersion
: `$(pyenv latest ${pythonVersion?.substring(1).split(".")[0] ||
DEFAULT_PYTHON_VERSION} | cut -d '.' -f 1,2 || echo '')`);
});
project.tasks.addEnvironment("VIRTUAL_ENV", "$(env -u VIRTUAL_ENV poetry env info -p || echo '')");
project.tasks.addEnvironment("PATH", "$(echo $(env -u VIRTUAL_ENV poetry env info -p || echo '')/bin:$PATH)");
}
}
patchPythonProjects(projects) {
projects.forEach((p) => {
if (utils_1.ProjectUtils.isNamedInstanceOf(p, python_1.PythonProject)) {
this.patchPoetryEnv(p);
}
this.patchPythonProjects(p.subprojects);
});
}
/**
* Overrides "build" related project tasks (build, compile, test, etc.) with `npx nx run-many` format.
* @param task - The task or task name to override
* @param options - Nx run-many options
* @param overrideOptions - Options for overriding the task
* @returns - The task that was overridden
* @internal
*/
_overrideNxBuildTask(task, options, overrideOptions) {
if (typeof task === "string") {
task = this.project.tasks.tryFind(task);
}
if (task == null) {
return;
}
if (overrideOptions?.force) {
// @ts-ignore - private property
task._locked = false;
}
task.reset(this.execNxRunManyCommand(options), {
receiveArgs: true,
});
task.description += " for all affected projects";
if (overrideOptions?.disableReset) {
// Prevent any further resets of the task to force it to remain as the overridden nx build task
task.reset = () => { };
}
return task;
}
/**
* Adds a command to upgrade all python subprojects to the given task
* @param monorepo the monorepo project
* @param task the task to add the command to
* @internal
*/
_configurePythonSubprojectUpgradeDeps(monorepo, task) {
// Upgrade deps for
const pythonSubprojects = monorepo.subprojects.filter((p) => utils_1.ProjectUtils.isNamedInstanceOf(p, python_1.PythonProject));
if (pythonSubprojects.length > 0) {
task.exec(this.execNxRunManyCommand({
target: "install", // TODO: remove in favour of the upgrade task if ever implemented for python
projects: pythonSubprojects.map((p) => p.name),
}), { receiveArgs: true });
}
}
/**
* Returns the install task or creates one with nx installation command added.
*
* Note: this should only be called from non-node projects
*
* @param nxPlugins additional plugins to install
* @returns install task
*/
ensureNxInstallTask(nxPlugins) {
this.nxPlugins = nxPlugins;
const installTask = this.project.tasks.tryFind("install") ?? this.project.addTask("install");
installTask.exec("pnpm i --no-frozen-lockfile");
(this.project.tasks.tryFind("install:ci") ??
this.project.addTask("install:ci")).exec("pnpm i --frozen-lockfile");
return installTask;
}
/**
* Helper to format `npx nx run-many ...` style command execution in package manager.
* @param options
*/
execNxRunManyCommand(options) {
return utils_1.NodePackageUtils.command.exec(utils_1.NodePackageUtils.getNodePackageManager(this.project, javascript_1.NodePackageManager.NPM), ...this.composeNxRunManyCommand(options));
}
/**
* Helper to format `npx nx run-many ...` style command
* @param options
*/
composeNxRunManyCommand(options) {
const args = [];
if (options.configuration) {
args.push(`--configuration=${options.configuration}`);
}
if (options.runner) {
args.push(`--runner=${options.runner}`);
}
if (options.parallel) {
args.push(`--parallel=${options.parallel}`);
}
if (options.skipCache) {
args.push("--skip-nx-cache");
}
if (options.ignoreCycles) {
args.push("--nx-ignore-cycles");
}
if (options.noBail !== true) {
args.push("--nx-bail");
}
if (options.projects && options.projects.length) {
args.push(`--projects=${options.projects.join(",")}`);
}
if (options.exclude) {
args.push(`--exclude=${options.exclude}`);
}
if (options.verbose) {
args.push("--verbose");
}
return [
"nx",
"run-many",
`--target=${options.target}`,
`--output-style=${options.outputStyle || "stream"}`,
...args,
];
}
/**
* Add project task that executes `npx nx run-many ...` style command.
*/
addNxRunManyTask(name, options) {
return this.project.addTask(name, {
receiveArgs: true,
exec: this.execNxRunManyCommand(options),
});
}
/**
* Create an implicit dependency between two Projects. This is typically
* used in polygot repos where a Typescript project wants a build dependency
* on a Python project as an example.
*
* @param dependent project you want to have the dependency.
* @param dependee project you wish to depend on.
* @throws error if this is called on a dependent which does not have a NXProject component attached.
*/
addImplicitDependency(dependent, dependee) {
nx_project_1.NxProject.ensure(dependent).addImplicitDependency(dependee);
}
/**
* Adds a dependency between two Java Projects in the monorepo.
* @param dependent project you want to have the dependency
* @param dependee project you wish to depend on
*/
addJavaDependency(dependent, dependee) {
nx_project_1.NxProject.ensure(dependent).addJavaDependency(dependee);
}
/**
* Adds a dependency between two Python Projects in the monorepo. The dependent must have Poetry enabled.
* @param dependent project you want to have the dependency (must be a Poetry Python Project)
* @param dependee project you wish to depend on
* @throws error if the dependent does not have Poetry enabled
*/
addPythonPoetryDependency(dependent, dependee) {
nx_project_1.NxProject.ensure(dependent).addPythonPoetryDependency(dependee);
}
/**
* Ensures that all non-root projects have NxProject applied.
* @internal
*/
_ensureNxProjectGraph() {
function _ensure(_project) {
if (_project.root === _project)
return;
nx_project_1.NxProject.ensure(_project);
_project.subprojects.forEach((p) => {
_ensure(p);
});
}
this.project.subprojects.forEach(_ensure);
}
/**
* Emits package.json for non-node NX monorepos.
* @internal
*/
_emitPackageJson() {
if (!utils_1.ProjectUtils.isNamedInstanceOf(this.project, javascript_1.NodeProject) &&
!this.project.tryFindFile("package.json")) {
new projen_1.JsonFile(this.project, "package.json", {
obj: {
devDependencies: {
...this.nxPlugins,
nx: "19.8.14",
"@nx/devkit": "19.8.14",
},
private: true,
engines: {
node: ">=16",
pnpm: ">=8",
},
scripts: Object.fromEntries(this.project.tasks.all
.filter((t) => t.name !== "install")
.map((c) => [
c.name,
!this.project.ejected
? utils_1.NodePackageUtils.command.projen(javascript_1.NodePackageManager.PNPM, c.name)
: `scripts/run-task ${c.name}`,
])),
},
}).synthesize();
}
if (!utils_1.ProjectUtils.isNamedInstanceOf(this.project, javascript_1.NodeProject) &&
!this.project.tryFindFile("pnpm-workspace.yaml")) {
new projen_1.YamlFile(this.project, "pnpm-workspace.yaml", {
obj: {
packages: this.project.subprojects
.filter((p) => utils_1.ProjectUtils.isNamedInstanceOf(p, javascript_1.NodeProject))
.map((p) => path.relative(this.project.outdir, p.outdir)),
},
}).synthesize();
}
if (!utils_1.ProjectUtils.isNamedInstanceOf(this.project, javascript_1.NodeProject) &&
!this.project.tryFindFile(".npmrc")) {
new projen_1.IniFile(this.project, ".npmrc", {
obj: {
"resolution-mode": "highest",
yes: "true",
"prefer-workspace-packages": "true",
"link-workspace-packages": "true",
},
}).synthesize();
}
else if (utils_1.ProjectUtils.isNamedInstanceOf(this.project, javascript_1.NodeProject) &&
this.project.package.packageManager === javascript_1.NodePackageManager.PNPM) {
this.project.npmrc.addConfig("prefer-workspace-packages", "true");
this.project.npmrc.addConfig("link-workspace-packages", "true");
this.project.npmrc.addConfig("yes", "true");
}
}
_invokeInstallCITasks() {
const cmd = utils_1.NodePackageUtils.command.exec(utils_1.ProjectUtils.isNamedInstanceOf(this.project, javascript_1.NodeProject)
? this.project.package.packageManager
: javascript_1.NodePackageManager.NPM, ...this.composeNxRunManyCommand({
target: "install:ci",
}));
const task = this.project.tasks.tryFind("install:ci");
task?.steps?.length &&
task.steps.length > 0 &&
!task?.steps.find((s) => s.exec === cmd) &&
task?.exec(cmd, { receiveArgs: true });
}
/**
* Add licenses to any subprojects which don't already have a license.
*/
_addLicenses() {
[this.project, ...this.project.subprojects]
.filter(() => !this.licenseOptions?.disableDefaultLicenses)
.forEach((p) => {
p.tryRemoveFile("LICENSE");
if (!this.licenseOptions) {
new projen_1.License(p, {
spdx: DEFAULT_LICENSE,
});
if (utils_1.ProjectUtils.isNamedInstanceOf(p, java_1.JavaProject)) {
// Force all Java projects to use Apache 2.0
p.tryFindObjectFile("pom.xml")?.addOverride("project.licenses", [
{
license: {
name: "Apache License 2.0",
url: "https://www.apache.org/licenses/LICENSE-2.0",
distribution: "repo",
comments: "An OSI-approved license",
},
},
]);
}
}
else if (!!this.licenseOptions?.licenseText) {
new projen_1.TextFile(p, "LICENSE", {
marker: false,
committed: true,
lines: this.licenseOptions.licenseText.split("\n"),
});
}
else if (this.licenseOptions.spdx) {
new projen_1.License(p, {
spdx: this.licenseOptions.spdx,
copyrightOwner: this.licenseOptions?.copyrightOwner,
});
}
else {
throw new Error("Either spdx or licenseText must be specified.");
}
});
}
preSynthesize() {
this._ensureNxProjectGraph();
this._emitPackageJson();
this._invokeInstallCITasks();
this.patchPythonProjects([this.project]);
this._addLicenses();
}
/**
* @inheritDoc
*/
synth() {
this.resetDefaultTask();
}
/**
* Ensures subprojects don't have a default task
*/
resetDefaultTask() {
this.project.subprojects.forEach((subProject) => {
// Disable default task on subprojects as this isn't supported in a monorepo
subProject.defaultTask?.reset();
});
}
}
exports.NxConfigurator = NxConfigurator;
_a = JSII_RTTI_SYMBOL_1;
NxConfigurator[_a] = { fqn: "@aws/pdk.monorepo.NxConfigurator", version: "0.26.14" };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nx-configurator.js","sourceRoot":"","sources":["nx-configurator.ts"],"names":[],"mappings":"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","sourcesContent":["/*! Copyright [Amazon.com](http://amazon.com/), Inc. or its affiliates. All Rights Reserved.\nSPDX-License-Identifier: Apache-2.0 */\nimport * as path from \"path\";\nimport {\n  Component,\n  IniFile,\n  JsonFile,\n  License,\n  Project,\n  Task,\n  TextFile,\n  YamlFile,\n} from \"projen\";\nimport { JavaProject } from \"projen/lib/java\";\nimport { NodePackageManager, NodeProject } from \"projen/lib/javascript\";\nimport { Poetry, PythonProject } from \"projen/lib/python\";\nimport { NxProject } from \"./nx-project\";\nimport { NxWorkspace } from \"./nx-workspace\";\nimport { Nx } from \"../nx-types\";\nimport { NodePackageUtils, ProjectUtils } from \"../utils\";\n\nconst DEFAULT_PYTHON_VERSION = \"3\";\nconst DEFAULT_LICENSE = \"Apache-2.0\";\n\n/**\n * Options for overriding nx build tasks\n * @internal\n */\ninterface OverrideNxBuildTaskOptions {\n  /**\n   * Force unlocking task (eg: build task is locked)\n   */\n  readonly force?: boolean;\n  /**\n   * Disable further resets of the task by other components in further lifecycle stages\n   * (eg eslint resets during preSynthesize)\n   */\n  readonly disableReset?: boolean;\n}\n\n/**\n * Interface that all NXProject implementations should implement.\n */\nexport interface INxProjectCore {\n  /**\n   * Return the NxWorkspace instance. This should be implemented using a getter.\n   */\n  readonly nx: NxWorkspace;\n\n  /**\n   * Helper to format `npx nx run-many ...` style command execution in package manager.\n   * @param options\n   */\n  execNxRunManyCommand(options: Nx.RunManyOptions): string;\n\n  /**\n   * Helper to format `npx nx run-many ...` style command\n   * @param options\n   */\n  composeNxRunManyCommand(options: Nx.RunManyOptions): string[];\n\n  /**\n   * Add project task that executes `npx nx run-many ...` style command.\n   *\n   * @param name task name\n   * @param options options\n   */\n  addNxRunManyTask(name: string, options: Nx.RunManyOptions): Task;\n\n  /**\n   * Create an implicit dependency between two Projects. This is typically\n   * used in polygot repos where a Typescript project wants a build dependency\n   * on a Python project as an example.\n   *\n   * @param dependent project you want to have the dependency.\n   * @param dependee project you wish to depend on.\n   * @throws error if this is called on a dependent which does not have a NXProject component attached.\n   */\n  addImplicitDependency(dependent: Project, dependee: Project | string): void;\n\n  /**\n   * Adds a dependency between two Java Projects in the monorepo.\n   * @param dependent project you want to have the dependency\n   * @param dependee project you wish to depend on\n   */\n  addJavaDependency(dependent: JavaProject, dependee: JavaProject): void;\n\n  /**\n   * Adds a dependency between two Python Projects in the monorepo. The dependent must have Poetry enabled.\n   * @param dependent project you want to have the dependency (must be a Poetry Python Project)\n   * @param dependee project you wish to depend on\n   * @throws error if the dependent does not have Poetry enabled\n   */\n  addPythonPoetryDependency(\n    dependent: PythonProject,\n    dependee: PythonProject\n  ): void;\n}\n\n/**\n * License options.\n *\n */\nexport interface LicenseOptions {\n  /**\n   * License type (SPDX).\n   *\n   * @see https://github.com/projen/projen/tree/main/license-text for list of supported licenses\n   */\n  readonly spdx?: string;\n\n  /**\n   * Copyright owner.\n   *\n   * If the license text for the given spdx has $copyright_owner, this option must be specified.\n   */\n  readonly copyrightOwner?: string;\n\n  /**\n   * Arbitrary license text.\n   */\n  readonly licenseText?: string;\n\n  /**\n   * Whether to disable the generation of default licenses.\n   *\n   * @default false\n   */\n  readonly disableDefaultLicenses?: boolean;\n}\n\n/**\n * NXConfigurator options.\n */\nexport interface NxConfiguratorOptions {\n  /**\n   * Branch that NX affected should run against.\n   */\n  readonly defaultReleaseBranch?: string;\n\n  /**\n   * Default package license config.\n   *\n   * If nothing is specified, all packages will default to Apache-2.0 (unless they have their own License component).\n   */\n  readonly licenseOptions?: LicenseOptions;\n}\n\n/**\n * Configues common NX related tasks and methods.\n */\nexport class NxConfigurator extends Component implements INxProjectCore {\n  public readonly nx: NxWorkspace;\n  private readonly licenseOptions?: LicenseOptions;\n  private nxPlugins: { [dep: string]: string } = {};\n\n  constructor(project: Project, options?: NxConfiguratorOptions) {\n    super(project);\n    project.addGitIgnore(\".nx/*\");\n    project.addGitIgnore(\"!.nx/plugins\");\n    project.addTask(\"run-many\", {\n      receiveArgs: true,\n      exec: NodePackageUtils.command.exec(\n        NodePackageUtils.getNodePackageManager(\n          this.project,\n          NodePackageManager.NPM\n        ),\n        \"nx\",\n        \"run-many\"\n      ),\n      description: \"Run task against multiple workspace projects\",\n    });\n\n    project.addTask(\"graph\", {\n      receiveArgs: true,\n      exec: NodePackageUtils.command.exec(\n        NodePackageUtils.getNodePackageManager(\n          this.project,\n          NodePackageManager.NPM\n        ),\n        \"nx\",\n        \"graph\"\n      ),\n      description: \"Generate dependency graph for monorepo\",\n    });\n\n    this.licenseOptions = options?.licenseOptions;\n    this.nx = NxWorkspace.of(project) || new NxWorkspace(project);\n    this.nx.affected.defaultBase = options?.defaultReleaseBranch ?? \"mainline\";\n  }\n\n  public patchPoetryEnv(project: PythonProject): void {\n    // Since the root monorepo is a poetry project and sets the VIRTUAL_ENV, and poetry env info -p will print\n    // the virtual env set in the VIRTUAL_ENV variable if set, we need to unset it to ensure the local project's\n    // env is used.\n    if (ProjectUtils.isNamedInstanceOf(project.depsManager as any, Poetry)) {\n      [\"install\", \"install:ci\"].forEach((t) => {\n        const task = project.tasks.tryFind(t);\n\n        // Setup env\n        const createVenvCmd = \"poetry env use python$PYTHON_VERSION\";\n        !task?.steps.find((s) => s.exec === createVenvCmd) &&\n          task?.prependExec(createVenvCmd);\n\n        // Ensure the projen & pdk bins are removed from the venv as we always want to use the npx variant\n        const removeBinsCmd =\n          \"rm -f `poetry env info -p`/bin/projen `poetry env info -p`/bin/pdk\";\n        !task?.steps.find((s) => s.exec === removeBinsCmd) &&\n          task?.exec(removeBinsCmd);\n\n        const pythonVersion = project.deps.tryGetDependency(\"python\")?.version;\n        task!.env(\n          \"PYTHON_VERSION\",\n          pythonVersion && !pythonVersion?.startsWith(\"^\")\n            ? pythonVersion\n            : `$(pyenv latest ${\n                pythonVersion?.substring(1).split(\".\")[0] ||\n                DEFAULT_PYTHON_VERSION\n              } | cut -d '.' -f 1,2 || echo '')`\n        );\n      });\n\n      project.tasks.addEnvironment(\n        \"VIRTUAL_ENV\",\n        \"$(env -u VIRTUAL_ENV poetry env info -p || echo '')\"\n      );\n      project.tasks.addEnvironment(\n        \"PATH\",\n        \"$(echo $(env -u VIRTUAL_ENV poetry env info -p || echo '')/bin:$PATH)\"\n      );\n    }\n  }\n\n  public patchPythonProjects(projects: Project[]): void {\n    projects.forEach((p) => {\n      if (ProjectUtils.isNamedInstanceOf(p, PythonProject)) {\n        this.patchPoetryEnv(p);\n      }\n      this.patchPythonProjects(p.subprojects);\n    });\n  }\n\n  /**\n   * Overrides \"build\" related project tasks (build, compile, test, etc.) with `npx nx run-many` format.\n   * @param task - The task or task name to override\n   * @param options - Nx run-many options\n   * @param overrideOptions - Options for overriding the task\n   * @returns - The task that was overridden\n   * @internal\n   */\n  public _overrideNxBuildTask(\n    task: Task | string | undefined,\n    options: Nx.RunManyOptions,\n    overrideOptions?: OverrideNxBuildTaskOptions\n  ): Task | undefined {\n    if (typeof task === \"string\") {\n      task = this.project.tasks.tryFind(task);\n    }\n\n    if (task == null) {\n      return;\n    }\n\n    if (overrideOptions?.force) {\n      // @ts-ignore - private property\n      task._locked = false;\n    }\n\n    task.reset(this.execNxRunManyCommand(options), {\n      receiveArgs: true,\n    });\n\n    task.description += \" for all affected projects\";\n\n    if (overrideOptions?.disableReset) {\n      // Prevent any further resets of the task to force it to remain as the overridden nx build task\n      task.reset = () => {};\n    }\n\n    return task;\n  }\n\n  /**\n   * Adds a command to upgrade all python subprojects to the given task\n   * @param monorepo the monorepo project\n   * @param task the task to add the command to\n   * @internal\n   */\n  public _configurePythonSubprojectUpgradeDeps(monorepo: Project, task: Task) {\n    // Upgrade deps for\n    const pythonSubprojects = monorepo.subprojects.filter((p) =>\n      ProjectUtils.isNamedInstanceOf(p, PythonProject)\n    );\n    if (pythonSubprojects.length > 0) {\n      task.exec(\n        this.execNxRunManyCommand({\n          target: \"install\", // TODO: remove in favour of the upgrade task if ever implemented for python\n          projects: pythonSubprojects.map((p) => p.name),\n        }),\n        { receiveArgs: true }\n      );\n    }\n  }\n\n  /**\n   * Returns the install task or creates one with nx installation command added.\n   *\n   * Note: this should only be called from non-node projects\n   *\n   * @param nxPlugins additional plugins to install\n   * @returns install task\n   */\n  public ensureNxInstallTask(nxPlugins: { [key: string]: string }): Task {\n    this.nxPlugins = nxPlugins;\n\n    const installTask =\n      this.project.tasks.tryFind(\"install\") ?? this.project.addTask(\"install\");\n    installTask.exec(\"pnpm i --no-frozen-lockfile\");\n\n    (\n      this.project.tasks.tryFind(\"install:ci\") ??\n      this.project.addTask(\"install:ci\")\n    ).exec(\"pnpm i --frozen-lockfile\");\n\n    return installTask;\n  }\n\n  /**\n   * Helper to format `npx nx run-many ...` style command execution in package manager.\n   * @param options\n   */\n  public execNxRunManyCommand(options: Nx.RunManyOptions): string {\n    return NodePackageUtils.command.exec(\n      NodePackageUtils.getNodePackageManager(\n        this.project,\n        NodePackageManager.NPM\n      ),\n      ...this.composeNxRunManyCommand(options)\n    );\n  }\n\n  /**\n   * Helper to format `npx nx run-many ...` style command\n   * @param options\n   */\n  public composeNxRunManyCommand(options: Nx.RunManyOptions): string[] {\n    const args: string[] = [];\n    if (options.configuration) {\n      args.push(`--configuration=${options.configuration}`);\n    }\n    if (options.runner) {\n      args.push(`--runner=${options.runner}`);\n    }\n    if (options.parallel) {\n      args.push(`--parallel=${options.parallel}`);\n    }\n    if (options.skipCache) {\n      args.push(\"--skip-nx-cache\");\n    }\n    if (options.ignoreCycles) {\n      args.push(\"--nx-ignore-cycles\");\n    }\n    if (options.noBail !== true) {\n      args.push(\"--nx-bail\");\n    }\n    if (options.projects && options.projects.length) {\n      args.push(`--projects=${options.projects.join(\",\")}`);\n    }\n    if (options.exclude) {\n      args.push(`--exclude=${options.exclude}`);\n    }\n    if (options.verbose) {\n      args.push(\"--verbose\");\n    }\n\n    return [\n      \"nx\",\n      \"run-many\",\n      `--target=${options.target}`,\n      `--output-style=${options.outputStyle || \"stream\"}`,\n      ...args,\n    ];\n  }\n\n  /**\n   * Add project task that executes `npx nx run-many ...` style command.\n   */\n  public addNxRunManyTask(name: string, options: Nx.RunManyOptions): Task {\n    return this.project.addTask(name, {\n      receiveArgs: true,\n      exec: this.execNxRunManyCommand(options),\n    });\n  }\n\n  /**\n   * Create an implicit dependency between two Projects. This is typically\n   * used in polygot repos where a Typescript project wants a build dependency\n   * on a Python project as an example.\n   *\n   * @param dependent project you want to have the dependency.\n   * @param dependee project you wish to depend on.\n   * @throws error if this is called on a dependent which does not have a NXProject component attached.\n   */\n  public addImplicitDependency(dependent: Project, dependee: Project | string) {\n    NxProject.ensure(dependent).addImplicitDependency(dependee);\n  }\n\n  /**\n   * Adds a dependency between two Java Projects in the monorepo.\n   * @param dependent project you want to have the dependency\n   * @param dependee project you wish to depend on\n   */\n  public addJavaDependency(dependent: JavaProject, dependee: JavaProject) {\n    NxProject.ensure(dependent).addJavaDependency(dependee);\n  }\n\n  /**\n   * Adds a dependency between two Python Projects in the monorepo. The dependent must have Poetry enabled.\n   * @param dependent project you want to have the dependency (must be a Poetry Python Project)\n   * @param dependee project you wish to depend on\n   * @throws error if the dependent does not have Poetry enabled\n   */\n  public addPythonPoetryDependency(\n    dependent: PythonProject,\n    dependee: PythonProject\n  ) {\n    NxProject.ensure(dependent).addPythonPoetryDependency(dependee);\n  }\n\n  /**\n   * Ensures that all non-root projects have NxProject applied.\n   * @internal\n   */\n  protected _ensureNxProjectGraph(): void {\n    function _ensure(_project: Project) {\n      if (_project.root === _project) return;\n\n      NxProject.ensure(_project);\n\n      _project.subprojects.forEach((p) => {\n        _ensure(p);\n      });\n    }\n\n    this.project.subprojects.forEach(_ensure);\n  }\n\n  /**\n   * Emits package.json for non-node NX monorepos.\n   * @internal\n   */\n  private _emitPackageJson() {\n    if (\n      !ProjectUtils.isNamedInstanceOf(this.project, NodeProject) &&\n      !this.project.tryFindFile(\"package.json\")\n    ) {\n      new JsonFile(this.project, \"package.json\", {\n        obj: {\n          devDependencies: {\n            ...this.nxPlugins,\n            nx: \"19.8.14\",\n            \"@nx/devkit\": \"19.8.14\",\n          },\n          private: true,\n          engines: {\n            node: \">=16\",\n            pnpm: \">=8\",\n          },\n          scripts: Object.fromEntries(\n            this.project.tasks.all\n              .filter((t) => t.name !== \"install\")\n              .map((c) => [\n                c.name,\n                !this