nx 17.0.3 → 17.0.5

package/src/plugins/js/utils/register.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTsNodeCompilerOptions = exports.registerTsConfigPaths = exports.registerTranspiler = exports.getTranspiler = exports.getTsNodeTranspiler = exports.getSwcTranspiler = exports.registerTsProject = void 0;
 const path_1 = require("path");
 const logger_1 = require("../../../utils/logger");
-const fs_1 = require("fs");
-const workspace_root_1 = require("../../../utils/workspace-root");
 const swcNodeInstalled = packageIsInstalled('@swc-node/register');
 const tsNodeInstalled = packageIsInstalled('ts-node/register');
 let ts;
+let isTsEsmLoaderRegistered = false;
 function registerTsProject(path, configFilename) {
     const tsConfigPath = configFilename ? (0, path_1.join)(path, configFilename) : path;
     const compilerOptions = readCompilerOptions(tsConfigPath);
@@ -15,6 +14,18 @@ function registerTsProject(path, configFilename) {
         registerTsConfigPaths(tsConfigPath),
         registerTranspiler(compilerOptions),
     ];
+    // Add ESM support for `.ts` files.
+    // NOTE: There is no cleanup function for this, as it's not possible to unregister the loader.
+    //       Based on limited testing, it doesn't seem to matter if we register it multiple times, but just in
+    //       case let's keep a flag to prevent it.
+    if (!isTsEsmLoaderRegistered) {
+        const module = require('node:module');
+        if (module.register && packageIsInstalled('ts-node/esm')) {
+            const url = require('node:url');
+            module.register(url.pathToFileURL(require.resolve('ts-node/esm')));
+        }
+        isTsEsmLoaderRegistered = true;
+    }
     return () => {
         for (const fn of cleanupFunctions) {
             fn();
@@ -26,10 +37,6 @@ function getSwcTranspiler(compilerOptions) {
     // These are requires to prevent it from registering when it shouldn't
     const register = require('@swc-node/register/register')
         .register;
-    let rootTsConfig = (0, path_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json');
-    if ((0, fs_1.existsSync)(rootTsConfig)) {
-        process.env.SWC_NODE_PROJECT = rootTsConfig;
-    }
     const cleanupFn = register(compilerOptions);
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
@@ -40,6 +47,8 @@ function getTsNodeTranspiler(compilerOptions) {
     const service = register({
         transpileOnly: true,
         compilerOptions: getTsNodeCompilerOptions(compilerOptions),
+        // we already read and provide the compiler options, so prevent ts-node from reading them again
+        skipProject: true,
     });
     const { transpiler, swc } = service.options;
     // Don't warn if a faster transpiler is enabled
@@ -58,6 +67,9 @@ function getTranspiler(compilerOptions) {
     }
     compilerOptions.lib = ['es2021'];
     compilerOptions.module = ts.ModuleKind.CommonJS;
+    // use NodeJs module resolution until support for TS 4.x is dropped and then
+    // we can switch to Node10
+    compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
     compilerOptions.target = ts.ScriptTarget.ES2021;
     compilerOptions.inlineSourceMap = true;
     compilerOptions.skipLibCheck = true;
@@ -121,13 +133,21 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 function readCompilerOptions(tsConfigPath) {
     const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
     if (swcNodeInstalled && !preferTsNode) {
-        const { readDefaultTsConfig, } = require('@swc-node/register/read-default-tsconfig');
-        return readDefaultTsConfig(tsConfigPath);
+        return readCompilerOptionsWithSwc(tsConfigPath);
     }
     else {
         return readCompilerOptionsWithTypescript(tsConfigPath);
     }
 }
+function readCompilerOptionsWithSwc(tsConfigPath) {
+    const { readDefaultTsConfig, } = require('@swc-node/register/read-default-tsconfig');
+    const compilerOptions = readDefaultTsConfig(tsConfigPath);
+    // This is returned in compiler options for some reason, but not part of the typings.
+    // @swc-node/register filters the files to transpile based on it, but it can be limiting when processing
+    // files not part of the received tsconfig included files (e.g. shared helpers, or config files not in source, etc.).
+    delete compilerOptions.files;
+    return compilerOptions;
+}
 function readCompilerOptionsWithTypescript(tsConfigPath) {
     if (!ts) {
         ts = require('typescript');

package/src/plugins/js/versions.d.ts

@@ -1 +1 @@
-export declare const typescriptVersion = "~5.1.3";
+export declare const typescriptVersion = "~5.4.2";

package/src/plugins/js/versions.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typescriptVersion = void 0;
-exports.typescriptVersion = '~5.1.3';
+exports.typescriptVersion = '~5.4.2';

package/{plugins/package-json-workspaces.d.ts → src/plugins/package-json-workspaces/create-nodes.d.ts}

@@ -1,7 +1,7 @@
-import { NxJsonConfiguration } from '../src/config/nx-json';
-import { ProjectConfiguration } from '../src/config/workspace-json-project-json';
-import { NxPluginV2 } from '../src/utils/nx-plugin';
-import { PackageJson } from '../src/utils/package-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxPluginV2 } from '../../utils/nx-plugin';
+import { PackageJson } from '../../utils/package-json';
 export declare function getNxPackageJsonWorkspacesPlugin(root: string): NxPluginV2;
 export declare function createNodeFromPackageJson(pkgJsonPath: string, root: string): {
     projects: {

package/{plugins/package-json-workspaces.js → src/plugins/package-json-workspaces/create-nodes.js}

@@ -1,32 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.getNxPackageJsonWorkspacesPlugin = void 0;
+const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const nx_json_1 = require("../src/config/nx-json");
-const workspaces_1 = require("../src/config/workspaces");
-const fileutils_1 = require("../src/utils/fileutils");
-const globs_1 = require("../src/utils/globs");
-const logger_1 = require("../src/utils/logger");
-const output_1 = require("../src/utils/output");
-const package_json_1 = require("../src/utils/package-json");
-const path_1 = require("../src/utils/path");
+const nx_json_1 = require("../../config/nx-json");
+const workspaces_1 = require("../../config/workspaces");
+const fileutils_1 = require("../../utils/fileutils");
+const globs_1 = require("../../utils/globs");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const package_json_1 = require("../../utils/package-json");
+const path_1 = require("../../utils/path");
 function getNxPackageJsonWorkspacesPlugin(root) {
     const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, f));
+    const patterns = getGlobPatternsFromPackageManagerWorkspaces(root, readJson);
+    // If the user only specified a negative pattern, we should find all package.json
+    // files and only return those that don't match a negative pattern.
+    const negativePatterns = patterns.filter((p) => p.startsWith('!'));
+    let positivePatterns = patterns.filter((p) => !p.startsWith('!'));
+    if (
+    // There are some negative patterns
+    negativePatterns.length > 0 &&
+        // No positive patterns
+        (positivePatterns.length === 0 ||
+            // Or only a single positive pattern that is the default coming from root package
+            (positivePatterns.length === 1 && positivePatterns[0] === 'package.json'))) {
+        positivePatterns.push('**/package.json');
+    }
     return {
-        name: 'nx-core-build-package-json-nodes',
+        name: 'nx/core/package-json-workspaces',
         createNodes: [
-            (0, globs_1.combineGlobPatterns)(getGlobPatternsFromPackageManagerWorkspaces(root, readJson)),
-            (p) => createNodeFromPackageJson(p, root),
+            (0, globs_1.combineGlobPatterns)(positivePatterns),
+            (p) => {
+                if (!negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative))) {
+                    return createNodeFromPackageJson(p, root);
+                }
+                // A negative pattern matched, so we should not create a node for this package.json
+                return {};
+            },
         ],
     };
 }
 exports.getNxPackageJsonWorkspacesPlugin = getNxPackageJsonWorkspacesPlugin;
 function createNodeFromPackageJson(pkgJsonPath, root) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, pkgJsonPath));
+    const project = buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root));
     return {
         projects: {
-            [json.name]: buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root)),
+            [project.root]: project,
         },
     };
 }

package/src/plugins/package-json-workspaces/index.d.ts

@@ -0,0 +1 @@
+export * from './create-nodes';

package/src/plugins/package-json-workspaces/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./create-nodes"), exports);

package/src/plugins/project-json/build-nodes/package-json-next-to-project-json.d.ts

@@ -0,0 +1,2 @@
+import { NxPluginV2 } from '../../../utils/nx-plugin';
+export declare const PackageJsonProjectsNextToProjectJsonPlugin: NxPluginV2;

package/src/plugins/project-json/build-nodes/package-json-next-to-project-json.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageJsonProjectsNextToProjectJsonPlugin = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const fileutils_1 = require("../../../utils/fileutils");
+const package_json_1 = require("../../../utils/package-json");
+// TODO: Remove this one day, this should not need to be done.
+exports.PackageJsonProjectsNextToProjectJsonPlugin = {
+    // Its not a problem if plugins happen to have same name, and this
+    // will look least confusing in the source map.
+    name: 'nx/core/package-json',
+    createNodes: [
+        '{project.json,**/project.json}',
+        (file, _, { workspaceRoot }) => {
+            const project = createProjectFromPackageJsonNextToProjectJson(file, workspaceRoot);
+            return project
+                ? {
+                    projects: {
+                        [project.name]: project,
+                    },
+                }
+                : {};
+        },
+    ],
+};
+function createProjectFromPackageJsonNextToProjectJson(projectJsonPath, workspaceRoot) {
+    const root = (0, path_1.dirname)(projectJsonPath);
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        let { nx, name } = packageJson;
+        return {
+            ...nx,
+            name,
+            root,
+            targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson),
+        };
+    }
+    catch (e) {
+        console.log(e);
+        return null;
+    }
+}

package/src/plugins/project-json/build-nodes/project-json.d.ts

@@ -1,7 +1,4 @@
-import { ProjectConfiguration, TargetConfiguration } from '../../../config/workspace-json-project-json';
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
 import { NxPluginV2 } from '../../../utils/nx-plugin';
-import { PackageJson } from '../../../utils/package-json';
-export declare const CreateProjectJsonProjectsPlugin: NxPluginV2;
+export declare const ProjectJsonProjectsPlugin: NxPluginV2;
 export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;
-export declare function mergePackageJsonConfigurationWithProjectJson(p: ProjectConfiguration, root: string): void;
-export declare function mergeNpmScriptsWithTargets(packageJson: PackageJson, targets: Record<string, TargetConfiguration>): Record<string, TargetConfiguration>;

package/src/plugins/project-json/build-nodes/project-json.js

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeNpmScriptsWithTargets = exports.mergePackageJsonConfigurationWithProjectJson = exports.buildProjectFromProjectJson = exports.CreateProjectJsonProjectsPlugin = void 0;
+exports.buildProjectFromProjectJson = exports.ProjectJsonProjectsPlugin = void 0;
 const node_path_1 = require("node:path");
-const node_fs_1 = require("node:fs");
 const workspaces_1 = require("../../../config/workspaces");
 const fileutils_1 = require("../../../utils/fileutils");
-const package_json_1 = require("../../../utils/package-json");
-exports.CreateProjectJsonProjectsPlugin = {
-    name: 'nx-core-build-project-json-nodes',
+exports.ProjectJsonProjectsPlugin = {
+    name: 'nx/core/project-json',
     createNodes: [
         '{project.json,**/project.json}',
-        (file, _, context) => {
-            const root = context.workspaceRoot;
-            const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, file));
+        (file, _, { workspaceRoot }) => {
+            const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, file));
             const project = buildProjectFromProjectJson(json, file);
-            mergePackageJsonConfigurationWithProjectJson(project, root);
             return {
                 projects: {
-                    [project.name]: project,
+                    [project.root]: project,
                 },
             };
         },
@@ -31,37 +27,3 @@ function buildProjectFromProjectJson(json, path) {
     };
 }
 exports.buildProjectFromProjectJson = buildProjectFromProjectJson;
-function mergePackageJsonConfigurationWithProjectJson(p, root) {
-    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, p.root, 'package.json'))) {
-        try {
-            const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, p.root, 'package.json'));
-            p.targets = mergeNpmScriptsWithTargets(packageJson, p.targets);
-            const { nx } = packageJson;
-            if (nx?.tags) {
-                p.tags = [...(p.tags || []), ...nx.tags];
-            }
-            if (nx?.implicitDependencies) {
-                p.implicitDependencies = [
-                    ...(p.implicitDependencies || []),
-                    ...nx.implicitDependencies,
-                ];
-            }
-            if (nx?.namedInputs) {
-                p.namedInputs = { ...(p.namedInputs || {}), ...nx.namedInputs };
-            }
-        }
-        catch (e) {
-            // ignore json parser errors
-        }
-    }
-}
-exports.mergePackageJsonConfigurationWithProjectJson = mergePackageJsonConfigurationWithProjectJson;
-function mergeNpmScriptsWithTargets(packageJson, targets) {
-    try {
-        return { ...(0, package_json_1.readTargetsFromPackageJson)(packageJson), ...(targets || {}) };
-    }
-    catch (e) {
-        return targets;
-    }
-}
-exports.mergeNpmScriptsWithTargets = mergeNpmScriptsWithTargets;

package/src/plugins/target-defaults/target-defaults-plugin.d.ts

@@ -0,0 +1,66 @@
+import { TargetConfiguration } from '../../config/workspace-json-project-json';
+import { NxPluginV2 } from '../../utils/nx-plugin';
+/**
+ * This marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+export declare const ONLY_MODIFIES_EXISTING_TARGET = "NX_ONLY_MODIFIES_EXISTING_TARGET";
+/**
+ * This is used to override the source file for the target defaults plugin.
+ * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+export declare const OVERRIDE_SOURCE_FILE = "NX_OVERRIDE_SOURCE_FILE";
+export declare const TargetDefaultsPlugin: NxPluginV2;
+/**
+ * This fn gets target info that would make a target uniquely compatible
+ * with what is described by project.json or package.json. As the merge process
+ * for config happens, without this, the target defaults may be compatible
+ * with a config from a plugin and then that combined target be incompatible
+ * with the project json configuration resulting in the target default values
+ * being scrapped. By adding enough information from the project.json / package.json,
+ * we can make sure that the target after merging is compatible with the defined target.
+ */
+export declare function getTargetInfo(target: string, projectJsonTargets: Record<string, TargetConfiguration>, packageJsonTargets: Record<string, TargetConfiguration>): {
+    command: string;
+    executor?: undefined;
+    options?: undefined;
+} | {
+    executor: string;
+    options: {
+        command: any;
+        commands?: undefined;
+        script?: undefined;
+    };
+    command?: undefined;
+} | {
+    executor: string;
+    options: {
+        commands: any;
+        command?: undefined;
+        script?: undefined;
+    };
+    command?: undefined;
+} | {
+    executor: string;
+    command?: undefined;
+    options?: undefined;
+} | {
+    executor: string;
+    options: {
+        script: any;
+        command?: undefined;
+        commands?: undefined;
+    };
+    command?: undefined;
+} | {
+    command?: undefined;
+    executor?: undefined;
+    options?: undefined;
+};

package/src/plugins/target-defaults/target-defaults-plugin.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetInfo = exports.TargetDefaultsPlugin = exports.OVERRIDE_SOURCE_FILE = exports.ONLY_MODIFIES_EXISTING_TARGET = void 0;
+const minimatch_1 = require("minimatch");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../utils/fileutils");
+const globs_1 = require("../../utils/globs");
+const package_json_1 = require("../../utils/package-json");
+const package_json_workspaces_1 = require("../package-json-workspaces");
+/**
+ * This marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+exports.ONLY_MODIFIES_EXISTING_TARGET = 'NX_ONLY_MODIFIES_EXISTING_TARGET';
+/**
+ * This is used to override the source file for the target defaults plugin.
+ * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+exports.OVERRIDE_SOURCE_FILE = 'NX_OVERRIDE_SOURCE_FILE';
+exports.TargetDefaultsPlugin = {
+    name: 'nx/core/target-defaults',
+    createNodes: [
+        '{package.json,**/package.json,project.json,**/project.json}',
+        (configFile, _, ctx) => {
+            const fileName = (0, node_path_1.basename)(configFile);
+            const root = (0, node_path_1.dirname)(configFile);
+            const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(ctx.workspaceRoot));
+            // Only process once if package.json + project.json both exist
+            if (fileName === 'package.json' &&
+                (0, node_fs_1.existsSync)((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'))) {
+                return {};
+            }
+            else if (fileName === 'package.json' &&
+                !(0, minimatch_1.minimatch)(configFile, packageManagerWorkspacesGlob)) {
+                return {};
+            }
+            // If no target defaults, this does nothing
+            const targetDefaults = ctx.nxJsonConfiguration?.targetDefaults;
+            if (!targetDefaults) {
+                return {};
+            }
+            const projectJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'project.json'));
+            const packageJson = readJsonOrNull((0, node_path_1.join)(ctx.workspaceRoot, root, 'package.json'));
+            const packageJsonTargets = (0, package_json_1.readTargetsFromPackageJson)(packageJson);
+            const projectDefinedTargets = new Set([
+                ...Object.keys(projectJson?.targets ?? {}),
+                ...(packageJson ? Object.keys(packageJsonTargets) : []),
+            ]);
+            const executorToTargetMap = getExecutorToTargetMap(packageJsonTargets, projectJson?.targets);
+            const modifiedTargets = {};
+            for (const defaultSpecifier in targetDefaults) {
+                const targetNames = executorToTargetMap.get(defaultSpecifier) ?? new Set();
+                targetNames.add(defaultSpecifier);
+                for (const targetName of targetNames) {
+                    // Prevents `build` from overwriting `@nx/js:tsc` if both are present
+                    // and build is specified later in the ordering.
+                    if (!modifiedTargets[targetName] || targetName !== defaultSpecifier) {
+                        const defaults = JSON.parse(JSON.stringify(targetDefaults[defaultSpecifier]));
+                        modifiedTargets[targetName] = {
+                            ...getTargetInfo(targetName, projectJson?.targets, packageJsonTargets),
+                            ...defaults,
+                        };
+                    }
+                    // TODO: Remove this after we figure out a way to define new targets
+                    // in target defaults
+                    if (!projectDefinedTargets.has(targetName)) {
+                        modifiedTargets[targetName][exports.ONLY_MODIFIES_EXISTING_TARGET] = true;
+                    }
+                }
+            }
+            return {
+                projects: {
+                    [root]: {
+                        targets: modifiedTargets,
+                    },
+                },
+                [exports.OVERRIDE_SOURCE_FILE]: 'nx.json',
+            };
+        },
+    ],
+};
+function getExecutorToTargetMap(packageJsonTargets, projectJsonTargets) {
+    const executorToTargetMap = new Map();
+    const targets = Object.keys({
+        ...projectJsonTargets,
+        ...packageJsonTargets,
+    });
+    for (const target of targets) {
+        const executor = getTargetExecutor(target, projectJsonTargets, packageJsonTargets);
+        const targetsForExecutor = executorToTargetMap.get(executor) ?? new Set();
+        targetsForExecutor.add(target);
+        executorToTargetMap.set(executor, targetsForExecutor);
+    }
+    return executorToTargetMap;
+}
+function readJsonOrNull(path) {
+    if ((0, node_fs_1.existsSync)(path)) {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * This fn gets target info that would make a target uniquely compatible
+ * with what is described by project.json or package.json. As the merge process
+ * for config happens, without this, the target defaults may be compatible
+ * with a config from a plugin and then that combined target be incompatible
+ * with the project json configuration resulting in the target default values
+ * being scrapped. By adding enough information from the project.json / package.json,
+ * we can make sure that the target after merging is compatible with the defined target.
+ */
+function getTargetInfo(target, projectJsonTargets, packageJsonTargets) {
+    const projectJsonTarget = projectJsonTargets?.[target];
+    const packageJsonTarget = packageJsonTargets?.[target];
+    const executor = getTargetExecutor(target, projectJsonTargets, packageJsonTargets);
+    const targetOptions = {
+        ...packageJsonTarget?.options,
+        ...projectJsonTarget?.options,
+    };
+    if (projectJsonTarget?.command) {
+        return {
+            command: projectJsonTarget?.command,
+        };
+    }
+    if (executor === 'nx:run-commands') {
+        if (targetOptions?.command) {
+            return {
+                executor: 'nx:run-commands',
+                options: {
+                    command: targetOptions?.command,
+                },
+            };
+        }
+        else if (targetOptions?.commands) {
+            return {
+                executor: 'nx:run-commands',
+                options: {
+                    commands: targetOptions.commands,
+                },
+            };
+        }
+        return {
+            executor: 'nx:run-commands',
+        };
+    }
+    if (executor === 'nx:run-script') {
+        return {
+            executor: 'nx:run-script',
+            options: {
+                script: targetOptions?.script ?? target,
+            },
+        };
+    }
+    if (executor) {
+        return { executor };
+    }
+    return {};
+}
+exports.getTargetInfo = getTargetInfo;
+function getTargetExecutor(target, projectJsonTargets, packageJsonTargets) {
+    const projectJsonTargetConfiguration = projectJsonTargets?.[target];
+    const packageJsonTargetConfiguration = packageJsonTargets?.[target];
+    if (!projectJsonTargetConfiguration && packageJsonTargetConfiguration) {
+        return packageJsonTargetConfiguration?.executor;
+    }
+    if (projectJsonTargetConfiguration?.executor) {
+        return projectJsonTargetConfiguration.executor;
+    }
+    if (projectJsonTargetConfiguration?.command) {
+        return 'nx:run-commands';
+    }
+    return null;
+}

package/src/project-graph/affected/locators/project-glob-changes.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromProjectGlobChanges = void 0;
-const minimatch = require("minimatch");
+const minimatch_1 = require("minimatch");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const installation_directory_1 = require("../../../utils/installation-directory");
 const path_1 = require("path");
@@ -10,10 +10,10 @@ const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files
 const nx_plugin_1 = require("../../../utils/nx-plugin");
 const globs_1 = require("../../../utils/globs");
 const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes, nxJson) => {
-    const globPattern = (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(workspace_root_1.workspaceRoot, await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins, (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot)));
+    const globPattern = (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins, (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot)));
     const touchedProjects = new Set();
     for (const touchedFile of touchedFiles) {
-        const isProjectFile = minimatch(touchedFile.file, globPattern, {
+        const isProjectFile = (0, minimatch_1.minimatch)(touchedFile.file, globPattern, {
             dot: true,
         });
         if (isProjectFile) {

package/src/project-graph/affected/locators/workspace-projects.d.ts

@@ -1,5 +1,3 @@
 import { TouchedProjectLocator } from '../affected-project-graph-models';
-import { NxJsonConfiguration } from '../../../config/nx-json';
 export declare const getTouchedProjects: TouchedProjectLocator;
 export declare const getImplicitlyTouchedProjects: TouchedProjectLocator;
-export declare function extractGlobalFilesFromInputs(nxJson: NxJsonConfiguration): any[];