@nx/node 0.0.0-pr-22179-271588f

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

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "SchematicsNxNodeE2eProject",
+  "title": "Node E2E Project Generator",
+  "description": "Generate an E2E project for a Node server application.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-dropdown": "project",
+      "x-prompt": "What project is this for?"
+    },
+    "directory": {
+      "description": "The directory of the e2e project.",
+      "type": "string",
+      "x-priority": "important"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "name": {
+      "description": "The name of the e2e project. Defaults to the project name with '-e2e' suffix.",
+      "type": "string"
+    },
+    "projectType": {
+      "description": "The type of application that is being tested.",
+      "type": "string",
+      "enum": ["server", "cli"],
+      "default": "server"
+    },
+    "port": {
+      "description": "The port that the server runs on. Only application for server application.",
+      "type": "number",
+      "default": 3000
+    },
+    "linter": {
+      "description": "Linter to be used for the E2E project",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "isNest": {
+      "description": "Is the E2E server project nest",
+      "type": "boolean",
+      "default": false,
+      "hidden": true,
+      "x-priority": "internal"
+    },
+    "rootProject": {
+      "description": "Create node application at the root of the workspace.",
+      "type": "boolean",
+      "default": false,
+      "hidden": true,
+      "x-priority": "internal"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "hidden": true,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["project"]
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function initGenerator(tree: Tree, options: Schema): Promise<GeneratorCallback>;
+export default initGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+function updateDependencies(tree, options) {
+    const tasks = [];
+    tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/node'], []));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/node': versions_1.nxVersion }, undefined, options.keepExistingVersions));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+async function initGenerator(tree, options) {
+    let installTask = () => { };
+    if (!options.skipPackageJson) {
+        installTask = updateDependencies(tree, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.initGenerator = initGenerator;
+exports.default = initGenerator;

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

@@ -0,0 +1,5 @@
+export interface Schema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxNodeInit",
+  "title": "Init Node Plugin",
+  "description": "Init Node Plugin.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/generators/library/files/lib/package.json__tmpl__

@@ -0,0 +1,4 @@
+{
+  "name": "<%= importPath %>",
+  "version": "0.0.1"
+}

package/src/generators/library/files/lib/src/lib/__fileName__.spec.ts__tmpl__

@@ -0,0 +1,7 @@
+import { <%= propertyName %> } from './<%= fileName %>';
+
+describe('<%= propertyName %>', () => {
+    it('should work', () => {
+        expect(<%= propertyName %>()).toEqual('<%= name %>');
+    })
+})

package/src/generators/library/files/lib/src/lib/__fileName__.ts__tmpl__

@@ -0,0 +1,3 @@
+export function <%= propertyName %>(): string {
+    return '<%= name %>';
+}

package/src/generators/library/files/lib/tsconfig.lib.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "<%= offsetFromRoot %>dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}

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

@@ -0,0 +1,12 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export interface NormalizedSchema extends Schema {
+    fileName: string;
+    projectName: string;
+    projectRoot: string;
+    parsedTags: string[];
+    compiler: 'swc' | 'tsc';
+}
+export declare function libraryGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function libraryGeneratorInternal(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default libraryGenerator;

package/src/generators/library/library.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.libraryGeneratorInternal = exports.libraryGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const js_1 = require("@nx/js");
+const add_swc_config_1 = require("@nx/js/src/utils/swc/add-swc-config");
+const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+const path_1 = require("path");
+const versions_1 = require("../../utils/versions");
+const init_1 = require("../init/init");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+async function libraryGenerator(tree, schema) {
+    return await libraryGeneratorInternal(tree, {
+        addPlugin: false,
+        projectNameAndRootFormat: 'derived',
+        ...schema,
+    });
+}
+exports.libraryGenerator = libraryGenerator;
+async function libraryGeneratorInternal(tree, schema) {
+    const options = await normalizeOptions(tree, schema);
+    const tasks = [
+        await (0, init_1.initGenerator)(tree, {
+            ...options,
+            skipFormat: true,
+        }),
+    ];
+    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)`);
+    }
+    const libraryInstall = await (0, js_1.libraryGenerator)(tree, {
+        ...options,
+        bundler: schema.buildable ? 'tsc' : 'none',
+        includeBabelRc: schema.babelJest,
+        importPath: options.importPath,
+        testEnvironment: 'node',
+        skipFormat: true,
+        setParserOptionsProject: options.setParserOptionsProject,
+    });
+    tasks.push(libraryInstall);
+    createFiles(tree, options);
+    if (options.js) {
+        (0, devkit_1.updateTsConfigsToJs)(tree, options);
+    }
+    updateProject(tree, options);
+    tasks.push(ensureDependencies(tree));
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.libraryGeneratorInternal = libraryGeneratorInternal;
+exports.default = libraryGenerator;
+async function normalizeOptions(tree, options) {
+    const { projectName, names: projectNames, projectRoot, importPath, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/node:library',
+    });
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const fileName = getCaseAwareFileName({
+        fileName: options.simpleModuleName
+            ? projectNames.projectSimpleName
+            : projectNames.projectFileName,
+        pascalCaseFiles: options.pascalCaseFiles,
+    });
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    return {
+        ...options,
+        fileName,
+        projectName,
+        projectRoot,
+        parsedTags,
+        importPath,
+    };
+}
+function getCaseAwareFileName(options) {
+    const normalized = (0, devkit_1.names)(options.fileName);
+    return options.pascalCaseFiles ? normalized.className : normalized.fileName;
+}
+function createFiles(tree, options) {
+    const { className, name, propertyName } = (0, devkit_1.names)(options.fileName);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files/lib'), options.projectRoot, {
+        ...options,
+        className,
+        name,
+        propertyName,
+        tmpl: '',
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(options.projectRoot),
+    });
+    if (options.unitTestRunner === 'none') {
+        tree.delete((0, path_1.join)(options.projectRoot, `./src/lib/${options.fileName}.spec.ts`));
+    }
+    if (!options.publishable && !options.buildable) {
+        tree.delete((0, path_1.join)(options.projectRoot, 'package.json'));
+    }
+    if (options.js) {
+        (0, devkit_1.toJS)(tree);
+    }
+}
+function updateProject(tree, options) {
+    if (!options.publishable && !options.buildable) {
+        return;
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.projectName);
+    const rootProject = options.projectRoot === '.' || options.projectRoot === '';
+    project.targets = project.targets || {};
+    (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, `@nx/js:${options.compiler}`);
+    project.targets.build = {
+        executor: `@nx/js:${options.compiler}`,
+        outputs: ['{options.outputPath}'],
+        options: {
+            outputPath: (0, devkit_1.joinPathFragments)('dist', rootProject ? options.projectName : options.projectRoot),
+            tsConfig: `${options.projectRoot}/tsconfig.lib.json`,
+            packageJson: `${options.projectRoot}/package.json`,
+            main: `${options.projectRoot}/src/index` + (options.js ? '.js' : '.ts'),
+            assets: [`${options.projectRoot}/*.md`],
+        },
+    };
+    if (options.compiler === 'swc') {
+        (0, add_swc_dependencies_1.addSwcDependencies)(tree);
+        (0, add_swc_config_1.addSwcConfig)(tree, options.projectRoot);
+    }
+    if (options.rootDir) {
+        project.targets.build.options.srcRootForCompilationRoot = options.rootDir;
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.projectName, project);
+}
+function ensureDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, { tslib: versions_1.tslibVersion }, { '@types/node': versions_1.typesNodeVersion });
+}

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

@@ -0,0 +1,27 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+
+export interface Schema {
+  name: string;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  simpleModuleName?: boolean;
+  skipTsConfig?: boolean;
+  skipFormat?: boolean;
+  tags?: string;
+  unitTestRunner?: 'jest' | 'none';
+  linter?: Linter;
+  buildable?: boolean;
+  publishable?: boolean;
+  importPath?: string;
+  testEnvironment?: 'jsdom' | 'node';
+  rootDir?: string;
+  babelJest?: boolean;
+  js?: boolean;
+  pascalCaseFiles?: boolean;
+  strict?: boolean;
+  standaloneConfig?: boolean;
+  setParserOptionsProject?: boolean;
+  compiler: 'tsc' | 'swc';
+  addPlugin?: boolean;
+}

package/src/generators/library/schema.json

@@ -0,0 +1,136 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxNodeLibrary",
+  "title": "Create a Node Library for Nx",
+  "description": "Create a Node Library for an Nx workspace.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g lib mylib --directory=myapp",
+      "description": "Generate `libs/myapp/mylib`"
+    }
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Library name",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the library?",
+      "pattern": "(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the lib is placed",
+      "alias": "dir",
+      "x-priority": "important"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "simpleModuleName": {
+      "description": "Keep the module name simple (when using `--directory`).",
+      "type": "boolean",
+      "default": false
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint"],
+      "default": "eslint"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "default": "jest"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the library (used for linting).",
+      "alias": "t"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipTsConfig": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not update `tsconfig.base.json` for development experience.",
+      "x-priority": "internal"
+    },
+    "publishable": {
+      "type": "boolean",
+      "description": "Create a publishable library.",
+      "x-priority": "important"
+    },
+    "buildable": {
+      "type": "boolean",
+      "default": false,
+      "description": "Generate a buildable library.",
+      "x-priority": "important"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "swc"],
+      "default": "tsc",
+      "description": "The compiler used by the build and test targets.",
+      "x-priority": "important"
+    },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used to import it, like `@myorg/my-awesome-lib`. Must be a valid npm name."
+    },
+    "rootDir": {
+      "type": "string",
+      "description": "Sets the `rootDir` for TypeScript compilation. When not defined, it uses the project's root property, or `srcRootForCompilationRoot` if it is defined."
+    },
+    "testEnvironment": {
+      "type": "string",
+      "enum": ["jsdom", "node"],
+      "description": "The test environment to use if `unitTestRunner` is set to `jest`.",
+      "default": "jsdom"
+    },
+    "babelJest": {
+      "type": "boolean",
+      "description": "Use `babel` instead of `ts-jest`.",
+      "default": false
+    },
+    "pascalCaseFiles": {
+      "type": "boolean",
+      "description": "Use pascal case file names.",
+      "alias": "P",
+      "default": false
+    },
+    "js": {
+      "type": "boolean",
+      "description": "Generate JavaScript files rather than TypeScript files.",
+      "default": false
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "Whether to enable tsconfig strict mode or not.",
+      "default": false
+    },
+    "standaloneConfig": {
+      "description": "Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.",
+      "type": "boolean",
+      "default": true,
+      "x-deprecated": "Nx only supports standaloneConfig"
+    },
+    "setParserOptionsProject": {
+      "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
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/setup-docker/files/Dockerfile__tmpl__

@@ -0,0 +1,24 @@
+# This file is generated by Nx.
+#
+# Build the docker image with `npx nx docker-build <%= project %>`.
+# Tip: Modify "docker-build" options in project.json to change docker build args.
+#
+# Run the container with `docker run -p 3000:3000 -t <%= project %>`.
+FROM docker.io/node:lts-alpine
+
+ENV HOST=0.0.0.0
+ENV PORT=3000
+
+WORKDIR /app
+
+RUN addgroup --system <%= project %> && \
+          adduser --system -G <%= project %> <%= project %>
+
+COPY <%= buildLocation %> <%= project %>
+RUN chown -R <%= project %>:<%= project %> .
+
+# You can remove this install step if you build with `--bundle` option.
+# The bundled output will include external dependencies.
+RUN npm --prefix <%= project %> --omit=dev -f install
+
+CMD [ "node", "<%= project %>" ]

package/src/generators/setup-docker/schema.d.ts

@@ -0,0 +1,6 @@
+export interface SetUpDockerOptions {
+  project?: string;
+  targetName?: string;
+  buildTarget?: string;
+  skipFormat?: boolean;
+}

package/src/generators/setup-docker/schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "SchematicsNxSetupDocker",
+  "title": "Nx Node Docker Options Schema",
+  "description": "Nx Node Docker Options Schema.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "description": "The name of the project",
+      "$default": {
+        "$source": "projectName"
+      },
+      "type": "string",
+      "x-prompt": "What project would you like to add a Dockerfile to?",
+      "x-priority": "important"
+    },
+    "targetName": {
+      "description": "The name of the target to create",
+      "type": "string",
+      "default": "docker-build"
+    },
+    "buildTargetName": {
+      "description": "The name of the build target",
+      "type": "string",
+      "default": "build"
+    }
+  }
+}

package/src/generators/setup-docker/setup-docker.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { SetUpDockerOptions } from './schema';
+export declare function updateProjectConfig(tree: Tree, options: SetUpDockerOptions): void;
+export declare function setupDockerGenerator(tree: Tree, setupOptions: SetUpDockerOptions): Promise<GeneratorCallback>;
+export default setupDockerGenerator;

package/src/generators/setup-docker/setup-docker.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupDockerGenerator = exports.updateProjectConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function normalizeOptions(tree, setupOptions) {
+    return {
+        ...setupOptions,
+        project: setupOptions.project ?? (0, devkit_1.readNxJson)(tree).defaultProject,
+        targetName: setupOptions.targetName ?? 'docker-build',
+        buildTarget: setupOptions.buildTarget ?? 'build',
+    };
+}
+function addDocker(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (!project || !options.targetName) {
+        return;
+    }
+    if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'DockerFile'))) {
+        devkit_1.logger.info(`Skipping setup since a Dockerfile already exists inside ${project.root}`);
+    }
+    else {
+        const outputPath = project.targets[`${options.buildTarget}`]?.options.outputPath;
+        (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, './files'), project.root, {
+            tmpl: '',
+            app: project.sourceRoot,
+            buildLocation: outputPath,
+            project: options.project,
+        });
+    }
+}
+function updateProjectConfig(tree, options) {
+    let projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    projectConfig.targets[`${options.targetName}`] = {
+        dependsOn: [`${options.buildTarget}`],
+        command: `docker build -f ${(0, devkit_1.joinPathFragments)(projectConfig.root, 'Dockerfile')} . -t ${options.project}`,
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+}
+exports.updateProjectConfig = updateProjectConfig;
+async function setupDockerGenerator(tree, setupOptions) {
+    const tasks = [];
+    const options = normalizeOptions(tree, setupOptions);
+    // Should check if the node project exists
+    addDocker(tree, options);
+    updateProjectConfig(tree, options);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.setupDockerGenerator = setupDockerGenerator;
+exports.default = setupDockerGenerator;

package/src/migrations/update-16-0-0/update-webpack-executor.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0/update-webpack-executor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function update(tree) {
+    const migrateProject = (options, projectName, targetName) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        projectConfig.targets[targetName].executor = '@nx/webpack:webpack';
+        projectConfig.targets[targetName].options.compiler = 'tsc';
+        projectConfig.targets[targetName].options.target = 'node';
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+    };
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/node:webpack', migrateProject);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/node:webpack', migrateProject);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/node', '@nx/node');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-3-1/update-webpack-executor.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;