@nx/rspack 0.0.0-pr-28218-5048fd1

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = moduleFederationDevServer;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const file_server_impl_1 = tslib_1.__importDefault(require("@nx/web/src/executors/file-server/file-server.impl"));
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const module_federation_1 = require("../../utils/module-federation");
+const build_static_remotes_1 = require("../../utils/module-federation/build-static.remotes");
+const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
+const start_remote_proxies_1 = require("../../utils/module-federation/start-remote-proxies");
+const dev_server_impl_1 = tslib_1.__importDefault(require("../dev-server/dev-server.impl"));
+function getBuildOptions(buildTarget, context) {
+    const target = (0, devkit_1.parseTargetString)(buildTarget, context);
+    const buildOptions = (0, devkit_1.readTargetOptions)(target, context);
+    return {
+        ...buildOptions,
+    };
+}
+function startStaticRemotesFileServer(staticRemotesConfig, context, options) {
+    if (!staticRemotesConfig.remotes ||
+        staticRemotesConfig.remotes.length === 0) {
+        return;
+    }
+    let shouldMoveToCommonLocation = false;
+    let commonOutputDirectory;
+    for (const app of staticRemotesConfig.remotes) {
+        const remoteBasePath = staticRemotesConfig.config[app].basePath;
+        if (!commonOutputDirectory) {
+            commonOutputDirectory = remoteBasePath;
+        }
+        else if (commonOutputDirectory !== remoteBasePath) {
+            shouldMoveToCommonLocation = true;
+            break;
+        }
+    }
+    if (shouldMoveToCommonLocation) {
+        commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-remotes');
+        for (const app of staticRemotesConfig.remotes) {
+            const remoteConfig = staticRemotesConfig.config[app];
+            (0, fs_1.cpSync)(remoteConfig.outputPath, (0, path_1.join)(commonOutputDirectory, remoteConfig.urlSegment), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+    const staticRemotesIter = (0, file_server_impl_1.default)({
+        cors: true,
+        watch: false,
+        staticFilePath: commonOutputDirectory,
+        parallel: false,
+        spa: false,
+        withDeps: false,
+        host: options.host,
+        port: options.staticRemotesPort,
+        ssl: options.ssl,
+        sslCert: options.sslCert,
+        sslKey: options.sslKey,
+        cacheSeconds: -1,
+    }, context);
+    return staticRemotesIter;
+}
+async function startRemotes(remotes, context, options, target = 'serve') {
+    const remoteIters = [];
+    for (const app of remotes) {
+        const remoteProjectServeTarget = context.projectGraph.nodes[app].data.targets[target];
+        const isUsingModuleFederationDevServerExecutor = remoteProjectServeTarget.executor.includes('module-federation-dev-server');
+        const configurationOverride = options.devRemotes?.find((r) => typeof r !== 'string' && r.remoteName === app)?.configuration;
+        const defaultOverrides = {
+            ...(options.host ? { host: options.host } : {}),
+            ...(options.ssl ? { ssl: options.ssl } : {}),
+            ...(options.sslCert ? { sslCert: options.sslCert } : {}),
+            ...(options.sslKey ? { sslKey: options.sslKey } : {}),
+        };
+        const overrides = target === 'serve'
+            ? {
+                watch: true,
+                ...(isUsingModuleFederationDevServerExecutor
+                    ? { isInitialHost: false }
+                    : {}),
+                ...defaultOverrides,
+            }
+            : { ...defaultOverrides };
+        remoteIters.push(await (0, devkit_1.runExecutor)({
+            project: app,
+            target,
+            configuration: configurationOverride ?? context.configurationName,
+        }, overrides, context));
+    }
+    return remoteIters;
+}
+async function* moduleFederationDevServer(options, context) {
+    // Force Node to resolve to look for the nx binary that is inside node_modules
+    const nxBin = require.resolve('nx/bin/nx');
+    const currIter = options.static
+        ? (0, file_server_impl_1.default)({
+            ...options,
+            parallel: false,
+            withDeps: false,
+            spa: false,
+            cors: true,
+            cacheSeconds: -1,
+        }, context)
+        : (0, dev_server_impl_1.default)(options, context);
+    const p = context.projectsConfigurations.projects[context.projectName];
+    const buildOptions = getBuildOptions(options.buildTarget, context);
+    let pathToManifestFile = (0, path_1.join)(context.root, p.sourceRoot, 'assets/module-federation.manifest.json');
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, options.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)(options.pathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    if (!options.isInitialHost) {
+        return yield* currIter;
+    }
+    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, p.root, 'react');
+    const remoteNames = options.devRemotes?.map((r) => typeof r === 'string' ? r : r.remoteName);
+    const remotes = (0, module_federation_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
+        projectName: context.projectName,
+        projectGraph: context.projectGraph,
+        root: context.root,
+    }, pathToManifestFile);
+    options.staticRemotesPort ??= remotes.staticRemotePort;
+    // Set NX_MF_DEV_REMOTES for the Nx Runtime Library Control Plugin
+    process.env.NX_MF_DEV_REMOTES = JSON.stringify([
+        ...(remotes.devRemotes.map((r) => typeof r === 'string' ? r : r.remoteName) ?? []),
+        p.name,
+    ]);
+    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    const mappedLocationsOfStaticRemotes = await (0, build_static_remotes_1.buildStaticRemotes)(staticRemotesConfig, nxBin, context, options);
+    const devRemoteIters = await startRemotes(remotes.devRemotes, context, options, 'serve');
+    const staticRemotesIter = startStaticRemotesFileServer(staticRemotesConfig, context, options);
+    (0, start_remote_proxies_1.startRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
+        ? {
+            pathToCert: (0, path_1.join)(devkit_1.workspaceRoot, options.sslCert),
+            pathToKey: (0, path_1.join)(devkit_1.workspaceRoot, options.sslKey),
+        }
+        : undefined);
+    return yield* (0, async_iterable_1.combineAsyncIterables)(currIter, ...devRemoteIters, ...(staticRemotesIter ? [staticRemotesIter] : []), (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        if (!options.isInitialHost) {
+            done();
+            return;
+        }
+        if (remotes.remotePorts.length === 0) {
+            done();
+            return;
+        }
+        try {
+            const host = options.host ?? 'localhost';
+            const baseUrl = `http${options.ssl ? 's' : ''}://${host}:${options.port}`;
+            const portsToWaitFor = staticRemotesIter
+                ? [options.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: host,
+            })));
+            devkit_1.logger.info(`NX All remotes started, server ready at ${baseUrl}`);
+            next({ success: true, baseUrl: baseUrl });
+        }
+        catch (err) {
+            throw new Error(`Failed to start remotes. Check above for any errors.`);
+        }
+        finally {
+            done();
+        }
+    }));
+}

package/src/executors/module-federation-dev-server/schema.d.ts

@@ -0,0 +1,18 @@
+import { DevServerExecutorSchema } from '../dev-server/schema';
+
+export type ModuleFederationDevServerOptions = DevServerExecutorSchema & {
+  // Module Federation Specific Options
+  devRemotes?: (
+    | string
+    | {
+        remoteName: string;
+        configuration: string;
+      }
+  )[];
+  skipRemotes?: string[];
+  static?: boolean;
+  isInitialHost?: boolean;
+  parallel?: number;
+  staticRemotesPort?: number;
+  pathToManifestFile?: string;
+};

package/src/executors/module-federation-dev-server/schema.json

@@ -0,0 +1,98 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Rspack Module Federation Dev Server",
+  "description": "Serve a module federation application.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "devRemotes": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "object",
+            "properties": {
+              "remoteName": {
+                "type": "string"
+              },
+              "configuration": {
+                "type": "string"
+              }
+            },
+            "required": ["remoteName"],
+            "additionalProperties": false
+          }
+        ]
+      },
+      "description": "List of remote applications to run in development mode (i.e. using serve target).",
+      "x-priority": "important"
+    },
+    "skipRemotes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of remote applications to not automatically serve, either statically or in development mode. This will not remove the remotes from the `module-federation.config` file, and therefore the application may still try to fetch these remotes.\nThis option is useful if you have other means for serving the `remote` application(s).\n**NOTE:** Remotes that are not in the workspace will be skipped automatically.",
+      "x-priority": "important"
+    },
+    "buildTarget": {
+      "type": "string",
+      "description": "Target which builds the application.",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "Port to listen on.",
+      "default": 4200,
+      "x-priority": "important"
+    },
+    "host": {
+      "type": "string",
+      "description": "Host to listen on.",
+      "default": "localhost"
+    },
+    "ssl": {
+      "type": "boolean",
+      "description": "Serve using `HTTPS`.",
+      "default": false
+    },
+    "sslKey": {
+      "type": "string",
+      "description": "SSL key to use for serving `HTTPS`."
+    },
+    "sslCert": {
+      "type": "string",
+      "description": "SSL certificate to use for serving `HTTPS`."
+    },
+    "publicHost": {
+      "type": "string",
+      "description": "Public URL where the application will be served."
+    },
+    "static": {
+      "type": "boolean",
+      "description": "Whether to use a static file server instead of the rspack-dev-server. This should be used for remote applications that are also host applications."
+    },
+    "isInitialHost": {
+      "type": "boolean",
+      "description": "Whether the host that is running this executor is the first in the project tree to do so.",
+      "default": true,
+      "x-priority": "internal"
+    },
+    "parallel": {
+      "type": "number",
+      "description": "Max number of parallel processes for building static remotes"
+    },
+    "staticRemotesPort": {
+      "type": "number",
+      "description": "The port at which to serve the file-server for the static remotes."
+    },
+    "pathToManifestFile": {
+      "type": "string",
+      "description": "Path to a Module Federation manifest file (e.g. `my/path/to/module-federation.manifest.json`) containing the dynamic remote applications relative to the workspace root."
+    }
+  }
+}

package/src/executors/module-federation-ssr-dev-server/module-federation-ssr-dev-server.impl.d.ts

@@ -0,0 +1,21 @@
+import { ExecutorContext } from '@nx/devkit';
+import { RspackSsrDevServerOptions } from '../ssr-dev-server/schema';
+type ModuleFederationSsrDevServerOptions = RspackSsrDevServerOptions & {
+    devRemotes?: (string | {
+        remoteName: string;
+        configuration: string;
+    })[];
+    skipRemotes?: string[];
+    host: string;
+    pathToManifestFile?: string;
+    staticRemotesPort?: number;
+    parallel?: number;
+    ssl?: boolean;
+    sslKey?: string;
+    sslCert?: string;
+    isInitialHost?: boolean;
+};
+export default function moduleFederationSsrDevServer(ssrDevServerOptions: ModuleFederationSsrDevServerOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+}, any, unknown>;
+export {};

package/src/executors/module-federation-ssr-dev-server/module-federation-ssr-dev-server.impl.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = moduleFederationSsrDevServer;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const module_federation_1 = require("../../utils/module-federation");
+const ssr_dev_server_impl_1 = tslib_1.__importDefault(require("../ssr-dev-server/ssr-dev-server.impl"));
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
+const file_server_impl_1 = tslib_1.__importDefault(require("@nx/web/src/executors/file-server/file-server.impl"));
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const start_ssr_remote_proxies_1 = require("../../utils/module-federation/start-ssr-remote-proxies");
+function normalizeOptions(options) {
+    return {
+        ...options,
+        ssl: options.ssl ?? false,
+        sslCert: options.sslCert ? (0, path_1.join)(devkit_1.workspaceRoot, options.sslCert) : undefined,
+        sslKey: options.sslKey ? (0, path_1.join)(devkit_1.workspaceRoot, options.sslKey) : undefined,
+    };
+}
+function getBuildOptions(buildTarget, context) {
+    const target = (0, devkit_1.parseTargetString)(buildTarget, context);
+    const buildOptions = (0, devkit_1.readTargetOptions)(target, context);
+    return {
+        ...buildOptions,
+    };
+}
+function startSsrStaticRemotesFileServer(ssrStaticRemotesConfig, context, options) {
+    if (ssrStaticRemotesConfig.remotes.length === 0) {
+        return;
+    }
+    // The directories are usually generated with /browser and /server suffixes so we need to copy them to a common directory
+    const commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-remotes');
+    for (const app of ssrStaticRemotesConfig.remotes) {
+        const remoteConfig = ssrStaticRemotesConfig.config[app];
+        (0, fs_1.cpSync)(remoteConfig.outputPath, (0, path_1.join)(commonOutputDirectory, remoteConfig.urlSegment), {
+            force: true,
+            recursive: true,
+        });
+    }
+    const staticRemotesIter = (0, file_server_impl_1.default)({
+        cors: true,
+        watch: false,
+        staticFilePath: commonOutputDirectory,
+        parallel: false,
+        spa: false,
+        withDeps: false,
+        host: options.host,
+        port: options.staticRemotesPort,
+        ssl: options.ssl,
+        sslCert: options.sslCert,
+        sslKey: options.sslKey,
+        cacheSeconds: -1,
+    }, context);
+    return staticRemotesIter;
+}
+async function startRemotes(remotes, context, options) {
+    const remoteIters = [];
+    const target = 'serve';
+    for (const app of remotes) {
+        const remoteProjectServeTarget = context.projectGraph.nodes[app].data.targets[target];
+        const isUsingModuleFederationSsrDevServerExecutor = remoteProjectServeTarget.executor.includes('module-federation-ssr-dev-server');
+        const configurationOverride = options.devRemotes?.find((remote) => typeof remote !== 'string' && remote.remoteName === app)?.configuration;
+        {
+            const defaultOverrides = {
+                ...(options.host ? { host: options.host } : {}),
+                ...(options.ssl ? { ssl: options.ssl } : {}),
+                ...(options.sslCert ? { sslCert: options.sslCert } : {}),
+                ...(options.sslKey ? { sslKey: options.sslKey } : {}),
+            };
+            const overrides = {
+                watch: true,
+                ...defaultOverrides,
+                ...(isUsingModuleFederationSsrDevServerExecutor
+                    ? { isInitialHost: false }
+                    : {}),
+            };
+            remoteIters.push(await (0, devkit_1.runExecutor)({
+                project: app,
+                target,
+                configuration: configurationOverride ?? context.configurationName,
+            }, overrides, context));
+        }
+    }
+    return remoteIters;
+}
+async function buildSsrStaticRemotes(staticRemotesConfig, nxBin, context, options) {
+    if (!staticRemotesConfig.remotes.length) {
+        return;
+    }
+    devkit_1.logger.info(`Nx is building ${staticRemotesConfig.remotes.length} static remotes...`);
+    const mapLocationOfRemotes = {};
+    for (const remoteApp of staticRemotesConfig.remotes) {
+        mapLocationOfRemotes[remoteApp] = `http${options.ssl ? 's' : ''}://${options.host}:${options.staticRemotesPort}/${staticRemotesConfig.config[remoteApp].urlSegment}`;
+    }
+    await new Promise((resolve) => {
+        const childProcess = (0, child_process_1.fork)(nxBin, [
+            'run-many',
+            '--target=server',
+            '--projects',
+            staticRemotesConfig.remotes.join(','),
+            ...(context.configurationName
+                ? [`--configuration=${context.configurationName}`]
+                : []),
+            ...(options.parallel ? [`--parallel=${options.parallel}`] : []),
+        ], {
+            cwd: context.root,
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        });
+        // Add a listener to the child process to capture the build log
+        const remoteBuildLogFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 
+        // eslint-disable-next-line
+        `${new Date().toISOString().replace(/[:\.]/g, '_')}-build.log`);
+        const remoteBuildLogStream = (0, fs_1.createWriteStream)(remoteBuildLogFile);
+        childProcess.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, '');
+            remoteBuildLogStream.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')) {
+                devkit_1.logger.log(stdoutString);
+            }
+            if (stdoutString.includes('Successfully ran target server')) {
+                childProcess.stdout.removeAllListeners('data');
+                devkit_1.logger.info(`Nx Built ${staticRemotesConfig.remotes.length} static remotes.`);
+                resolve();
+            }
+        });
+        process.on('SIGTERM', () => childProcess.kill('SIGTERM'));
+        process.on('exit', () => childProcess.kill('SIGTERM'));
+    });
+    return mapLocationOfRemotes;
+}
+async function* moduleFederationSsrDevServer(ssrDevServerOptions, context) {
+    const options = normalizeOptions(ssrDevServerOptions);
+    // Force Node to resolve to look for the nx binary that is inside node_modules
+    const nxBin = require.resolve('nx/bin/nx');
+    const iter = (0, ssr_dev_server_impl_1.default)(options, context);
+    const projectConfig = context.projectsConfigurations.projects[context.projectName];
+    const buildOptions = getBuildOptions(options.browserTarget, context);
+    let pathToManifestFile = (0, path_1.join)(context.root, projectConfig.sourceRoot, 'assets/module-federation.manifest.json');
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, options.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)(userPathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    if (!options.isInitialHost) {
+        return yield* iter;
+    }
+    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, projectConfig.root, 'react');
+    const remoteNames = options.devRemotes?.map((remote) => typeof remote === 'string' ? remote : remote.remoteName);
+    const remotes = (0, module_federation_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
+        projectName: context.projectName,
+        projectGraph: context.projectGraph,
+        root: context.root,
+    }, pathToManifestFile);
+    options.staticRemotesPort ??= remotes.staticRemotePort;
+    process.env.NX_MF_DEV_REMOTES = JSON.stringify([
+        ...(remotes.devRemotes.map((r) => typeof r === 'string' ? r : r.remoteName) ?? []),
+        projectConfig.name,
+    ]);
+    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticSsrRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    const mappedLocationsOfStaticRemotes = await buildSsrStaticRemotes(staticRemotesConfig, nxBin, context, options);
+    const devRemoteIters = await startRemotes(remotes.devRemotes, context, options);
+    const staticRemotesIter = startSsrStaticRemotesFileServer(staticRemotesConfig, context, options);
+    (0, start_ssr_remote_proxies_1.startSsrRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
+        ? {
+            pathToCert: options.sslCert,
+            pathToKey: options.sslKey,
+        }
+        : undefined);
+    return yield* (0, async_iterable_1.combineAsyncIterables)(iter, ...devRemoteIters, ...(staticRemotesIter ? [staticRemotesIter] : []), (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        if (!options.isInitialHost) {
+            done();
+            return;
+        }
+        if (remotes.remotePorts.length === 0) {
+            done();
+            return;
+        }
+        try {
+            const host = options.host ?? 'localhost';
+            const baseUrl = `http${options.ssl ? 's' : ''}://${host}:${options.port}`;
+            const portsToWaitFor = staticRemotesIter
+                ? [options.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host,
+            })));
+            devkit_1.logger.info(`Nx all ssr remotes have started, server ready at ${baseUrl}`);
+            next({ success: true, baseUrl });
+        }
+        catch (error) {
+            throw new Error(`Nx failed to start ssr remotes. Check above for errors.`);
+        }
+        finally {
+            done();
+        }
+    }));
+}

package/src/executors/module-federation-ssr-dev-server/schema.json

@@ -0,0 +1,79 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Module Federation SSR Dev Server",
+  "description": "Serve a SSR host application along with its known remotes.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Target which builds the browser application.",
+      "x-priority": "important"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Target which builds the server application.",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port to be set on `process.env.PORT` for use in the server.",
+      "default": 4200,
+      "x-priority": "important"
+    },
+    "devRemotes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of remote applications to run in development mode (i.e. using serve target).",
+      "x-priority": "important"
+    },
+    "skipRemotes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of remote applications to not automatically serve, either statically or in development mode.",
+      "x-priority": "important"
+    },
+    "host": {
+      "type": "string",
+      "description": "Host to listen on.",
+      "default": "localhost"
+    },
+    "staticRemotesPort": {
+      "type": "number",
+      "description": "The port at which to serve the file-server for the static remotes."
+    },
+    "pathToManifestFile": {
+      "type": "string",
+      "description": "Path to a Module Federation manifest file (e.g. `my/path/to/module-federation.manifest.json`) containing the dynamic remote applications relative to the workspace root."
+    },
+    "ssl": {
+      "type": "boolean",
+      "description": "Serve using HTTPS.",
+      "default": false
+    },
+    "sslKey": {
+      "type": "string",
+      "description": "SSL key to use for serving HTTPS."
+    },
+    "sslCert": {
+      "type": "string",
+      "description": "SSL certificate to use for serving HTTPS."
+    },
+    "publicHost": {
+      "type": "string",
+      "description": "Public URL where the application will be served."
+    },
+    "isInitialHost": {
+      "type": "boolean",
+      "description": "Whether the host that is running this executor is the first in the project tree to do so.",
+      "default": true,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["browserTarget", "serverTarget"]
+}

package/src/executors/module-federation-static-server/module-federation-static-server.impl.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorContext } from 'nx/src/config/misc-interfaces';
+import { StaticRemotesConfig } from '../../utils/module-federation/parse-static-remotes-config';
+import { ModuleFederationDevServerOptions } from '../module-federation-dev-server/schema';
+import { ModuleFederationStaticServerSchema } from './schema';
+export declare function startProxies(staticRemotesConfig: StaticRemotesConfig, hostServeOptions: ModuleFederationDevServerOptions, mappedLocationOfHost: string, mappedLocationsOfRemotes: Record<string, string>, sslOptions?: {
+    pathToCert: string;
+    pathToKey: string;
+}): void;
+export default function moduleFederationStaticServer(schema: ModuleFederationStaticServerSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl: string;
+}, any, unknown>;