@nx/node 21.0.0-beta.0 → 21.0.0-beta.10

package/migrations.json

@@ -1,24 +1,6 @@
 {
   "generators": {},
   "packageJsonUpdates": {
-    "17.3.0": {
-      "version": "17.3.0-beta.3",
-      "packages": {
-        "@types/node": {
-          "version": "18.16.9",
-          "alwaysAddToPackageJson": false
-        }
-      }
-    },
-    "17.3.1": {
-      "version": "17.3.1-beta.0",
-      "packages": {
-        "axios": {
-          "version": "^1.6.0",
-          "alwaysAddToPackageJson": false
-        }
-      }
-    },
     "20.4.0": {
       "version": "20.4.0-beta.3",
       "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/node",
-  "version": "21.0.0-beta.0",
+  "version": "21.0.0-beta.10",
   "private": false,
   "description": "The Node Plugin for Nx contains generators to manage Node applications within an Nx workspace.",
   "repository": {
@@ -32,10 +32,12 @@
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "21.0.0-beta.0",
-    "@nx/jest": "21.0.0-beta.0",
-    "@nx/js": "21.0.0-beta.0",
-    "@nx/eslint": "21.0.0-beta.0"
+    "@nx/devkit": "21.0.0-beta.10",
+    "@nx/jest": "21.0.0-beta.10",
+    "@nx/js": "21.0.0-beta.10",
+    "@nx/eslint": "21.0.0-beta.10",
+    "tcp-port-used": "^1.0.2",
+    "kill-port": "^1.6.1"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/application/application.d.ts

@@ -1,9 +1,10 @@
 import { GeneratorCallback, Tree } from '@nx/devkit';
 import { Schema } from './schema';
-export interface NormalizedSchema extends Schema {
+export interface NormalizedSchema extends Omit<Schema, 'useTsSolution'> {
     appProjectRoot: string;
     parsedTags: string[];
     outputPath: string;
+    importPath: string;
     isUsingTsSolutionConfig: boolean;
 }
 export declare function addLintingToApplication(tree: Tree, options: NormalizedSchema): Promise<GeneratorCallback>;

package/src/generators/application/application.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLintingToApplication = addLintingToApplication;
 exports.applicationGenerator = applicationGenerator;
 exports.applicationGeneratorInternal = applicationGeneratorInternal;
-const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
 const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
 const jest_1 = require("@nx/jest");
@@ -79,6 +78,7 @@ function getEsBuildConfig(project, options) {
 }
 function getServeConfig(options) {
     return {
+        continuous: true,
         executor: '@nx/js:node',
         defaultConfiguration: 'development',
         // Run build, which includes dependency on "^build" by default, so the first run
@@ -138,23 +138,24 @@ function addProject(tree, options) {
         }
     }
     project.targets.serve = getServeConfig(options);
-    if (options.isUsingTsSolutionConfig) {
-        (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'package.json'), {
-            name: (0, get_import_path_1.getImportPath)(tree, options.name),
-            version: '0.0.1',
-            private: true,
-            nx: {
-                name: options.name,
-                projectType: 'application',
-                sourceRoot: project.sourceRoot,
-                targets: project.targets,
-                tags: project.tags?.length ? project.tags : undefined,
-            },
-        });
+    const packageJson = {
+        name: options.importPath,
+        version: '0.0.1',
+        private: true,
+    };
+    if (!options.useProjectJson) {
+        packageJson.nx = {
+            name: options.name !== options.importPath ? options.name : undefined,
+            targets: project.targets,
+            tags: project.tags?.length ? project.tags : undefined,
+        };
     }
     else {
         (0, devkit_1.addProjectConfiguration)(tree, options.name, project, options.standaloneConfig);
     }
+    if (!options.useProjectJson || options.isUsingTsSolutionConfig) {
+        (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'package.json'), packageJson);
+    }
 }
 function addAppFiles(tree, options) {
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/common'), options.appProjectRoot, {
@@ -194,10 +195,16 @@ function addAppFiles(tree, options) {
 }
 function addProxy(tree, options) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.frontendProject);
-    if (projectConfig.targets && projectConfig.targets.serve) {
+    if (projectConfig.targets &&
+        ['serve', 'dev'].find((t) => !!projectConfig.targets[t])) {
+        const targetName = ['serve', 'dev'].find((t) => !!projectConfig.targets[t]);
+        projectConfig.targets[targetName].dependsOn = [
+            ...(projectConfig.targets[targetName].dependsOn ?? []),
+            `${options.name}:serve`,
+        ];
         const pathToProxyFile = `${projectConfig.root}/proxy.conf.json`;
-        projectConfig.targets.serve.options = {
-            ...projectConfig.targets.serve.options,
+        projectConfig.targets[targetName].options = {
+            ...projectConfig.targets[targetName].options,
             proxyConfig: pathToProxyFile,
         };
         if (!tree.exists(pathToProxyFile)) {
@@ -314,6 +321,7 @@ function updateTsConfigOptions(tree, options) {
 async function applicationGenerator(tree, schema) {
     return await applicationGeneratorInternal(tree, {
         addPlugin: false,
+        useProjectJson: true,
         ...schema,
     });
 }
@@ -374,6 +382,11 @@ async function applicationGeneratorInternal(tree, schema) {
     }
     addAppFiles(tree, options);
     addProject(tree, options);
+    // If we are using the new TS solution
+    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
+    if (options.isUsingTsSolutionConfig) {
+        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.appProjectRoot);
+    }
     updateTsConfigOptions(tree, options);
     if (options.linter === eslint_1.Linter.EsLint) {
         const lintTask = await addLintingToApplication(tree, options);
@@ -438,11 +451,6 @@ async function applicationGeneratorInternal(tree, schema) {
             ? ['eslint.config.js', 'eslint.config.cjs', 'eslint.config.mjs']
             : undefined);
     }
-    // If we are using the new TS solution
-    // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
-    if (options.isUsingTsSolutionConfig) {
-        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.appProjectRoot);
-    }
     (0, sort_fields_1.sortPackageJsonFields)(tree, options.appProjectRoot);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -453,8 +461,8 @@ async function applicationGeneratorInternal(tree, schema) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 async function normalizeOptions(host, options) {
-    await (0, project_name_and_root_utils_1.ensureProjectName)(host, options, 'application');
-    const { projectName: appProjectName, projectRoot: appProjectRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'application');
+    const { projectName, projectRoot: appProjectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
         name: options.name,
         projectType: 'application',
         directory: options.directory,
@@ -471,6 +479,8 @@ async function normalizeOptions(host, options) {
         nxJson.useInferencePlugins !== false;
     const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
     const swcJest = options.swcJest ?? isUsingTsSolutionConfig;
+    const appProjectName = !isUsingTsSolutionConfig || options.name ? projectName : importPath;
+    const useProjectJson = options.useProjectJson ?? !isUsingTsSolutionConfig;
     return {
         addPlugin,
         ...options,
@@ -479,6 +489,7 @@ async function normalizeOptions(host, options) {
             ? (0, devkit_1.names)(options.frontendProject).fileName
             : undefined,
         appProjectRoot,
+        importPath,
         parsedTags,
         linter: options.linter ?? eslint_1.Linter.EsLint,
         unitTestRunner: options.unitTestRunner ?? 'jest',
@@ -486,9 +497,10 @@ async function normalizeOptions(host, options) {
         port: options.port ?? 3000,
         outputPath: isUsingTsSolutionConfig
             ? (0, devkit_1.joinPathFragments)(appProjectRoot, 'dist')
-            : (0, devkit_1.joinPathFragments)('dist', options.rootProject ? options.name : appProjectRoot),
+            : (0, devkit_1.joinPathFragments)('dist', options.rootProject ? appProjectName : appProjectRoot),
         isUsingTsSolutionConfig,
         swcJest,
+        useProjectJson,
     };
 }
 exports.default = applicationGenerator;

package/src/generators/application/schema.d.ts

@@ -25,6 +25,7 @@ export interface Schema {
   isNest?: boolean;
   addPlugin?: boolean;
   useTsSolution?: boolean;
+  useProjectJson?: boolean;
 }
 
 export type NodeJsFrameWorks = 'express' | 'koa' | 'fastify' | 'nest' | 'none';

package/src/generators/application/schema.json

@@ -123,6 +123,10 @@
     "docker": {
       "type": "boolean",
       "description": "Add a docker build target"
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["directory"]

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

@@ -12,12 +12,12 @@ const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
 const config_file_1 = require("@nx/jest/src/utils/config/config-file");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
 const posix_1 = require("node:path/posix");
 const add_swc_config_1 = require("@nx/js/src/utils/swc/add-swc-config");
 async function e2eProjectGenerator(host, options) {
     return await e2eProjectGeneratorInternal(host, {
         addPlugin: false,
+        useProjectJson: true,
         ...options,
     });
 }
@@ -25,30 +25,30 @@ async function e2eProjectGeneratorInternal(host, _options) {
     const tasks = [];
     const options = await normalizeOptions(host, _options);
     const appProject = (0, devkit_1.readProjectConfiguration)(host, options.project);
-    const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(host);
     // TODO(@ndcunningham): This is broken.. the outputs are wrong.. and this isn't using the jest generator
-    if (isUsingTsSolutionConfig) {
-        (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'package.json'), {
-            name: (0, get_import_path_1.getImportPath)(host, options.e2eProjectName),
-            version: '0.0.1',
-            private: true,
-            nx: {
-                name: options.e2eProjectName,
-                projectType: 'application',
-                implicitDependencies: [options.project],
-                targets: {
-                    e2e: {
-                        executor: '@nx/jest:jest',
-                        outputs: ['{workspaceRoot}/coverage/{e2eProjectRoot}'],
-                        options: {
-                            jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
-                            passWithNoTests: true,
-                        },
-                        dependsOn: [`${options.project}:build`],
+    const packageJson = {
+        name: options.importPath,
+        version: '0.0.1',
+        private: true,
+    };
+    if (!options.useProjectJson) {
+        packageJson.nx = {
+            name: options.e2eProjectName !== options.importPath
+                ? options.e2eProjectName
+                : undefined,
+            implicitDependencies: [options.project],
+            targets: {
+                e2e: {
+                    executor: '@nx/jest:jest',
+                    outputs: ['{projectRoot}/test-output/jest/coverage'],
+                    options: {
+                        jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
+                        passWithNoTests: true,
                     },
+                    dependsOn: [`${options.project}:build`, `${options.project}:serve`],
                 },
             },
-        });
+        };
     }
     else {
         (0, devkit_1.addProjectConfiguration)(host, options.e2eProjectName, {
@@ -63,11 +63,14 @@ async function e2eProjectGeneratorInternal(host, _options) {
                         jestConfig: `${options.e2eProjectRoot}/jest.config.ts`,
                         passWithNoTests: true,
                     },
-                    dependsOn: [`${options.project}:build`],
+                    dependsOn: [`${options.project}:build`, `${options.project}:serve`],
                 },
             },
         });
     }
+    if (!options.useProjectJson || options.isUsingTsSolutionConfig) {
+        (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'package.json'), packageJson);
+    }
     // TODO(@nicholas): Find a better way to get build target
     // We remove the 'test' target from the e2e project because it is not needed
     // The 'e2e' target is the one that should run the tests for the e2e project
@@ -94,28 +97,28 @@ async function e2eProjectGeneratorInternal(host, _options) {
         });
     }
     const jestPreset = (0, config_file_1.findRootJestPreset)(host) ?? 'jest.preset.js';
-    const tsConfigFile = isUsingTsSolutionConfig
+    const tsConfigFile = options.isUsingTsSolutionConfig
         ? 'tsconfig.json'
         : 'tsconfig.spec.json';
     const rootOffset = (0, devkit_1.offsetFromRoot)(options.e2eProjectRoot);
-    const coverageDirectory = isUsingTsSolutionConfig
+    const coverageDirectory = options.isUsingTsSolutionConfig
         ? 'test-output/jest/coverage'
         : (0, devkit_1.joinPathFragments)(rootOffset, 'coverage', options.e2eProjectName);
+    const projectSimpleName = options.project.split('/').pop();
     if (options.projectType === 'server') {
         (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/server/common'), options.e2eProjectRoot, {
             ...options,
-            ...(0, devkit_1.names)(options.rootProject ? 'server' : options.project),
+            ...(0, devkit_1.names)(options.rootProject ? 'server' : projectSimpleName),
             tsConfigFile,
             offsetFromRoot: rootOffset,
             jestPreset,
             coverageDirectory,
-            isUsingTsSolutionConfig,
             tmpl: '',
         });
         if (options.isNest) {
             (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/server/nest'), options.e2eProjectRoot, {
                 ...options,
-                ...(0, devkit_1.names)(options.rootProject ? 'server' : options.project),
+                ...(0, devkit_1.names)(options.rootProject ? 'server' : projectSimpleName),
                 tsConfigFile,
                 offsetFromRoot: rootOffset,
                 tmpl: '',
@@ -126,17 +129,16 @@ async function e2eProjectGeneratorInternal(host, _options) {
         const mainFile = appProject.targets.build?.options?.outputPath;
         (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/cli'), options.e2eProjectRoot, {
             ...options,
-            ...(0, devkit_1.names)(options.rootProject ? 'cli' : options.project),
+            ...(0, devkit_1.names)(options.rootProject ? 'cli' : projectSimpleName),
             mainFile,
             tsConfigFile,
             offsetFromRoot: rootOffset,
             jestPreset,
             coverageDirectory,
-            isUsingTsSolutionConfig,
             tmpl: '',
         });
     }
-    if (isUsingTsSolutionConfig) {
+    if (options.isUsingTsSolutionConfig) {
         (0, add_swc_config_1.addSwcTestConfig)(host, options.e2eProjectRoot, 'es6');
         (0, devkit_1.generateFiles)(host, path.join(__dirname, 'files/ts-solution'), options.e2eProjectRoot, {
             ...options,
@@ -177,7 +179,7 @@ async function e2eProjectGeneratorInternal(host, _options) {
             ]);
         }
     }
-    if (isUsingTsSolutionConfig) {
+    if (options.isUsingTsSolutionConfig) {
         (0, devkit_1.updateJson)(host, 'tsconfig.json', (json) => {
             json.references ??= [];
             const e2eRef = `./${options.e2eProjectRoot}`;
@@ -189,8 +191,8 @@ async function e2eProjectGeneratorInternal(host, _options) {
     }
     // If we are using the new TS solution
     // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
-    if (isUsingTsSolutionConfig) {
-        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(host, options.e2eProjectRoot);
+    if (options.isUsingTsSolutionConfig) {
+        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(host, options.e2eProjectRoot);
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(host);
@@ -201,22 +203,30 @@ async function e2eProjectGeneratorInternal(host, _options) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 async function normalizeOptions(tree, options) {
-    options.directory = options.directory ?? `${options.project}-e2e`;
-    const { projectName: e2eProjectName, projectRoot: e2eProjectRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+    let directory = options.rootProject ? 'e2e' : options.directory;
+    if (!directory) {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+        directory = `${projectConfig.root}-e2e`;
+    }
+    const { projectName: e2eProjectName, projectRoot: e2eProjectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
         name: options.name,
-        projectType: 'library',
-        directory: options.rootProject ? 'e2e' : options.directory,
+        projectType: 'application',
+        directory,
     });
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
         nxJson.useInferencePlugins !== false;
+    const isUsingTsSolutionConfig = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
     return {
         addPlugin,
         ...options,
         e2eProjectRoot,
         e2eProjectName,
+        importPath,
         port: options.port ?? 3000,
         rootProject: !!options.rootProject,
+        isUsingTsSolutionConfig,
+        useProjectJson: options.useProjectJson ?? !isUsingTsSolutionConfig,
     };
 }
 exports.default = e2eProjectGenerator;

package/src/generators/e2e-project/files/server/common/src/support/global-setup.ts__tmpl__

@@ -1,3 +1,5 @@
+import { waitForPortOpen } from '@nx/node/utils';
+
 /* eslint-disable */
 var __TEARDOWN_MESSAGE__: string;
 
@@ -5,6 +7,10 @@ module.exports = async function() {
   // Start services that that the app needs to run (e.g. database, docker-compose, etc.).
   console.log('\nSetting up...\n');
 
+  const host = process.env.HOST ?? 'localhost';
+  const port = process.env.PORT ? Number(process.env.PORT) : <%= port %>;
+  await waitForPortOpen(port, { host });
+
   // Hint: Use `globalThis` to pass variables to global teardown.
   globalThis.__TEARDOWN_MESSAGE__ = '\nTearing down...\n';
 };

package/src/generators/e2e-project/files/server/common/src/support/global-teardown.ts__tmpl__

@@ -1,7 +1,10 @@
+import { killPort } from '@nx/node/utils';
 /* eslint-disable */
 
 module.exports = async function() {
   // Put clean up logic here (e.g. stopping services, docker-compose, etc.).
   // Hint: `globalThis` is shared between setup and teardown.
+  const port = process.env.PORT ? Number(process.env.PORT) : <%= port %>;
+  await killPort(port);
   console.log(globalThis.__TEARDOWN_MESSAGE__);
 };

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

@@ -9,4 +9,5 @@ export interface Schema {
   isNest?: boolean;
   skipFormat?: boolean;
   addPlugin?: boolean;
+  useProjectJson?: boolean;
 }

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

@@ -59,6 +59,10 @@
       "default": false,
       "hidden": true,
       "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": ["project"]

package/src/generators/library/library.js

@@ -12,11 +12,11 @@ const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
 const sort_fields_1 = require("@nx/js/src/utils/package-json/sort-fields");
 async function libraryGenerator(tree, schema) {
     return await libraryGeneratorInternal(tree, {
         addPlugin: false,
+        useProjectJson: true,
         ...schema,
     });
 }
@@ -25,21 +25,21 @@ async function libraryGeneratorInternal(tree, schema) {
     // If we are using the new TS solution
     // We need to update the workspace file (package.json or pnpm-workspaces.yaml) to include the new project
     if (options.isUsingTsSolutionConfig) {
-        (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
+        await (0, ts_solution_setup_1.addProjectToTsSolutionWorkspace)(tree, options.projectRoot);
     }
     const tasks = [];
     if (options.publishable === true && !schema.importPath) {
         throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
     }
     // Create `package.json` first because @nx/js:lib generator will update it.
-    if (options.isUsingTsSolutionConfig ||
+    if (!options.useProjectJson ||
+        options.isUsingTsSolutionConfig ||
         options.publishable ||
         options.buildable) {
         (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), {
-            name: (0, get_import_path_1.getImportPath)(tree, options.name),
+            name: options.importPath,
             version: '0.0.1',
             private: true,
-            files: options.publishable ? ['dist', '!**/*.tsbuildinfo'] : undefined,
         });
     }
     tasks.push(await (0, js_1.libraryGenerator)(tree, {
@@ -50,7 +50,7 @@ async function libraryGeneratorInternal(tree, schema) {
         testEnvironment: 'node',
         skipFormat: true,
         setParserOptionsProject: schema.setParserOptionsProject,
-        useProjectJson: !options.isUsingTsSolutionConfig,
+        useProjectJson: options.useProjectJson,
     }));
     updatePackageJson(tree, options);
     tasks.push(await (0, init_1.initGenerator)(tree, {
@@ -75,7 +75,7 @@ async function libraryGeneratorInternal(tree, schema) {
 }
 exports.default = libraryGenerator;
 async function normalizeOptions(tree, options) {
-    await (0, project_name_and_root_utils_1.ensureProjectName)(tree, options, 'library');
+    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'library');
     const { projectName, names: projectNames, projectRoot, importPath, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
         name: options.name,
         projectType: 'library',
@@ -96,13 +96,12 @@ async function normalizeOptions(tree, options) {
     return {
         ...options,
         fileName,
-        projectName: isUsingTsSolutionConfig
-            ? (0, get_import_path_1.getImportPath)(tree, projectName)
-            : projectName,
+        projectName: isUsingTsSolutionConfig && !options.name ? importPath : projectName,
         projectRoot,
         parsedTags,
         importPath,
         isUsingTsSolutionConfig,
+        useProjectJson: options.useProjectJson ?? !isUsingTsSolutionConfig,
     };
 }
 function createFiles(tree, options) {

package/src/generators/library/schema.d.ts

@@ -21,4 +21,5 @@ export interface Schema {
   setParserOptionsProject?: boolean;
   compiler: 'tsc' | 'swc';
   addPlugin?: boolean;
+  useProjectJson?: boolean;
 }

package/src/generators/library/schema.json

@@ -123,6 +123,10 @@
       "type": "boolean",
       "description": "Whether or not to configure the ESLint `parserOptions.project`. We do not do this by default for lint performance reasons.",
       "default": false
+    },
+    "useProjectJson": {
+      "type": "boolean",
+      "description": "Use a `project.json` configuration file instead of inlining the Nx configuration in the `package.json` file."
     }
   },
   "required": ["directory"]

package/src/utils/kill-port.d.ts

@@ -0,0 +1,7 @@
+export declare const kill: any;
+/**
+ * Kills the process on the given port
+ * @param port
+ * @param killPortDelay
+ */
+export declare function killPort(port: number, killPortDelay?: number): Promise<boolean>;

package/src/utils/kill-port.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kill = void 0;
+exports.killPort = killPort;
+const devkit_1 = require("@nx/devkit");
+const tcp_port_used_1 = require("tcp-port-used");
+exports.kill = require('kill-port');
+/**
+ * Kills the process on the given port
+ * @param port
+ * @param killPortDelay
+ */
+async function killPort(port, killPortDelay = 2500) {
+    if (await (0, tcp_port_used_1.check)(port)) {
+        let killPortResult;
+        try {
+            devkit_1.logger.info(`Attempting to close port ${port}`);
+            killPortResult = await (0, exports.kill)(port);
+            await new Promise((resolve) => setTimeout(() => resolve(), killPortDelay));
+            if (await (0, tcp_port_used_1.check)(port)) {
+                devkit_1.logger.error(`Port ${port} still open ${JSON.stringify(killPortResult)}`);
+            }
+            else {
+                devkit_1.logger.info(`Port ${port} successfully closed`);
+                return true;
+            }
+        }
+        catch {
+            devkit_1.logger.error(`Port ${port} closing failed`);
+        }
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/src/utils/wait-for-port-open.d.ts

@@ -0,0 +1,24 @@
+interface WaitForPortOpenOptions {
+    /**
+     * The host to connect to
+     * @default 'localhost'
+     */
+    host?: string;
+    /**
+     * The number of retries to attempt
+     * @default 120
+     */
+    retries?: number;
+    /**
+     * The delay between retries
+     * @default 1000
+     */
+    retryDelay?: number;
+}
+/**
+ * Waits for the given port to be open
+ * @param port
+ * @param options
+ */
+export declare function waitForPortOpen(port: number, options?: WaitForPortOpenOptions): Promise<void>;
+export {};

package/src/utils/wait-for-port-open.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForPortOpen = waitForPortOpen;
+const net = require("net");
+const devkit_1 = require("@nx/devkit");
+/**
+ * Waits for the given port to be open
+ * @param port
+ * @param options
+ */
+function waitForPortOpen(port, options = {}) {
+    const host = options.host ?? 'localhost';
+    const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT'];
+    return new Promise((resolve, reject) => {
+        const checkPort = (retries = options.retries ?? 120) => {
+            const client = new net.Socket();
+            const cleanupClient = () => {
+                client.removeAllListeners('connect');
+                client.removeAllListeners('error');
+                client.end();
+                client.destroy();
+                client.unref();
+            };
+            client.once('connect', () => {
+                cleanupClient();
+                resolve();
+            });
+            client.once('error', (err) => {
+                if (retries === 0 || !allowedErrorCodes.includes(err['code'])) {
+                    if (process.env['NX_VERBOSE_LOGGING'] === 'true') {
+                        devkit_1.logger.info(`Error connecting on ${host}:${port}: ${err['code'] || err}`);
+                    }
+                    cleanupClient();
+                    reject(err);
+                }
+                else {
+                    setTimeout(() => checkPort(retries - 1), options.retryDelay ?? 1000);
+                }
+            });
+            if (process.env['NX_VERBOSE_LOGGING'] === 'true') {
+                devkit_1.logger.info(`Connecting on ${host}:${port}`);
+            }
+            client.connect({ port, host });
+        };
+        checkPort();
+    });
+}

package/utils.d.ts

@@ -0,0 +1,2 @@
+export { waitForPortOpen } from './src/utils/wait-for-port-open';
+export { killPort } from './src/utils/kill-port';

package/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killPort = exports.waitForPortOpen = void 0;
+var wait_for_port_open_1 = require("./src/utils/wait-for-port-open");
+Object.defineProperty(exports, "waitForPortOpen", { enumerable: true, get: function () { return wait_for_port_open_1.waitForPortOpen; } });
+var kill_port_1 = require("./src/utils/kill-port");
+Object.defineProperty(exports, "killPort", { enumerable: true, get: function () { return kill_port_1.killPort; } });