@nx/webpack 19.4.0-beta.1 → 19.4.0-beta.2

package/src/plugins/plugin.js

@@ -1,61 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = exports.createDependencies = void 0;
+exports.createNodes = exports.createNodesV2 = exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
-const path_1 = require("path");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const js_1 = require("@nx/js");
 const fs_1 = require("fs");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const path_1 = require("path");
 const read_webpack_options_1 = require("../utils/webpack/read-webpack-options");
 const resolve_user_defined_webpack_config_1 = require("../utils/webpack/resolve-user-defined-webpack-config");
-const js_1 = require("@nx/js");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
-const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'webpack.hash');
-const targetsCache = readTargetsCache();
-function readTargetsCache() {
+function readTargetsCache(cachePath) {
     return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
 }
-function writeTargetsToCache() {
-    const oldCache = readTargetsCache();
-    (0, devkit_1.writeJsonFile)(cachePath, {
-        ...oldCache,
-        ...targetsCache,
-    });
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
 }
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
 const createDependencies = () => {
-    writeTargetsToCache();
     return [];
 };
 exports.createDependencies = createDependencies;
+const webpackConfigGlob = '**/webpack.config.{js,ts,mjs,cjs}';
+exports.createNodesV2 = [
+    webpackConfigGlob,
+    async (configFilePaths, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `webpack-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        const normalizedOptions = normalizeOptions(options);
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache), configFilePaths, normalizedOptions, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
 exports.createNodes = [
-    '**/webpack.config.{js,ts,mjs,cjs}',
+    webpackConfigGlob,
     async (configFilePath, options, context) => {
-        options ??= {};
-        options.buildTargetName ??= 'build';
-        options.serveTargetName ??= 'serve';
-        options.serveStaticTargetName ??= 'serve-static';
-        options.previewTargetName ??= 'preview';
-        const projectRoot = (0, path_1.dirname)(configFilePath);
-        // Do not create a project if package.json and project.json isn't there.
-        const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
-        if (!siblingFiles.includes('package.json') &&
-            !siblingFiles.includes('project.json')) {
-            return {};
-        }
-        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [(0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
-        const targets = targetsCache[hash]
-            ? targetsCache[hash]
-            : await createWebpackTargets(configFilePath, projectRoot, options, context);
-        return {
-            projects: {
-                [projectRoot]: {
-                    projectType: 'application',
-                    targets,
-                },
-            },
-        };
+        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        const normalizedOptions = normalizeOptions(options);
+        return createNodesInternal(configFilePath, normalizedOptions, context, {});
     },
 ];
+async function createNodesInternal(configFilePath, options, context, targetsCache) {
+    const projectRoot = (0, path_1.dirname)(configFilePath);
+    // Do not create a project if package.json and project.json isn't there.
+    const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+    if (!siblingFiles.includes('package.json') &&
+        !siblingFiles.includes('project.json')) {
+        return {};
+    }
+    const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [(0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
+    targetsCache[hash] ??= await createWebpackTargets(configFilePath, projectRoot, options, context);
+    const { targets, metadata } = targetsCache[hash];
+    return {
+        projects: {
+            [projectRoot]: {
+                projectType: 'application',
+                targets,
+                metadata,
+            },
+        },
+    };
+}
 async function createWebpackTargets(configFilePath, projectRoot, options, context) {
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const webpackConfig = (0, resolve_user_defined_webpack_config_1.resolveUserDefinedWebpackConfig)((0, path_1.join)(context.workspaceRoot, configFilePath), (0, js_1.getRootTsConfigPath)(), true);
@@ -105,7 +118,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             spa: true,
         },
     };
-    return targets;
+    return { targets, metadata: {} };
 }
 function normalizeOutputPath(outputPath, projectRoot) {
     if (!outputPath) {
@@ -135,3 +148,11 @@ function normalizeOutputPath(outputPath, projectRoot) {
         }
     }
 }
+function normalizeOptions(options) {
+    return {
+        buildTargetName: options?.buildTargetName ?? 'build',
+        serveTargetName: options?.serveTargetName ?? 'serve',
+        serveStaticTargetName: options?.serveStaticTargetName ?? 'serve-static',
+        previewTargetName: options?.previewTargetName ?? 'preview',
+    };
+}

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.d.ts

@@ -0,0 +1,29 @@
+import { NxWebpackExecutionContext } from '../../utils/config';
+import { NxAppWebpackPluginOptions } from '../nx-webpack-plugin/nx-app-webpack-plugin-options';
+import { Configuration } from 'webpack';
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the webpack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+      withNx(),
+      (config) => {
+        return config;
+      }
+  );
+  
+Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+The context options are created and passed to the legacy plugin function.
+
+module.exports = async () => ({
+  plugins: [
+  ...otherPlugins,
+    await nxUseLegacyPlugin(require({path}), options),
+  ],
+});
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Webpack configuration
+ */
+export declare function useLegacyNxPlugin(fn: (config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>, executorOptions: NxAppWebpackPluginOptions): Promise<(config: Configuration) => Promise<Configuration>>;

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLegacyNxPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../nx-webpack-plugin/lib/normalize-options");
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the webpack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+      withNx(),
+      (config) => {
+        return config;
+      }
+  );
+  
+Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+The context options are created and passed to the legacy plugin function.
+
+module.exports = async () => ({
+  plugins: [
+  ...otherPlugins,
+    await nxUseLegacyPlugin(require({path}), options),
+  ],
+});
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Webpack configuration
+ */
+async function useLegacyNxPlugin(fn, executorOptions) {
+    if (global.NX_GRAPH_CREATION) {
+        return;
+    }
+    const options = (0, normalize_options_1.normalizeOptions)(executorOptions);
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectName = process.env.NX_TASK_TARGET_PROJECT;
+    const project = projectGraph.nodes[projectName];
+    const targetName = process.env.NX_TASK_TARGET_TARGET;
+    const context = {
+        cwd: process.cwd(),
+        isVerbose: process.env.NX_VERBOSE_LOGGING === 'true',
+        root: project.data.root,
+        projectGraph: (0, devkit_1.readCachedProjectGraph)(),
+        target: project.data.targets[targetName],
+        targetName: targetName,
+        projectName: projectName,
+    };
+    const configuration = process.env.NX_TASK_TARGET_CONFIGURATION;
+    return async (config) => {
+        const ctx = {
+            context,
+            options: options,
+            configuration,
+        };
+        return await fn(config, ctx);
+    };
+}
+exports.useLegacyNxPlugin = useLegacyNxPlugin;

package/src/utils/module-federation/get-remotes-for-host.js

@@ -48,7 +48,7 @@ function getRemotes(devRemotes, skipRemotes, config, context, pathToManifestFile
         devkit_1.logger.info(`Remotes not served automatically: ${[...remotesToSkip.values()].join(', ')}`);
     }
     const knownRemotes = Array.from(collectedRemotes).filter((r) => !remotesToSkip.has(r));
-    const knownDynamicRemotes = dynamicRemotes.filter((r) => !remotesToSkip.has(r));
+    const knownDynamicRemotes = dynamicRemotes.filter((r) => !remotesToSkip.has(r) && context.projectGraph.nodes[r]);
     devkit_1.logger.info(`NX Starting module federation dev-server for ${chalk.bold(context.projectName)} with ${[...knownRemotes, ...knownDynamicRemotes].length} remotes`);
     const devServeApps = new Set(!devRemotes
         ? []