@nx/module-federation 20.5.0-beta.2 → 20.5.0-beta.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/module-federation",
   "description": "The Nx Plugin for Module Federation contains executors and utilities that support building applications using Module Federation.",
-  "version": "20.5.0-beta.2",
+  "version": "20.5.0-beta.4",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -25,19 +25,20 @@
   "executors": "./executors.json",
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "20.5.0-beta.2",
-    "@nx/js": "20.5.0-beta.2",
-    "@nx/web": "20.5.0-beta.2",
+    "@nx/devkit": "20.5.0-beta.4",
+    "@nx/js": "20.5.0-beta.4",
+    "@nx/web": "20.5.0-beta.4",
     "picocolors": "^1.1.0",
     "webpack": "^5.88.0",
-    "@rspack/core": "^1.1.5",
     "@module-federation/enhanced": "^0.8.8",
     "@module-federation/node": "^2.6.21",
     "@module-federation/sdk": "^0.8.8",
     "express": "^4.21.2",
     "http-proxy-middleware": "^3.0.3"
   },
-  "peerDependencies": {},
+  "peerDependencies": {
+    "@rspack/core": "^1.1.5"
+  },
   "nx-migrations": {
     "migrations": "./migrations.json"
   },

package/rspack.d.ts

@@ -1,2 +1,4 @@
 export * from './src/with-module-federation/rspack/with-module-federation';
 export * from './src/with-module-federation/rspack/with-module-federation-ssr';
+export * from './src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-plugin';
+export * from './src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-dev-server-plugin';

package/rspack.js

@@ -3,3 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./src/with-module-federation/rspack/with-module-federation"), exports);
 tslib_1.__exportStar(require("./src/with-module-federation/rspack/with-module-federation-ssr"), exports);
+tslib_1.__exportStar(require("./src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-plugin"), exports);
+tslib_1.__exportStar(require("./src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-dev-server-plugin"), exports);

package/src/plugins/models/index.d.ts

@@ -0,0 +1,14 @@
+export interface NxModuleFederationDevServerConfig {
+    host?: string;
+    staticRemotesPort?: number;
+    pathToManifestFile?: string;
+    ssl?: boolean;
+    sslCert?: string;
+    sslKey?: string;
+    parallel?: number;
+    devRemoteFindOptions?: DevRemoteFindOptions;
+}
+export interface DevRemoteFindOptions {
+    retries?: number;
+    retryDelay?: number;
+}

package/src/plugins/models/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-dev-server-plugin.d.ts

@@ -0,0 +1,13 @@
+import { Compiler, RspackPluginInstance } from '@rspack/core';
+import { ModuleFederationConfig } from '../../../utils/models';
+import { NxModuleFederationDevServerConfig } from '../../models';
+export declare class NxModuleFederationDevServerPlugin implements RspackPluginInstance {
+    private _options;
+    private nxBin;
+    constructor(_options: {
+        config: ModuleFederationConfig;
+        devServerConfig: NxModuleFederationDevServerConfig;
+    });
+    apply(compiler: Compiler): void;
+    private setup;
+}

package/src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-dev-server-plugin.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxModuleFederationDevServerPlugin = void 0;
+const core_1 = require("@rspack/core");
+const pc = require("picocolors");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const utils_1 = require("../../utils");
+const PLUGIN_NAME = 'NxModuleFederationDevServerPlugin';
+class NxModuleFederationDevServerPlugin {
+    constructor(_options) {
+        this._options = _options;
+        this.nxBin = require.resolve('nx/bin/nx');
+    }
+    apply(compiler) {
+        compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
+            const staticRemotesConfig = await this.setup();
+            devkit_1.logger.info(`NX Starting module federation dev-server for ${pc.bold(this._options.config.name)} with ${Object.keys(staticRemotesConfig).length} remotes`);
+            const mappedLocationOfRemotes = await (0, utils_1.buildStaticRemotes)(staticRemotesConfig, this._options.devServerConfig, this.nxBin);
+            (0, utils_1.startStaticRemotesFileServer)(staticRemotesConfig, devkit_1.workspaceRoot, this._options.devServerConfig.staticRemotesPort);
+            (0, utils_1.startRemoteProxies)(staticRemotesConfig, mappedLocationOfRemotes, {
+                pathToCert: this._options.devServerConfig.sslCert,
+                pathToKey: this._options.devServerConfig.sslCert,
+            });
+            new core_1.DefinePlugin({
+                'process.env.NX_MF_DEV_REMOTES': process.env.NX_MF_DEV_REMOTES,
+            }).apply(compiler);
+            callback();
+        });
+    }
+    async setup() {
+        const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+        const { projects: workspaceProjects } = (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        const project = workspaceProjects[this._options.config.name];
+        if (!this._options.devServerConfig.pathToManifestFile) {
+            this._options.devServerConfig.pathToManifestFile =
+                (0, utils_1.getDynamicMfManifestFile)(project, devkit_1.workspaceRoot);
+        }
+        else {
+            const userPathToManifestFile = (0, path_1.join)(devkit_1.workspaceRoot, this._options.devServerConfig.pathToManifestFile);
+            if (!(0, fs_1.existsSync)(userPathToManifestFile)) {
+                throw new Error(`The provided Module Federation manifest file path does not exist. Please check the file exists at "${userPathToManifestFile}".`);
+            }
+            else if ((0, path_1.extname)(this._options.devServerConfig.pathToManifestFile) !== '.json') {
+                throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+            }
+            this._options.devServerConfig.pathToManifestFile = userPathToManifestFile;
+        }
+        const { remotes, staticRemotePort } = (0, utils_1.getRemotes)(this._options.config, projectGraph, this._options.devServerConfig.pathToManifestFile);
+        this._options.devServerConfig.staticRemotesPort ??= staticRemotePort;
+        const remotesConfig = (0, utils_1.parseRemotesConfig)(remotes, devkit_1.workspaceRoot, projectGraph);
+        const staticRemotesConfig = await (0, utils_1.getStaticRemotes)(remotesConfig.config ?? {});
+        const devRemotes = remotes.filter((r) => !staticRemotesConfig[r]);
+        process.env.NX_MF_DEV_REMOTES = JSON.stringify([
+            ...(devRemotes.length > 0 ? devRemotes : []),
+            project.name,
+        ]);
+        return staticRemotesConfig ?? {};
+    }
+}
+exports.NxModuleFederationDevServerPlugin = NxModuleFederationDevServerPlugin;

package/src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-plugin.d.ts

@@ -0,0 +1,12 @@
+import { Compiler, RspackPluginInstance } from '@rspack/core';
+import { ModuleFederationConfig, NxModuleFederationConfigOverride } from '../../../utils/models';
+import { NxModuleFederationDevServerConfig } from '../../models';
+export declare class NxModuleFederationPlugin implements RspackPluginInstance {
+    private _options;
+    private configOverride?;
+    constructor(_options: {
+        config: ModuleFederationConfig;
+        devServerConfig?: NxModuleFederationDevServerConfig;
+    }, configOverride?: NxModuleFederationConfigOverride);
+    apply(compiler: Compiler): void;
+}

package/src/plugins/nx-module-federation-plugin/rspack/nx-module-federation-plugin.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxModuleFederationPlugin = void 0;
+const utils_1 = require("../../../with-module-federation/rspack/utils");
+const nx_module_federation_dev_server_plugin_1 = require("./nx-module-federation-dev-server-plugin");
+class NxModuleFederationPlugin {
+    constructor(_options, configOverride) {
+        this._options = _options;
+        this.configOverride = configOverride;
+    }
+    apply(compiler) {
+        if (global.NX_GRAPH_CREATION) {
+            return;
+        }
+        // This is required to ensure Module Federation will build the project correctly
+        compiler.options.optimization.runtimeChunk = false;
+        const isDevServer = !!process.env['WEBPACK_SERVE'];
+        // TODO(colum): Add support for SSR
+        const config = (0, utils_1.getModuleFederationConfig)(this._options.config);
+        const sharedLibraries = config.sharedLibraries;
+        const sharedDependencies = config.sharedDependencies;
+        const mappedRemotes = config.mappedRemotes;
+        new (require('@module-federation/enhanced/rspack').ModuleFederationPlugin)({
+            name: this._options.config.name.replace(/-/g, '_'),
+            filename: 'remoteEntry.js',
+            exposes: this._options.config.exposes,
+            remotes: mappedRemotes,
+            shared: {
+                ...(sharedDependencies ?? {}),
+            },
+            ...(this.configOverride ? this.configOverride : {}),
+            runtimePlugins: this.configOverride
+                ? this.configOverride.runtimePlugins ?? []
+                : [],
+            virtualRuntimeEntry: true,
+        }).apply(compiler);
+        if (sharedLibraries) {
+            sharedLibraries.getReplacementPlugin().apply(compiler);
+        }
+        if (isDevServer) {
+            new nx_module_federation_dev_server_plugin_1.NxModuleFederationDevServerPlugin({
+                config: this._options.config,
+                devServerConfig: {
+                    ...(this._options.devServerConfig ?? {}),
+                    host: this._options.devServerConfig?.host ?? 'localhost',
+                },
+            }).apply(compiler);
+        }
+    }
+}
+exports.NxModuleFederationPlugin = NxModuleFederationPlugin;

package/src/plugins/utils/build-static-remotes.d.ts

@@ -0,0 +1,3 @@
+import { StaticRemoteConfig } from '../../utils';
+import { NxModuleFederationDevServerConfig } from '../models';
+export declare function buildStaticRemotes(staticRemotesConfig: Record<string, StaticRemoteConfig>, options: NxModuleFederationDevServerConfig, nxBin: string): Promise<Record<string, string>>;

package/src/plugins/utils/build-static-remotes.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStaticRemotes = buildStaticRemotes;
+const node_child_process_1 = require("node:child_process");
+const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const devkit_1 = require("@nx/devkit");
+async function buildStaticRemotes(staticRemotesConfig, options, nxBin) {
+    const remotes = Object.keys(staticRemotesConfig);
+    if (!remotes.length) {
+        return;
+    }
+    const mappedLocationOfRemotes = {};
+    for (const app of remotes) {
+        mappedLocationOfRemotes[app] = `http${options.ssl ? 's' : ''}://${options.host}:${options.staticRemotesPort}/${staticRemotesConfig[app].urlSegment}`;
+    }
+    await new Promise((res, rej) => {
+        console.log(`NX Building ${remotes.length} static remotes...`);
+        const staticProcess = (0, node_child_process_1.fork)(nxBin, [
+            'run-many',
+            `--target=build`,
+            `--projects=${remotes.join(',')}`,
+            ...(options.parallel ? [`--parallel=${options.parallel}`] : []),
+        ], {
+            cwd: devkit_1.workspaceRoot,
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        });
+        // File to debug build failures e.g. 2024-01-01T00_00_0_0Z-build.log'
+        const remoteBuildLogFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 
+        // eslint-disable-next-line
+        `${new Date().toISOString().replace(/[:\.]/g, '_')}-build.log`);
+        const stdoutStream = (0, node_fs_1.createWriteStream)(remoteBuildLogFile);
+        staticProcess.stdout?.on('data', (data) => {
+            const ANSII_CODE_REGEX = 
+            // eslint-disable-next-line no-control-regex
+            /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+            const stdoutString = data.toString().replace(ANSII_CODE_REGEX, '');
+            stdoutStream.write(stdoutString);
+            // in addition to writing into the stdout stream, also show error directly in console
+            // so the error is easily discoverable. 'ERROR in' is the key word to search in webpack output.
+            if (stdoutString.includes('ERROR in')) {
+                console.log(stdoutString);
+            }
+            if (stdoutString.includes('Successfully ran target build')) {
+                staticProcess.stdout?.removeAllListeners('data');
+                console.info(`NX Built ${remotes.length} static remotes`);
+                res();
+            }
+        });
+        staticProcess.stderr?.on('data', (data) => console.log(data.toString()));
+        staticProcess.once('exit', (code) => {
+            stdoutStream.end();
+            staticProcess.stdout?.removeAllListeners('data');
+            staticProcess.stderr?.removeAllListeners('data');
+            if (code !== 0) {
+                rej(`Remote failed to start. A complete log can be found in: ${remoteBuildLogFile}`);
+            }
+            else {
+                res();
+            }
+        });
+        process.on('SIGTERM', () => staticProcess.kill('SIGTERM'));
+        process.on('exit', () => staticProcess.kill('SIGTERM'));
+    });
+    return mappedLocationOfRemotes;
+}

package/src/plugins/utils/get-dynamic-manifest-file.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectConfiguration } from '@nx/devkit';
+export declare function getDynamicMfManifestFile(project: ProjectConfiguration, workspaceRoot: string): string | undefined;

package/src/plugins/utils/get-dynamic-manifest-file.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamicMfManifestFile = getDynamicMfManifestFile;
+const path_1 = require("path");
+const fs_1 = require("fs");
+function getDynamicMfManifestFile(project, workspaceRoot) {
+    // {sourceRoot}/assets/module-federation.manifest.json was the generated
+    // path for the manifest file in the past. We now generate the manifest
+    // file at {root}/public/module-federation.manifest.json. This check
+    // ensures that we can still support the old path for backwards
+    // compatibility since old projects may still have the manifest file
+    // at the old path.
+    return [
+        (0, path_1.join)(workspaceRoot, project.root, 'public/module-federation.manifest.json'),
+        (0, path_1.join)(workspaceRoot, project.sourceRoot, 'assets/module-federation.manifest.json'),
+    ].find((path) => (0, fs_1.existsSync)(path));
+}

package/src/plugins/utils/get-remotes.d.ts

@@ -0,0 +1,7 @@
+import { ProjectGraph } from '@nx/devkit';
+import { ModuleFederationConfig } from '../../utils';
+export declare function getRemotes(config: ModuleFederationConfig, projectGraph: ProjectGraph, pathToManifestFile?: string): {
+    remotes: string[];
+    remotePorts: any[];
+    staticRemotePort: number;
+};

package/src/plugins/utils/get-remotes.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemotes = getRemotes;
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("../../utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+function getRemotes(config, projectGraph, pathToManifestFile) {
+    const collectedRemotes = new Set();
+    const { remotes, dynamicRemotes } = extractRemoteProjectsFromConfig(config, pathToManifestFile);
+    remotes.forEach((r) => collectRemoteProjects(r, collectedRemotes, projectGraph));
+    // With dynamic remotes, the manifest file may contain the names with `_` due to MF limitations on naming
+    // The project graph might contain these names with `-` rather than `_`. Check for both.
+    // This can occur after migration of existing remotes past Nx 19.8
+    let normalizedDynamicRemotes = dynamicRemotes.map((r) => {
+        if (projectGraph.nodes[r.replace(/_/g, '-')]) {
+            return r.replace(/_/g, '-');
+        }
+        return r;
+    });
+    const knownDynamicRemotes = normalizedDynamicRemotes.filter((r) => projectGraph.nodes[r]);
+    const remotePorts = [...collectedRemotes, ...knownDynamicRemotes].map((r) => projectGraph.nodes[r].data.targets['serve'].options.port);
+    const staticRemotePort = Math.max(...[...remotePorts]) + 1;
+    return {
+        remotes: Array.from(collectedRemotes),
+        remotePorts,
+        staticRemotePort,
+    };
+}
+function extractRemoteProjectsFromConfig(config, pathToManifestFile) {
+    const remotes = [];
+    const dynamicRemotes = [];
+    if (pathToManifestFile && (0, fs_1.existsSync)(pathToManifestFile)) {
+        const moduleFederationManifestJson = (0, fs_1.readFileSync)(pathToManifestFile, 'utf-8');
+        if (moduleFederationManifestJson) {
+            // This should have shape of
+            // {
+            //   "remoteName": "remoteLocation",
+            // }
+            const parsedManifest = JSON.parse(moduleFederationManifestJson);
+            if (Object.keys(parsedManifest).every((key) => typeof key === 'string' && typeof parsedManifest[key] === 'string')) {
+                dynamicRemotes.push(...Object.keys(parsedManifest));
+            }
+        }
+    }
+    const staticRemotes = config.remotes?.map((r) => (Array.isArray(r) ? r[0] : r)) ?? [];
+    remotes.push(...staticRemotes);
+    return { remotes, dynamicRemotes };
+}
+function collectRemoteProjects(remote, collected, projectGraph) {
+    const remoteProject = projectGraph.nodes[remote]?.data;
+    if (!projectGraph.nodes[remote] || collected.has(remote)) {
+        return;
+    }
+    collected.add(remote);
+    const remoteProjectRoot = remoteProject.root;
+    let remoteProjectTsConfig = ['tsconfig.app.json', 'tsconfig.json']
+        .map((p) => (0, path_1.join)(devkit_1.workspaceRoot, remoteProjectRoot, p))
+        .find((p) => (0, fs_1.existsSync)(p));
+    const remoteProjectConfig = (0, utils_1.getModuleFederationConfig)(remoteProjectTsConfig, devkit_1.workspaceRoot, remoteProjectRoot);
+    const { remotes: remoteProjectRemotes } = extractRemoteProjectsFromConfig(remoteProjectConfig);
+    remoteProjectRemotes.forEach((r) => collectRemoteProjects(r, collected, projectGraph));
+}

package/src/plugins/utils/get-static-remotes.d.ts

@@ -0,0 +1,3 @@
+import { StaticRemoteConfig } from '../../utils';
+import { DevRemoteFindOptions } from '../models';
+export declare function getStaticRemotes(remotesConfig: Record<string, StaticRemoteConfig>, devRemoteFindOptions?: DevRemoteFindOptions): Promise<Record<string, StaticRemoteConfig>>;

package/src/plugins/utils/get-static-remotes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticRemotes = getStaticRemotes;
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+async function getStaticRemotes(remotesConfig, devRemoteFindOptions) {
+    const remotes = Object.keys(remotesConfig);
+    const findStaticRemotesPromises = [];
+    for (const remote of remotes) {
+        findStaticRemotesPromises.push(new Promise((resolve, reject) => {
+            (0, wait_for_port_open_1.waitForPortOpen)(remotesConfig[remote].port, {
+                retries: devRemoteFindOptions?.retries ?? 3,
+                retryDelay: devRemoteFindOptions?.retryDelay ?? 1000,
+            }).then((res) => {
+                resolve(undefined);
+            }, (rej) => {
+                resolve(remote);
+            });
+        }));
+    }
+    const staticRemoteNames = (await Promise.all(findStaticRemotesPromises)).filter(Boolean);
+    let staticRemotesConfig = {};
+    for (const remote of staticRemoteNames) {
+        staticRemotesConfig[remote] = remotesConfig[remote];
+    }
+    return staticRemotesConfig;
+}

package/src/plugins/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './build-static-remotes';
+export * from './get-dynamic-manifest-file';
+export * from './get-remotes';
+export * from './get-static-remotes';
+export * from './parse-remotes-config';
+export * from './start-remote-proxies';
+export * from './start-static-remotes-file-server';

package/src/plugins/utils/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build-static-remotes"), exports);
+tslib_1.__exportStar(require("./get-dynamic-manifest-file"), exports);
+tslib_1.__exportStar(require("./get-remotes"), exports);
+tslib_1.__exportStar(require("./get-static-remotes"), exports);
+tslib_1.__exportStar(require("./parse-remotes-config"), exports);
+tslib_1.__exportStar(require("./start-remote-proxies"), exports);
+tslib_1.__exportStar(require("./start-static-remotes-file-server"), exports);

package/src/plugins/utils/parse-remotes-config.d.ts

@@ -0,0 +1,6 @@
+import { ProjectGraph } from '@nx/devkit';
+import { StaticRemoteConfig } from '../../utils';
+export declare function parseRemotesConfig(remotes: string[] | undefined, workspaceRoot: string, projectGraph: ProjectGraph): {
+    remotes: string[];
+    config: Record<string, StaticRemoteConfig>;
+};

package/src/plugins/utils/parse-remotes-config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRemotesConfig = parseRemotesConfig;
+const path_1 = require("path");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const devkit_1 = require("@nx/devkit");
+function parseRemotesConfig(remotes, workspaceRoot, projectGraph) {
+    if (!remotes?.length) {
+        return { remotes: [], config: undefined };
+    }
+    const config = {};
+    for (const app of remotes) {
+        const projectRoot = projectGraph.nodes[app].data.root;
+        let outputPath = (0, devkit_internals_1.interpolate)(projectGraph.nodes[app].data.targets?.['build']?.options?.outputPath ??
+            projectGraph.nodes[app].data.targets?.['build']?.outputs?.[0] ??
+            `${workspaceRoot ? `${workspaceRoot}/` : ''}${projectGraph.nodes[app].data.root}/dist`, {
+            projectName: projectGraph.nodes[app].data.name,
+            projectRoot,
+            workspaceRoot,
+        });
+        if (outputPath.startsWith(projectRoot)) {
+            outputPath = (0, devkit_1.joinPathFragments)(workspaceRoot, outputPath);
+        }
+        const basePath = (0, path_1.dirname)(outputPath);
+        const urlSegment = app;
+        const port = projectGraph.nodes[app].data.targets?.['serve']?.options.port;
+        config[app] = { basePath, outputPath, urlSegment, port };
+    }
+    return { remotes, config };
+}

package/src/plugins/utils/start-remote-proxies.d.ts

@@ -0,0 +1,5 @@
+import { StaticRemoteConfig } from '../../utils';
+export declare function startRemoteProxies(staticRemotesConfig: Record<string, StaticRemoteConfig>, mappedLocationsOfRemotes: Record<string, string>, sslOptions?: {
+    pathToCert: string;
+    pathToKey: string;
+}): void;

package/src/plugins/utils/start-remote-proxies.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRemoteProxies = startRemoteProxies;
+const fs_1 = require("fs");
+function startRemoteProxies(staticRemotesConfig, mappedLocationsOfRemotes, sslOptions) {
+    const { createProxyMiddleware } = require('http-proxy-middleware');
+    const express = require('express');
+    let sslCert;
+    let sslKey;
+    if (sslOptions && sslOptions.pathToCert && sslOptions.pathToKey) {
+        if ((0, fs_1.existsSync)(sslOptions.pathToCert) && (0, fs_1.existsSync)(sslOptions.pathToKey)) {
+            sslCert = (0, fs_1.readFileSync)(sslOptions.pathToCert);
+            sslKey = (0, fs_1.readFileSync)(sslOptions.pathToKey);
+        }
+        else {
+            console.warn(`Encountered SSL options in project.json, however, the certificate files do not exist in the filesystem. Using http.`);
+            console.warn(`Attempted to find '${sslOptions.pathToCert}' and '${sslOptions.pathToKey}'.`);
+        }
+    }
+    const http = require('http');
+    const https = require('https');
+    const remotes = Object.keys(staticRemotesConfig);
+    console.log(`NX Starting static remotes proxies...`);
+    for (const app of remotes) {
+        const appConfig = staticRemotesConfig[app];
+        const expressProxy = express();
+        expressProxy.use(createProxyMiddleware({
+            target: mappedLocationsOfRemotes[app],
+            changeOrigin: true,
+            secure: sslCert ? false : undefined,
+        }));
+        const proxyServer = (sslCert ? https : http)
+            .createServer({ cert: sslCert, key: sslKey }, expressProxy)
+            .listen(appConfig.port);
+        process.on('SIGTERM', () => proxyServer.close());
+        process.on('exit', () => proxyServer.close());
+    }
+    console.info(`NX Static remotes proxies started successfully`);
+}

package/src/plugins/utils/start-static-remotes-file-server.d.ts

@@ -0,0 +1,2 @@
+import { StaticRemoteConfig } from '../../utils';
+export declare function startStaticRemotesFileServer(staticRemotesConfig: Record<string, StaticRemoteConfig>, root: string, staticRemotesPort: number): void;

package/src/plugins/utils/start-static-remotes-file-server.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStaticRemotesFileServer = startStaticRemotesFileServer;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const node_child_process_1 = require("node:child_process");
+const devkit_1 = require("@nx/devkit");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+function startStaticRemotesFileServer(staticRemotesConfig, root, staticRemotesPort) {
+    const remotes = Object.keys(staticRemotesConfig);
+    if (!remotes || remotes.length === 0) {
+        return;
+    }
+    let shouldMoveToCommonLocation = false;
+    const commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-remotes');
+    for (const app of remotes) {
+        const remoteConfig = staticRemotesConfig[app];
+        if (remoteConfig) {
+            (0, fs_1.cpSync)(remoteConfig.outputPath, (0, path_1.join)(commonOutputDirectory, remoteConfig.urlSegment), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+    const { path: pathToHttpServerPkgJson, packageJson } = (0, devkit_internals_1.readModulePackageJson)('http-server', module.paths);
+    const pathToHttpServerBin = packageJson.bin['http-server'];
+    const pathToHttpServer = (0, path_1.resolve)(pathToHttpServerPkgJson.replace('package.json', ''), pathToHttpServerBin);
+    const httpServerProcess = (0, node_child_process_1.fork)(pathToHttpServer, [
+        commonOutputDirectory,
+        `-p=${staticRemotesPort}`,
+        `-a=localhost`,
+        `--cors`,
+    ], {
+        stdio: 'pipe',
+        cwd: root,
+        env: {
+            FORCE_COLOR: 'true',
+            ...process.env,
+        },
+    });
+    process.on('SIGTERM', () => httpServerProcess.kill('SIGTERM'));
+    process.on('exit', () => httpServerProcess.kill('SIGTERM'));
+}

package/src/with-module-federation/rspack/utils.d.ts

@@ -3,10 +3,10 @@ export declare function getFunctionDeterminateRemoteUrl(isServer?: boolean): (re
 export declare function getModuleFederationConfig(mfConfig: ModuleFederationConfig, options?: {
     isServer: boolean;
     determineRemoteUrl?: (remote: string) => string;
-}): Promise<{
+}): {
     sharedLibraries: import("../../utils").SharedWorkspaceLibraryConfig;
     sharedDependencies: {
         [x: string]: import("../../utils").SharedLibraryConfig;
     };
     mappedRemotes: {};
-}>;
+};

package/src/with-module-federation/rspack/utils.js

@@ -34,14 +34,8 @@ function getFunctionDeterminateRemoteUrl(isServer = false) {
         return `${host.endsWith('/') ? host.slice(0, -1) : host}:${port}/${remoteEntry}`;
     };
 }
-async function getModuleFederationConfig(mfConfig, options = { isServer: false }) {
-    let projectGraph;
-    try {
-        projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    }
-    catch (e) {
-        projectGraph = await (0, devkit_1.createProjectGraphAsync)();
-    }
+function getModuleFederationConfig(mfConfig, options = { isServer: false }) {
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
     const project = projectGraph.nodes[mfConfig.name]?.data;
     if (!project) {
         throw Error(`Cannot find project "${mfConfig.name}". Check that the name is correct in module-federation.config.js`);

package/src/with-module-federation/rspack/with-module-federation-ssr.js

@@ -7,7 +7,7 @@ async function withModuleFederationForSSR(options, configOverride) {
     if (global.NX_GRAPH_CREATION) {
         return (config) => config;
     }
-    const { sharedLibraries, sharedDependencies, mappedRemotes } = await (0, utils_1.getModuleFederationConfig)(options, {
+    const { sharedLibraries, sharedDependencies, mappedRemotes } = (0, utils_1.getModuleFederationConfig)(options, {
         isServer: true,
     });
     return (config, { context }) => {

package/src/with-module-federation/rspack/with-module-federation.js

@@ -15,7 +15,7 @@ async function withModuleFederation(options, configOverride) {
             return config;
         };
     }
-    const { sharedDependencies, sharedLibraries, mappedRemotes } = await (0, utils_1.getModuleFederationConfig)(options);
+    const { sharedDependencies, sharedLibraries, mappedRemotes } = (0, utils_1.getModuleFederationConfig)(options);
     const isGlobal = isVarOrWindow(options.library?.type);
     return function makeConfig(config, { context }) {
         config.output.uniqueName = options.name;