@nx/workspace 19.8.0-canary.20240912-b6140d4 → 19.8.0-canary.20240913-5bbaffb

package/generators.json

@@ -54,6 +54,11 @@
       "factory": "./src/generators/ci-workflow/ci-workflow#ciWorkflowGenerator",
       "schema": "./src/generators/ci-workflow/schema.json",
       "description": "Generate a CI workflow."
+    },
+    "infer-targets": {
+      "factory": "./src/generators/infer-targets/infer-targets",
+      "schema": "./src/generators/infer-targets/schema.json",
+      "description": "Convert Nx projects to use inferred targets."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/workspace",
-  "version": "19.8.0-canary.20240912-b6140d4",
+  "version": "19.8.0-canary.20240913-5bbaffb",
   "private": false,
   "description": "The Workspace plugin contains executors and generators that are useful for any Nx workspace. It should be present in every Nx workspace and other plugins build on it.",
   "repository": {
@@ -61,13 +61,13 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "19.8.0-canary.20240912-b6140d4",
+    "@nx/devkit": "19.8.0-canary.20240913-5bbaffb",
     "chalk": "^4.1.0",
     "enquirer": "~2.3.6",
     "tslib": "^2.3.0",
     "yargs-parser": "21.1.1",
-    "nx": "19.8.0-canary.20240912-b6140d4",
-    "@nrwl/workspace": "19.8.0-canary.20240912-b6140d4"
+    "nx": "19.8.0-canary.20240913-5bbaffb",
+    "@nrwl/workspace": "19.8.0-canary.20240913-5bbaffb"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/infer-targets/infer-targets.d.ts

@@ -0,0 +1,8 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    plugins?: string[];
+    skipFormat?: boolean;
+}
+export declare function convertToInferredGenerator(tree: Tree, options: Schema): Promise<GeneratorCallback>;
+export default convertToInferredGenerator;

package/src/generators/infer-targets/infer-targets.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToInferredGenerator = convertToInferredGenerator;
+const devkit_1 = require("@nx/devkit");
+const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const enquirer_1 = require("enquirer");
+const generator_utils_1 = require("nx/src/command-line/generate/generator-utils");
+const installed_plugins_1 = require("nx/src/utils/plugins/installed-plugins");
+async function convertToInferredGenerator(tree, options) {
+    const generatorCollectionChoices = await getPossibleConvertToInferredGenerators();
+    if (generatorCollectionChoices.size === 0) {
+        devkit_1.output.error({
+            title: 'No inference plugin found. For information on this migration, see https://nx.dev/recipes/running-tasks/convert-to-inferred',
+        });
+        return;
+    }
+    let generatorsToRun;
+    if (options.plugins && options.plugins.filter((p) => !!p).length > 0) {
+        generatorsToRun = Array.from(generatorCollectionChoices.values())
+            .filter((generator) => options.plugins.includes(generator.resolvedCollectionName))
+            .map((generator) => generator.resolvedCollectionName);
+    }
+    else if (process.argv.includes('--no-interactive')) {
+        generatorsToRun = Array.from(generatorCollectionChoices.keys());
+    }
+    else {
+        const allChoices = Array.from(generatorCollectionChoices.keys());
+        generatorsToRun = (await (0, enquirer_1.prompt)({
+            type: 'multiselect',
+            name: 'generatorsToRun',
+            message: 'Which inference plugin do you want to use?',
+            choices: allChoices,
+            initial: allChoices,
+            validate: (result) => {
+                if (result.length === 0) {
+                    return 'Please select at least one plugin.';
+                }
+                return true;
+            },
+        })).generatorsToRun;
+    }
+    if (generatorsToRun.length === 0) {
+        devkit_1.output.error({
+            title: 'Please select at least one plugin.',
+        });
+        return;
+    }
+    const tasks = [];
+    for (const generatorCollection of generatorsToRun) {
+        try {
+            const generator = generatorCollectionChoices.get(generatorCollection);
+            if (generator) {
+                const generatorFactory = generator.implementationFactory();
+                const callback = await generatorFactory(tree, {
+                    project: options.project,
+                    skipFormat: options.skipFormat,
+                });
+                if (callback) {
+                    const task = await callback();
+                    if (typeof task === 'function')
+                        tasks.push(task);
+                }
+                devkit_1.output.success({
+                    title: `${generatorCollection}:convert-to-inferred - Success`,
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof executor_to_plugin_migrator_1.NoTargetsToMigrateError) {
+                devkit_1.output.note({
+                    title: `${generatorCollection}:convert-to-inferred - Skipped (No targets to migrate)`,
+                });
+            }
+            else {
+                devkit_1.output.error({
+                    title: `${generatorCollection}:convert-to-inferred - Failed`,
+                });
+                throw e;
+            }
+        }
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+async function getPossibleConvertToInferredGenerators() {
+    const installedCollections = Array.from(new Set((0, installed_plugins_1.findInstalledPlugins)().map((x) => x.name)));
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const projectsConfigurations = (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const choices = new Map();
+    for (const collectionName of installedCollections) {
+        try {
+            const generator = (0, generator_utils_1.getGeneratorInformation)(collectionName, 'convert-to-inferred', devkit_1.workspaceRoot, projectsConfigurations.projects);
+            if (generator.generatorConfiguration.hidden ||
+                generator.generatorConfiguration['x-deprecated']) {
+                continue;
+            }
+            choices.set(generator.resolvedCollectionName, generator);
+        }
+        catch {
+            // this just means that no convert-to-inferred generator exists for a given collection, ignore
+        }
+    }
+    return choices;
+}
+exports.default = convertToInferredGenerator;

package/src/generators/infer-targets/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "InferTargets",
+  "title": "",
+  "type": "object",
+  "description": "Convert Nx projects to use inferred targets.",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert to use inferred targets.",
+      "x-priority": "important"
+    },
+    "plugins": {
+      "type": "array",
+      "description": "The plugins used to infer targets. For example @nx/eslint or @nx/jest",
+      "items": {
+        "type": "string"
+      }
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files.",
+      "default": false
+    }
+  }
+}