@module-federation/node 0.0.0-feat-node-support-1702930274547 → 0.0.0-next-20231219093413

package/src/plugins/CommonJsChunkLoadingPlugin.ts

@@ -0,0 +1,168 @@
+import type { Chunk, Compiler, Compilation, ChunkGraph } from 'webpack';
+import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
+import type { ModuleFederationPluginOptions } from '../types';
+const StartupChunkDependenciesPlugin = require(
+  normalizeWebpackPath('webpack/lib/runtime/StartupChunkDependenciesPlugin'),
+) as typeof import('webpack/lib/runtime/StartupChunkDependenciesPlugin');
+import ChunkLoadingRuntimeModule from './DynamicFilesystemChunkLoadingRuntimeModule';
+import AutoPublicPathRuntimeModule from './RemotePublicPathRuntimeModule';
+
+interface DynamicFilesystemChunkLoadingOptions
+  extends ModuleFederationPluginOptions {
+  baseURI: Compiler['options']['output']['publicPath'];
+  promiseBaseURI?: string;
+  remotes: Record<string, string>;
+  name?: string;
+  asyncChunkLoading: boolean;
+  debug?: boolean;
+}
+
+class DynamicFilesystemChunkLoadingPlugin {
+  private options: DynamicFilesystemChunkLoadingOptions;
+  private _asyncChunkLoading: boolean;
+
+  constructor(options: DynamicFilesystemChunkLoadingOptions) {
+    this.options = options || ({} as DynamicFilesystemChunkLoadingOptions);
+    this._asyncChunkLoading = this.options.asyncChunkLoading;
+  }
+
+  apply(compiler: Compiler) {
+    const { RuntimeGlobals } = compiler.webpack;
+    const chunkLoadingValue = this._asyncChunkLoading
+      ? 'async-node'
+      : 'require';
+
+    new StartupChunkDependenciesPlugin({
+      chunkLoading: chunkLoadingValue,
+      asyncChunkLoading: this._asyncChunkLoading,
+      //@ts-ignore
+    }).apply(compiler);
+
+    compiler.hooks.thisCompilation.tap(
+      'DynamicFilesystemChunkLoadingPlugin',
+      (compilation: Compilation) => {
+        // Always enabled
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const isEnabledForChunk = (_: Chunk) => true;
+        const onceForChunkSet = new WeakSet();
+
+        const handler = (chunk: Chunk, set: Set<string>) => {
+          if (onceForChunkSet.has(chunk)) {
+            return;
+          }
+
+          onceForChunkSet.add(chunk);
+          if (!isEnabledForChunk(chunk)) {
+            return;
+          }
+          set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+          set.add(RuntimeGlobals.hasOwnProperty);
+
+          set.add(RuntimeGlobals.publicPath); // this breaks things
+          compilation.addRuntimeModule(
+            chunk,
+            new ChunkLoadingRuntimeModule(set, this.options, {
+              webpack: compiler.webpack,
+            }),
+          );
+        };
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.ensureChunkHandlers)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadManifest)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.baseURI)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.externalInstallChunk)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.onChunksLoaded)
+          .tap('DynamicFilesystemChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.ensureChunkHandlers)
+          .tap(
+            'DynamicFilesystemChunkLoadingPlugin',
+            (chunk: Chunk, set: Set<string>) => {
+              if (!isEnabledForChunk(chunk)) {
+                return;
+              }
+              set.add(RuntimeGlobals.getChunkScriptFilename);
+            },
+          );
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+          .tap(
+            'DynamicFilesystemChunkLoadingPlugin',
+            (chunk: Chunk, set: Set<string>) => {
+              if (!isEnabledForChunk(chunk)) {
+                return;
+              }
+              set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+              set.add(RuntimeGlobals.moduleCache);
+              set.add(RuntimeGlobals.hmrModuleData);
+              set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+            },
+          );
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadManifest)
+          .tap(
+            'DynamicFilesystemChunkLoadingPlugin',
+            (chunk: Chunk, set: Set<string>) => {
+              if (!isEnabledForChunk(chunk)) {
+                return;
+              }
+              set.add(RuntimeGlobals.getUpdateManifestFilename);
+            },
+          );
+
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.publicPath)
+          .tap('RuntimePlugin', (chunk, set) => {
+            const { outputOptions } = compilation;
+            const { publicPath: globalPublicPath, scriptType } = outputOptions;
+            const entryOptions = chunk.getEntryOptions();
+            const publicPath =
+              entryOptions && entryOptions.publicPath !== undefined
+                ? entryOptions.publicPath
+                : globalPublicPath;
+
+            const module = new AutoPublicPathRuntimeModule(this.options);
+            if (publicPath === 'auto' && scriptType !== 'module') {
+              set.add(RuntimeGlobals.global);
+            } else if (
+              typeof publicPath !== 'string' ||
+              /\[(full)?hash\]/.test(publicPath)
+            ) {
+              module.fullHash = true;
+            }
+
+            compilation.addRuntimeModule(chunk, module);
+            return true;
+          });
+
+        compilation.hooks.additionalTreeRuntimeRequirements.tap(
+          'StartupChunkDependenciesPlugin',
+          (
+            chunk: Chunk,
+            set: Set<string>,
+            { chunkGraph }: { chunkGraph: ChunkGraph },
+          ) => {
+            // compilation.addRuntimeModule(
+            //   chunk,
+            //   //@ts-ignore
+            //   new FederationModuleInfoRuntimeModule(),
+            // );
+          },
+        );
+      },
+    );
+  }
+}
+
+export default DynamicFilesystemChunkLoadingPlugin;

package/src/plugins/DynamicFilesystemChunkLoadingRuntimeModule.ts

@@ -0,0 +1,239 @@
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+import type { Chunk, Compiler } from 'webpack';
+import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
+const { RuntimeGlobals, RuntimeModule } = require(
+  normalizeWebpackPath('webpack'),
+) as typeof import('webpack');
+const { getUndoPath } = require(
+  normalizeWebpackPath('webpack/lib/util/identifier'),
+) as typeof import('webpack/lib/util/identifier');
+import { SyncWaterfallHook } from 'tapable';
+const compileBooleanMatcher = require(
+  normalizeWebpackPath('webpack/lib/util/compileBooleanMatcher'),
+) as typeof import('webpack/lib/util/compileBooleanMatcher');
+import {
+  generateHmrCode,
+  getInitialChunkIds,
+  generateLoadingCode,
+  generateHmrManifestCode,
+  handleOnChunkLoad,
+  generateLoadScript,
+  generateInstallChunk,
+  generateExternalInstallChunkCode,
+} from './webpackChunkUtilities';
+import {
+  fileSystemRunInContextStrategy,
+  httpEvalStrategy,
+  httpVmStrategy,
+} from '../filesystem/stratagies';
+
+interface RemotesByType {
+  functional: string[];
+  normal: string[];
+}
+
+interface DynamicFilesystemChunkLoadingRuntimeModuleOptions {
+  baseURI: Compiler['options']['output']['publicPath'];
+  promiseBaseURI?: string;
+  remotes: Record<string, string>;
+  name?: string;
+  debug?: boolean;
+}
+
+interface ChunkLoadingContext {
+  webpack: Compiler['webpack'];
+}
+
+class DynamicFilesystemChunkLoadingRuntimeModule extends RuntimeModule {
+  private runtimeRequirements: Set<string>;
+  private options: DynamicFilesystemChunkLoadingRuntimeModuleOptions;
+  private chunkLoadingContext: ChunkLoadingContext;
+  hooks = {
+    strategyCase: new SyncWaterfallHook(['source']),
+  };
+
+  constructor(
+    runtimeRequirements: Set<string>,
+    options: DynamicFilesystemChunkLoadingRuntimeModuleOptions,
+    chunkLoadingContext: ChunkLoadingContext,
+  ) {
+    super('readFile chunk loading', RuntimeModule.STAGE_ATTACH + 1);
+    this.runtimeRequirements = runtimeRequirements;
+
+    this.options = options;
+    this.chunkLoadingContext = chunkLoadingContext;
+  }
+
+  /**
+   * @private
+   * @param {Chunk} chunk chunk
+   * @param {string} rootOutputDir root output directory
+   * @returns {string} generated code
+   */
+  _generateBaseUri(chunk: Chunk, rootOutputDir: string) {
+    const options = chunk.getEntryOptions();
+    if (options && options.baseUri) {
+      return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
+    }
+
+    return `${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
+      rootOutputDir
+        ? `__dirname + ${JSON.stringify('/' + rootOutputDir)}`
+        : '__filename'
+    });`;
+  }
+
+  /**
+   * @private
+   * @param {unknown[]} items item to log
+   */
+  _getLogger(...items: unknown[]) {
+    if (!this.options.debug) {
+      return '';
+    }
+
+    return `console.log(${items.join(',')});`;
+  }
+
+  /**
+   * @returns {string} runtime code
+   */
+  override generate() {
+    const { remotes = {}, name } = this.options;
+    const { webpack } = this.chunkLoadingContext;
+    const { chunkGraph, chunk, compilation } = this;
+    const { Template } = webpack;
+    if (!chunkGraph || !chunk || !compilation) {
+      console.warn('Missing required properties. Returning empty string.');
+      return '';
+    }
+
+    const { runtimeTemplate } = compilation;
+    const jsModulePlugin =
+      webpack?.javascript?.JavascriptModulesPlugin ||
+      require('webpack/lib/javascript/JavascriptModulesPlugin');
+    const { chunkHasJs } = jsModulePlugin;
+    const fn = RuntimeGlobals.ensureChunkHandlers;
+
+    const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+    const hasJsMatcher = compileBooleanMatcher(conditionMap);
+    const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+    const outputName = compilation.getPath(
+      jsModulePlugin.getChunkFilenameTemplate(chunk, compilation.outputOptions),
+      { chunk, contentHashType: 'javascript' },
+    );
+    const rootOutputDir = getUndoPath(
+      outputName,
+      compilation.outputOptions.path,
+      false,
+    );
+    const stateExpression = this.runtimeRequirements.has(
+      RuntimeGlobals.hmrDownloadUpdateHandlers,
+    )
+      ? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
+      : undefined;
+
+    const dynamicFilesystemChunkLoadingPluginCode = Template.asString([
+      fileSystemRunInContextStrategy.toString(),
+      httpEvalStrategy.toString(),
+      httpVmStrategy.toString(),
+      'const loadChunkStrategy = async (strategyType,chunkId,rootOutputDir, remotes, callback) => {',
+      Template.indent([
+        'switch (strategyType) {',
+        Template.indent([
+          'case "filesystem": return await fileSystemRunInContextStrategy(chunkId,rootOutputDir, remotes, callback);',
+          'case "http-eval": return await httpEvalStrategy(chunkId,rootOutputDir, remotes, callback);',
+          'case "http-vm": return await httpVmStrategy(chunkId,rootOutputDir, remotes, callback);',
+          this.hooks.strategyCase.call(
+            'default: throw new Error("Invalid strategy type");',
+          ) as string,
+        ]),
+        '}',
+      ]),
+      '};',
+    ]);
+    const remoteRegistry = Template.asString([
+      `var remotes = ${JSON.stringify(
+        Object.values(remotes).reduce(
+          (acc, remote) => {
+            const [global, url] = remote.split('@');
+            acc[global] = url;
+            return acc;
+          },
+          {} as Record<string, string>,
+        ),
+      )};`,
+      Template.asString([
+        'Object.keys(remotes).forEach(function(remote) {',
+        Template.indent(
+          'globalThis.__remote_scope__._config[remote] = remotes[remote];',
+        ),
+        '});',
+      ]),
+    ]);
+
+    return Template.asString([
+      remoteRegistry,
+      dynamicFilesystemChunkLoadingPluginCode,
+      this.runtimeRequirements.has(RuntimeGlobals.baseURI)
+        ? this._generateBaseUri(chunk, rootOutputDir)
+        : '// no baseURI',
+      '',
+      '// object to store loaded chunks',
+      '// "0" means "already loaded", Promise means loading',
+      `var installedChunks = ${
+        stateExpression ? `${stateExpression} = ${stateExpression} || ` : ''
+      }{`,
+      Template.indent(
+        Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 0`).join(
+          ',\n',
+        ),
+      ),
+      '};',
+      '',
+      handleOnChunkLoad(
+        this.runtimeRequirements.has(RuntimeGlobals.onChunksLoaded),
+        runtimeTemplate,
+      ),
+      '',
+      generateInstallChunk(
+        runtimeTemplate,
+        this.runtimeRequirements.has(RuntimeGlobals.onChunksLoaded),
+      ),
+      '',
+      this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+        ? generateLoadScript(runtimeTemplate)
+        : '// no remote script loader needed',
+      this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+        ? generateLoadingCode(
+            this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers),
+            fn,
+            hasJsMatcher,
+            rootOutputDir,
+            remotes,
+            name,
+          )
+        : '// no chunk loading',
+      '',
+      generateExternalInstallChunkCode(
+        this.runtimeRequirements.has(RuntimeGlobals.externalInstallChunk),
+        this.options.debug,
+      ),
+      '',
+      generateHmrCode(
+        this.runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers),
+        rootOutputDir,
+      ),
+      '',
+      generateHmrManifestCode(
+        this.runtimeRequirements.has(RuntimeGlobals.hmrDownloadManifest),
+        rootOutputDir,
+      ),
+    ]);
+  }
+}
+
+export default DynamicFilesystemChunkLoadingRuntimeModule;

package/src/plugins/NodeContainerPlugin.ts

@@ -0,0 +1,150 @@
+'use strict';
+
+import type { Compiler, container } from 'webpack';
+import { extractUrlAndGlobal } from '@module-federation/utilities';
+
+/**
+ * Interface for NodeContainerOptions which extends ContainerPluginOptions
+ * @interface
+ * @property {Record<string, unknown>} experiments - Optional experiments configuration
+ * @property {boolean} debug - Optional debug flag
+ */
+
+/**
+ * Interface for Context
+ * @interface
+ * @property {typeof container.ContainerPlugin} ContainerPlugin - Optional ContainerPlugin
+ */
+interface Context {
+  ContainerPlugin?: typeof container.ContainerPlugin;
+}
+
+// possible remote evaluators
+// this depends on the chunk format selected.
+// commonjs2 - it think, is lazily evaluated - beware
+// const remote = eval(scriptContent + '\n  try{' + moduleName + '}catch(e) { null; };');
+// commonjs - fine to use but exports marker doesnt exist
+// const remote = eval('let exports = {};' + scriptContent + 'exports');
+// commonjs-module, ideal since it returns a commonjs module format
+// const remote = eval(scriptContent + 'module.exports')
+
+/**
+ * This function iterates over all remotes and checks if they
+ * are internal or not. If it's an internal remote then we add it to our new object
+ * with a key of the name of the remote and value as internal. If it's not an internal
+ * remote then we check if there is a '@' in that string which likely means it is a global @ url
+ *
+ * @param {Record<string, any>} remotes - The remotes to parse.
+ * @returns {Record<string, string>} - The parsed remotes.
+ * */
+
+export const parseRemotes = (
+  remotes: Record<string, any>,
+): Record<string, string> => {
+  if (!remotes || typeof remotes !== 'object') {
+    throw new Error('remotes must be an object');
+  }
+
+  return Object.entries(remotes).reduce(
+    (acc: Record<string, string>, [key, value]) => {
+      const isInternal = value.startsWith('internal ');
+      const isGlobal =
+        value.includes('@') &&
+        !['window.', 'global.', 'globalThis.', 'self.'].some((prefix) =>
+          value.startsWith(prefix),
+        );
+
+      acc[key] = isInternal || !isGlobal ? value : parseRemoteSyntax(value);
+
+      return acc;
+    },
+    {},
+  );
+};
+/**
+ * Parses the remote syntax and returns a formatted string if the remote includes '@' and does not start with 'window', 'global', or 'globalThis'.
+ * Otherwise, it returns the original remote string.
+ *
+ * @param {string} remote - The remote string to parse.
+ * @returns {string} - The parsed remote string or the original remote string.
+ * @throws {Error} - Throws an error if the remote is not a string.
+ */
+export const parseRemoteSyntax = (remote: any): string => {
+  if (typeof remote !== 'string') {
+    throw new Error('remote must be a string');
+  }
+
+  if (remote.includes('@')) {
+    const [url, global] = extractUrlAndGlobal(remote);
+    if (
+      !['window.', 'global.', 'globalThis.'].some((prefix) =>
+        global.startsWith(prefix),
+      )
+    ) {
+      return `globalThis.__remote_scope__.${global}@${url}`;
+    }
+  }
+  return remote;
+};
+
+/**
+ * Class representing a NodeContainerPlugin.
+ * @class
+ */
+class NodeContainerPlugin {
+  private _options: any;
+  private context: Context;
+  private experiments: any['experiments'];
+
+  /**
+   * Create a NodeContainerPlugin.
+   * @constructor
+   * @param {NodeContainerOptions} options - The options for the NodeContainerPlugin
+   * @param {Context} context - The context for the NodeContainerPlugin
+   */
+  constructor({ experiments, debug, ...options }: any, context: Context) {
+    this._options = options || ({} as any);
+    this.context = context || ({} as Context);
+    this.experiments = experiments || {};
+  }
+
+  /**
+   * Apply method for the NodeContainerPlugin class.
+   * @method
+   * @param {Compiler} compiler - The webpack compiler.
+   */
+  apply(compiler: Compiler) {
+    // When used with Next.js, context is needed to use Next.js webpack
+    const { webpack } = compiler;
+
+    const pluginOptions = {
+      name: this._options.name,
+      filename: this._options.filename,
+      exposes: this._options.exposes,
+      library: this._options.library,
+      runtime: this._options.runtime,
+      shareScope: this._options.shareScope,
+    };
+    //    //TODO can use import meta mock object but need to update data structure of remote_scope
+    //     if (compiler.options && compiler.options.output) {
+    //       compiler.options.output.importMetaName = 'remoteContainerRegistry';
+    //     }
+
+    // const chunkFileName = compiler.options?.output?.chunkFilename;
+    // const uniqueName =
+    //   compiler?.options?.output?.uniqueName || this._options.name;
+
+    // if (typeof chunkFileName === 'string' && uniqueName && !chunkFileName.includes(uniqueName)) {
+    //   const suffix = `-[chunkhash].js`;
+    //   compiler.options.output.chunkFilename = chunkFileName.replace('.js', suffix);
+    // }
+
+    new (this.context.ContainerPlugin ||
+      (webpack && webpack.container.ContainerPlugin) ||
+      require('webpack/lib/container/ContainerPlugin'))(pluginOptions).apply(
+      compiler,
+    );
+  }
+}
+
+export default NodeContainerPlugin;