@nx/plugin 20.1.0 → 20.2.0-beta.0

package/generators.json

@@ -4,12 +4,12 @@
   "extends": ["@nx/workspace"],
   "generators": {
     "plugin": {
-      "factory": "./src/generators/plugin/plugin",
+      "factory": "./src/generators/plugin/plugin#pluginGeneratorInternal",
       "schema": "./src/generators/plugin/schema.json",
       "description": "Create a Nx Plugin."
     },
     "create-package": {
-      "factory": "./src/generators/create-package/create-package",
+      "factory": "./src/generators/create-package/create-package#createPackageGeneratorInternal",
       "schema": "./src/generators/create-package/schema.json",
       "description": "Create a package which can be used by npx to create a new workspace"
     },
@@ -39,7 +39,7 @@
       "description": "Adds linting configuration to validate common json files for nx plugins."
     },
     "preset": {
-      "factory": "./src/generators/preset/generator",
+      "factory": "./src/generators/preset/generator#presetGeneratorInternal",
       "schema": "./src/generators/preset/schema.json",
       "description": "Initializes a workspace with an nx-plugin inside of it. Use as: `create-nx-workspace --preset @nx/plugin`.",
       "hidden": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/plugin",
-  "version": "20.1.0",
+  "version": "20.2.0-beta.0",
   "private": false,
   "description": "This plugin is used to create Nx plugins! It contains generators for generating common plugin features like generators, executors, migrations and more.",
   "repository": {
@@ -28,10 +28,10 @@
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "20.1.0",
-    "@nx/jest": "20.1.0",
-    "@nx/js": "20.1.0",
-    "@nx/eslint": "20.1.0"
+    "@nx/devkit": "20.2.0-beta.0",
+    "@nx/jest": "20.2.0-beta.0",
+    "@nx/js": "20.2.0-beta.0",
+    "@nx/eslint": "20.2.0-beta.0"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/create-package/create-package.d.ts

@@ -1,4 +1,5 @@
 import { GeneratorCallback, Tree } from '@nx/devkit';
 import { CreatePackageSchema } from './schema';
 export declare function createPackageGenerator(host: Tree, schema: CreatePackageSchema): Promise<GeneratorCallback>;
+export declare function createPackageGeneratorInternal(host: Tree, schema: CreatePackageSchema): Promise<GeneratorCallback>;
 export default createPackageGenerator;

package/src/generators/create-package/create-package.js

@@ -1,18 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPackageGenerator = createPackageGenerator;
+exports.createPackageGeneratorInternal = createPackageGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
+const package_manager_workspaces_1 = require("@nx/js/src/utils/package-manager-workspaces");
 const add_tslib_dependencies_1 = require("@nx/js/src/utils/typescript/add-tslib-dependencies");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const versions_1 = require("nx/src/utils/versions");
+const versions_1 = require("@nx/js/src/utils/versions");
+const versions_2 = require("nx/src/utils/versions");
+const path_1 = require("path");
+const has_generator_1 = require("../../utils/has-generator");
 const generator_1 = require("../generator/generator");
 const normalize_schema_1 = require("./utils/normalize-schema");
-const has_generator_1 = require("../../utils/has-generator");
-const path_1 = require("path");
-const versions_2 = require("@nx/js/src/utils/versions");
 async function createPackageGenerator(host, schema) {
-    (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(host, 'plugin', 'create-package');
+    return await createPackageGeneratorInternal(host, {
+        useProjectJson: true,
+        addPlugin: false,
+        ...schema,
+    });
+}
+async function createPackageGeneratorInternal(host, schema) {
     const tasks = [];
     const options = await (0, normalize_schema_1.normalizeSchema)(host, schema);
     const pluginPackageName = await addPresetGenerator(host, options);
@@ -20,7 +28,7 @@ async function createPackageGenerator(host, schema) {
         tasks.push((0, add_tslib_dependencies_1.addTsLibDependencies)(host));
     }
     const installTask = (0, devkit_1.addDependenciesToPackageJson)(host, {
-        'create-nx-workspace': versions_1.nxVersion,
+        'create-nx-workspace': versions_2.nxVersion,
     }, {});
     tasks.push(installTask);
     await createCliPackage(host, options, pluginPackageName);
@@ -30,6 +38,12 @@ async function createPackageGenerator(host, schema) {
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);
     }
+    if (options.isTsSolutionSetup) {
+        const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(host, options.projectRoot);
+        if (projectPackageManagerWorkspaceState !== 'included') {
+            tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(projectPackageManagerWorkspaceState, host.root));
+        }
+    }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 /**
@@ -41,11 +55,12 @@ async function createPackageGenerator(host, schema) {
 async function addPresetGenerator(host, schema) {
     const { root: projectRoot } = (0, devkit_1.readProjectConfiguration)(host, schema.project);
     if (!(0, has_generator_1.hasGenerator)(host, schema.project, 'preset')) {
-        await (0, generator_1.default)(host, {
+        await (0, generator_1.generatorGenerator)(host, {
             name: 'preset',
-            path: (0, path_1.join)(projectRoot, 'src/generators/preset'),
+            path: (0, path_1.join)(projectRoot, 'src/generators/preset/generator'),
             unitTestRunner: schema.unitTestRunner,
             skipFormat: true,
+            skipLintChecks: schema.linter === 'none',
         });
     }
     return (0, devkit_1.readJson)(host, (0, devkit_1.joinPathFragments)(projectRoot, 'package.json'))?.name;
@@ -61,16 +76,27 @@ async function createCliPackage(host, options, pluginPackageName) {
         importPath: options.name,
         skipFormat: true,
         skipTsConfig: true,
+        useTscExecutor: true,
+        skipWorkspacesWarning: true,
     });
     host.delete((0, devkit_1.joinPathFragments)(options.projectRoot, 'src'));
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
     // Add the bin entry to the package.json
     (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (packageJson) => {
         packageJson.bin = {
             [options.name]: './bin/index.js',
         };
+        if (isTsSolutionSetup) {
+            packageJson.bin[options.name] = './dist/bin/index.js';
+            // this package only exposes a binary entry point and no JS programmatic API
+            delete packageJson.main;
+            delete packageJson.types;
+            delete packageJson.typings;
+            delete packageJson.exports;
+        }
         packageJson.dependencies = {
-            'create-nx-workspace': versions_1.nxVersion,
-            ...(options.bundler === 'tsc' && { tslib: versions_2.tsLibVersion }),
+            'create-nx-workspace': versions_2.nxVersion,
+            ...(options.bundler === 'tsc' && { tslib: versions_1.tsLibVersion }),
         };
         return packageJson;
     });
@@ -79,10 +105,20 @@ async function createCliPackage(host, options, pluginPackageName) {
     projectConfiguration.sourceRoot = (0, devkit_1.joinPathFragments)(options.projectRoot, 'bin');
     projectConfiguration.targets.build.options.main = (0, devkit_1.joinPathFragments)(options.projectRoot, 'bin/index.ts');
     projectConfiguration.implicitDependencies = [options.project];
+    if (options.isTsSolutionSetup) {
+        if (options.bundler === 'tsc') {
+            projectConfiguration.targets.build.options.generatePackageJson = false;
+        }
+        else if (options.bundler === 'swc') {
+            delete projectConfiguration.targets.build.options.stripLeadingPaths;
+        }
+    }
     (0, devkit_1.updateProjectConfiguration)(host, options.projectName, projectConfiguration);
-    // Add bin files to tsconfg.lib.json
+    // Add bin files and update rootDir in tsconfg.lib.json
     (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'), (tsConfig) => {
         tsConfig.include.push('bin/**/*.ts');
+        tsConfig.compilerOptions ??= {};
+        tsConfig.compilerOptions.rootDir = '.';
         return tsConfig;
     });
     (0, devkit_1.generateFiles)(host, (0, devkit_1.joinPathFragments)(__dirname, './files/create-framework-package'), options.projectRoot, {

package/src/generators/create-package/files/create-framework-package/bin/index.ts__tmpl__

@@ -11,8 +11,9 @@ async function main() {
   console.log(`Creating the workspace: ${name}`);
 
   // This assumes "<%= preset %>" and "<%= projectName %>" are at the same version
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const presetVersion = require('../package.json').version;
+  // eslint-disable-next-line @typescript-eslint/no-var-requires<% if (isTsSolutionSetup) { %>
+  const presetVersion = require('../../package.json').version;<% } else { %>
+  const presetVersion = require('../package.json').version;<% } %>
 
   // TODO: update below to customize the workspace
   const { directory } = await createWorkspace(

package/src/generators/create-package/schema.d.ts

@@ -6,12 +6,15 @@ export interface CreatePackageSchema {
   directory: string;
 
   // options to create cli package, passed to js library generator
-  skipFormat: boolean;
+  skipFormat?: boolean;
   tags?: string;
-  unitTestRunner: 'jest' | 'none';
-  linter: Linter | LinterType;
-  compiler: 'swc' | 'tsc';
+  unitTestRunner?: 'jest' | 'none';
+  linter?: Linter | LinterType;
+  compiler?: 'swc' | 'tsc';
 
   // options to create e2e project, passed to e2e project generator
   e2eProject?: string;
+
+  useProjectJson?: boolean;
+  addPlugin?: boolean;
 }

package/src/generators/create-package/schema.json

@@ -33,15 +33,13 @@
     },
     "unitTestRunner": {
       "type": "string",
-      "enum": ["jest", "none"],
-      "description": "Test runner to use for unit tests.",
-      "default": "jest"
+      "enum": ["none", "jest"],
+      "description": "Test runner to use for unit tests."
     },
     "linter": {
       "description": "The tool to use for running lint checks.",
       "type": "string",
-      "enum": ["eslint"],
-      "default": "eslint"
+      "enum": ["none", "eslint"]
     },
     "tags": {
       "type": "string",
@@ -64,6 +62,10 @@
       "type": "string",
       "description": "The name of the e2e project.",
       "x-prompt": "What is the name of the e2e project? Leave blank to skip e2e tests"
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["directory", "name", "project"]

package/src/generators/create-package/utils/normalize-schema.d.ts

@@ -1,8 +1,14 @@
 import { Tree } from '@nx/devkit';
+import type { LinterType } from '@nx/eslint';
 import { CreatePackageSchema } from '../schema';
 export interface NormalizedSchema extends CreatePackageSchema {
     bundler: 'swc' | 'tsc';
     projectName: string;
     projectRoot: string;
+    unitTestRunner: 'jest' | 'none';
+    linter: LinterType;
+    useProjectJson: boolean;
+    addPlugin: boolean;
+    isTsSolutionSetup: boolean;
 }
 export declare function normalizeSchema(host: Tree, schema: CreatePackageSchema): Promise<NormalizedSchema>;

package/src/generators/create-package/utils/normalize-schema.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeSchema = normalizeSchema;
+const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const generator_prompts_1 = require("@nx/js/src/utils/generator-prompts");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 async function normalizeSchema(host, schema) {
+    const linter = await (0, generator_prompts_1.normalizeLinterOption)(host, schema.linter);
+    const unitTestRunner = await (0, generator_prompts_1.normalizeUnitTestRunnerOption)(host, schema.unitTestRunner, ['jest']);
     if (!schema.directory) {
         throw new Error(`Please provide the --directory option. It should be the directory containing the project '${schema.project}'.`);
     }
@@ -11,11 +16,23 @@ async function normalizeSchema(host, schema) {
         projectType: 'library',
         directory: schema.directory,
     });
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPlugin = schema.addPlugin ??
+        (isTsSolutionSetup &&
+            process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false);
     return {
         ...schema,
         bundler: schema.compiler ?? 'tsc',
         projectName,
         projectRoot,
         name: projectNames.projectSimpleName,
+        linter,
+        unitTestRunner,
+        // We default to generate a project.json file if the new setup is not being used
+        useProjectJson: schema.useProjectJson ?? !isTsSolutionSetup,
+        addPlugin,
+        isTsSolutionSetup,
     };
 }

package/src/generators/e2e-project/e2e.d.ts

@@ -1,5 +1,4 @@
-import type { Tree } from '@nx/devkit';
-import { GeneratorCallback } from '@nx/devkit';
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
 import type { Schema } from './schema';
 export declare function e2eProjectGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
 export declare function e2eProjectGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;

package/src/generators/e2e-project/e2e.js

@@ -4,19 +4,22 @@ exports.e2eProjectGenerator = e2eProjectGenerator;
 exports.e2eProjectGeneratorInternal = e2eProjectGeneratorInternal;
 const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const eslint_1 = require("@nx/eslint");
 const jest_1 = require("@nx/jest");
 const js_1 = require("@nx/js");
 const generator_1 = require("@nx/js/src/generators/setup-verdaccio/generator");
 const add_local_registry_scripts_1 = require("@nx/js/src/utils/add-local-registry-scripts");
+const generator_prompts_1 = require("@nx/js/src/utils/generator-prompts");
+const package_manager_workspaces_1 = require("@nx/js/src/utils/package-manager-workspaces");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const eslint_1 = require("@nx/eslint");
 const path_1 = require("path");
 async function normalizeOptions(host, options) {
+    const linter = await (0, generator_prompts_1.normalizeLinterOption)(host, options.linter);
     const projectName = options.rootProject ? 'e2e' : `${options.pluginName}-e2e`;
     const nxJson = (0, devkit_1.readNxJson)(host);
-    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    options.addPlugin ??= addPlugin;
+    const addPlugin = options.addPlugin ??
+        (process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false);
     let projectRoot;
     const projectNameAndRootOptions = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
         name: projectName,
@@ -27,12 +30,16 @@ async function normalizeOptions(host, options) {
     });
     projectRoot = projectNameAndRootOptions.projectRoot;
     const pluginPropertyName = (0, devkit_1.names)(options.pluginName).propertyName;
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
     return {
         ...options,
         projectName,
-        linter: options.linter ?? eslint_1.Linter.EsLint,
+        linter,
         pluginPropertyName,
         projectRoot,
+        addPlugin,
+        useProjectJson: options.useProjectJson ?? !isTsSolutionSetup,
+        isTsSolutionSetup,
     };
 }
 function validatePlugin(host, pluginName) {
@@ -55,13 +62,25 @@ function addFiles(host, options) {
     });
 }
 async function addJest(host, options) {
-    (0, devkit_1.addProjectConfiguration)(host, options.projectName, {
+    const projectConfiguration = {
+        name: options.projectName,
         root: options.projectRoot,
         projectType: 'application',
         sourceRoot: `${options.projectRoot}/src`,
-        targets: {},
         implicitDependencies: [options.pluginName],
-    });
+    };
+    if (options.isTsSolutionSetup) {
+        (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), {
+            name: (0, project_name_and_root_utils_1.resolveImportPath)(host, options.projectName, options.projectRoot),
+            version: '0.0.1',
+            private: true,
+        });
+        (0, devkit_1.updateProjectConfiguration)(host, options.projectName, projectConfiguration);
+    }
+    else {
+        projectConfiguration.targets = {};
+        (0, devkit_1.addProjectConfiguration)(host, options.projectName, projectConfiguration);
+    }
     const jestTask = await (0, jest_1.configurationGenerator)(host, {
         project: options.projectName,
         targetName: 'e2e',
@@ -75,6 +94,7 @@ async function addJest(host, options) {
     (0, jest_1.addPropertyToJestConfig)(host, (0, path_1.join)(options.projectRoot, 'jest.config.ts'), 'globalSetup', (0, path_1.join)((0, devkit_1.offsetFromRoot)(options.projectRoot), startLocalRegistryPath));
     (0, jest_1.addPropertyToJestConfig)(host, (0, path_1.join)(options.projectRoot, 'jest.config.ts'), 'globalTeardown', (0, path_1.join)((0, devkit_1.offsetFromRoot)(options.projectRoot), stopLocalRegistryPath));
     const project = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
+    project.targets ??= {};
     const e2eTarget = project.targets.e2e;
     project.targets.e2e = {
         ...e2eTarget,
@@ -101,14 +121,22 @@ async function addLintingToApplication(tree, options) {
     });
     return lintTask;
 }
+function updatePluginPackageJson(tree, options) {
+    const { root } = (0, devkit_1.readProjectConfiguration)(tree, options.pluginName);
+    (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(root, 'package.json'), (json) => {
+        // to publish the plugin, we need to remove the private flag
+        delete json.private;
+        return json;
+    });
+}
 async function e2eProjectGenerator(host, schema) {
     return await e2eProjectGeneratorInternal(host, {
         addPlugin: false,
+        useProjectJson: true,
         ...schema,
     });
 }
 async function e2eProjectGeneratorInternal(host, schema) {
-    (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(host, 'plugin', 'e2e-project');
     const tasks = [];
     validatePlugin(host, schema.pluginName);
     const options = await normalizeOptions(host, schema);
@@ -117,14 +145,33 @@ async function e2eProjectGeneratorInternal(host, schema) {
         skipFormat: true,
     }));
     tasks.push(await addJest(host, options));
-    if (options.linter !== eslint_1.Linter.None) {
+    updatePluginPackageJson(host, options);
+    if (options.linter !== 'none') {
         tasks.push(await addLintingToApplication(host, {
             ...options,
         }));
     }
+    if (options.isTsSolutionSetup && !options.rootProject) {
+        // update root  tsconfig.json references with the new lib tsconfig
+        (0, devkit_1.updateJson)(host, 'tsconfig.json', (json) => {
+            json.references ??= [];
+            json.references.push({
+                path: options.projectRoot.startsWith('./')
+                    ? options.projectRoot
+                    : './' + options.projectRoot,
+            });
+            return json;
+        });
+    }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);
     }
+    if (options.isTsSolutionSetup && !options.skipWorkspacesWarning) {
+        const projectPackageManagerWorkspaceState = (0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceState)(host, options.projectRoot);
+        if (projectPackageManagerWorkspaceState !== 'included') {
+            tasks.push((0, package_manager_workspaces_1.getProjectPackageManagerWorkspaceStateWarningTask)(projectPackageManagerWorkspaceState, host.root));
+        }
+    }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.default = e2eProjectGenerator;

package/src/generators/e2e-project/schema.d.ts

@@ -9,5 +9,7 @@ export interface Schema {
   linter?: Linter | LinterType;
   skipFormat?: boolean;
   rootProject?: boolean;
+  useProjectJson?: boolean;
   addPlugin?: boolean;
+  skipWorkspacesWarning?: boolean;
 }

package/src/generators/e2e-project/schema.json

@@ -33,8 +33,7 @@
     "linter": {
       "description": "The tool to use for running lint checks.",
       "type": "string",
-      "enum": ["eslint", "none"],
-      "default": "eslint"
+      "enum": ["none", "eslint"]
     },
     "minimal": {
       "type": "boolean",
@@ -46,6 +45,10 @@
       "type": "boolean",
       "default": false,
       "x-priority": "internal"
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["pluginName", "npmPackageName"]

package/src/generators/executor/executor.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from '@nx/devkit';
+import { type Tree } from '@nx/devkit';
 import type { Schema } from './schema';
 export declare function createExecutorsJson(host: Tree, projectRoot: string, projectName: string, skipLintChecks?: boolean): Promise<void>;
 export declare function executorGenerator(host: Tree, schema: Schema): Promise<void>;

package/src/generators/executor/executor.js

@@ -3,25 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExecutorsJson = createExecutorsJson;
 exports.executorGenerator = executorGenerator;
 const devkit_1 = require("@nx/devkit");
-const path = require("path");
-const generator_1 = require("../lint-checks/generator");
-const versions_1 = require("../../utils/versions");
 const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 const path_1 = require("path");
+const paths_1 = require("../../utils/paths");
+const versions_1 = require("../../utils/versions");
+const generator_1 = require("../lint-checks/generator");
 function addFiles(host, options) {
-    (0, devkit_1.generateFiles)(host, path.join(__dirname, './files/executor'), options.path, {
+    (0, devkit_1.generateFiles)(host, (0, path_1.join)(__dirname, './files/executor'), options.directory, {
         ...options,
     });
     if (options.unitTestRunner === 'none') {
-        host.delete((0, devkit_1.joinPathFragments)(options.path, `executor.spec.ts`));
+        host.delete((0, devkit_1.joinPathFragments)(options.directory, `${options.fileName}.spec.ts`));
     }
 }
 function addHasherFiles(host, options) {
-    (0, devkit_1.generateFiles)(host, path.join(__dirname, './files/hasher'), options.path, {
+    (0, devkit_1.generateFiles)(host, (0, path_1.join)(__dirname, './files/hasher'), options.directory, {
         ...options,
     });
     if (options.unitTestRunner === 'none') {
-        host.delete((0, devkit_1.joinPathFragments)(options.path, 'hasher.spec.ts'));
+        host.delete((0, devkit_1.joinPathFragments)(options.directory, 'hasher.spec.ts'));
     }
 }
 async function createExecutorsJson(host, projectRoot, projectName, skipLintChecks) {
@@ -49,6 +50,14 @@ async function updateExecutorJson(host, options) {
     }
     if (!host.exists(executorsPath)) {
         await createExecutorsJson(host, options.projectRoot, options.project, options.skipLintChecks);
+        if (options.isTsSolutionSetup) {
+            (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (json) => {
+                const filesSet = new Set(json.files ?? ['dist', '!**/*.tsbuildinfo']);
+                filesSet.add('executors.json');
+                json.files = [...filesSet];
+                return json;
+            });
+        }
     }
     // add dependencies
     (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), (json) => {
@@ -61,42 +70,45 @@ async function updateExecutorJson(host, options) {
     return (0, devkit_1.updateJson)(host, executorsPath, (json) => {
         let executors = json.executors ?? json.builders;
         executors ||= {};
+        const dir = (0, paths_1.getArtifactMetadataDirectory)(host, options.project, options.directory, options.isTsSolutionSetup);
         executors[options.name] = {
-            implementation: `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.path), 'executor')}`,
-            schema: `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.path), 'schema.json')}`,
+            implementation: `${dir}/${options.fileName}`,
+            schema: `${dir}/schema.json`,
             description: options.description,
         };
         if (options.includeHasher) {
-            executors[options.name].hasher = `./${(0, devkit_1.joinPathFragments)((0, path_1.relative)(options.projectRoot, options.path), 'hasher')}`;
+            executors[options.name].hasher = `${dir}/hasher`;
         }
         json.executors = executors;
         return json;
     });
 }
 async function normalizeOptions(tree, options) {
-    const { project, artifactName, filePath, directory } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
-        name: options.name,
+    const { artifactName: name, directory, fileName, project, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
         path: options.path,
-        fileName: 'executor',
+        name: options.name,
     });
-    const { className, propertyName } = (0, devkit_1.names)(artifactName);
-    const { root: projectRoot } = (0, devkit_1.readProjectConfiguration)(tree, project);
+    const { className, propertyName } = (0, devkit_1.names)(name);
+    const { root: projectRoot, sourceRoot: projectSourceRoot } = (0, devkit_1.readProjectConfiguration)(tree, project);
     let description;
     if (options.description) {
         description = options.description;
     }
     else {
-        description = `${options.name} executor`;
+        description = `${name} executor`;
     }
     return {
         ...options,
-        filePath,
+        fileName,
         project,
         directory,
+        name,
         className,
         propertyName,
         description,
         projectRoot,
+        projectSourceRoot,
+        isTsSolutionSetup: (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree),
     };
 }
 async function executorGenerator(host, schema) {

package/src/generators/executor/files/executor/{executor.spec.ts.template → __fileName__.spec.ts.template}

@@ -1,7 +1,7 @@
 import { ExecutorContext } from '@nx/devkit';
 
 import { <%= className %>ExecutorSchema } from './schema';
-import executor from './executor';
+import executor from './<%= fileName %>';
 
 const options: <%= className %>ExecutorSchema = {};
 const context: ExecutorContext = {

package/src/generators/generator/files/generator/{generator.spec.ts.template → __fileName__.spec.ts.template}

@@ -1,7 +1,7 @@
 import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
 import { Tree, readProjectConfiguration } from '@nx/devkit';
 
-import { <%= generatorFnName %> } from './generator';
+import { <%= generatorFnName %> } from './<%= fileName %>';
 import { <%= schemaInterfaceName %> } from './schema';
 
 describe('<%= name %> generator', () => {