@module-federation/node 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# Module Federation Support for Node Environments
+
+This package exposes two Webpack Plugins to bring the concept and power of Module Federation to NodeJS. This will allow your server to fetch chunks across the network allowing for distributed deployments of federated applications.
+
+## Installation
+
+To install the plugin run one of the following commands in your terminal for your application.
+
+```bash
+# npm
+npm install @module-federation/node
+
+# yarn
+yarn add @module-federation/node
+```
+
+## Usage
+
+To then use the plugin, modify your `webpack.config.js` to include and use the two plugins.
+
+At build time, you need to be aware if you're building for the `server` or for the `browser`.
+If it's building for server, we need to set `target: false` to allow the plugins to function correctly.
+
+The `NodeFederationPlugin` follows the same API as the [Module Federation Plugin](https://webpack.js.org/plugins/module-federation-plugin) and therefore should be a drop-in replacement if you already have it set up in your `webpack.config.js`.
+
+An example configuration is presented below:
+```js
+
+const {NodeFederationPlugin, StreamingTargetPlugin} = require("@module-federation/node");
+
+const config = {
+  target: isServer ? false : "web",
+  plugins: [
+    new NodeFederationPlugin({
+      name: 'website2',
+      library: {type: 'commonjs-module'},
+      remotes: {},
+      filename: 'remoteEntry.js',
+      exposes: {
+        './SharedComponent': './remoteServer/SharedComponent',
+      },
+    }),
+    new StreamingTargetPlugin({
+      name: 'website2',
+      library: {type: 'commonjs-module'},
+      remotes: {},
+    }),
+  ]
+}
+```

package/index.js

@@ -0,0 +1,5 @@
+const NodeFederationPlugin = require('./src/NodeFederationPlugin');
+const StreamingTargetPlugin = require('./src/StreamingTargetPlugin');
+
+module.exports.NodeFederationPlugin = NodeFederationPlugin;
+module.exports.StreamingTargetPlugin = StreamingTargetPlugin;

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@module-federation/node",
+  "version": "0.0.1",
+  "description": "Module Federation for Node.js",
+  "main": "index.js",
+  "peerDependencies": {
+    "webpack": "5.40.0",
+    "node-fetch": "^3.2.10"
+  }
+}

package/src/CommonJsChunkLoadingPlugin.js

@@ -0,0 +1,89 @@
+const RuntimeGlobals = require('webpack/lib/RuntimeGlobals');
+const StartupChunkDependenciesPlugin = require('webpack/lib/runtime/StartupChunkDependenciesPlugin');
+const ChunkLoadingRuntimeModule = require('./LoadFileChunkLoadingRuntimeModule');
+
+class CommonJsChunkLoadingPlugin {
+  constructor(options) {
+    this.options = options || {};
+    this._asyncChunkLoading = this.options.asyncChunkLoading;
+  }
+
+  /**
+   * Apply the plugin
+   * @param {Compiler} compiler the compiler instance
+   * @returns {void}
+   */
+  apply(compiler) {
+    const chunkLoadingValue = this._asyncChunkLoading
+      ? 'async-node'
+      : 'require';
+    new StartupChunkDependenciesPlugin({
+      chunkLoading: chunkLoadingValue,
+      asyncChunkLoading: this._asyncChunkLoading,
+    }).apply(compiler);
+    compiler.hooks.thisCompilation.tap(
+      'CommonJsChunkLoadingPlugin',
+      (compilation) => {
+        // Always enabled
+        const isEnabledForChunk = () => true;
+        const onceForChunkSet = new WeakSet();
+        const handler = (chunk, set) => {
+          if (onceForChunkSet.has(chunk)) return;
+          onceForChunkSet.add(chunk);
+          if (!isEnabledForChunk(chunk)) return;
+          set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+          set.add(RuntimeGlobals.hasOwnProperty);
+          compilation.addRuntimeModule(
+            chunk,
+            new ChunkLoadingRuntimeModule(set, this.options, {
+              webpack: compiler.webpack,
+            })
+          );
+        };
+
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.ensureChunkHandlers)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadManifest)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.baseURI)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.externalInstallChunk)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.onChunksLoaded)
+          .tap('CommonJsChunkLoadingPlugin', handler);
+
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.ensureChunkHandlers)
+          .tap('CommonJsChunkLoadingPlugin', (chunk, set) => {
+            if (!isEnabledForChunk(chunk)) return;
+            set.add(RuntimeGlobals.getChunkScriptFilename);
+          });
+        compilation.hooks.runtimeRequirementInTree
+          .for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+          .tap('CommonJsChunkLoadingPlugin', (chunk, set) => {
+            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('CommonJsChunkLoadingPlugin', (chunk, set) => {
+            if (!isEnabledForChunk(chunk)) return;
+            set.add(RuntimeGlobals.getUpdateManifestFilename);
+          });
+      }
+    );
+  }
+}
+
+module.exports = CommonJsChunkLoadingPlugin;

package/src/LoadFileChunkLoadingRuntimeModule.js

@@ -0,0 +1,410 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+'use strict';
+
+const RuntimeGlobals = require('webpack/lib/RuntimeGlobals');
+const RuntimeModule = require('webpack/lib/RuntimeModule');
+const Template = require('webpack/lib/Template');
+const compileBooleanMatcher = require('webpack/lib/util/compileBooleanMatcher');
+const { getUndoPath } = require('webpack/lib/util/identifier');
+
+const loadScriptTemplate = require('./loadScript')
+
+class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
+  constructor(runtimeRequirements, options, context) {
+    super('readFile chunk loading', RuntimeModule.STAGE_ATTACH);
+    this.runtimeRequirements = runtimeRequirements;
+    this.options = options;
+    this.context = context;
+  }
+
+  /**
+   * @private
+   * @param {Chunk} chunk chunk
+   * @param {string} rootOutputDir root output directory
+   * @returns {string} generated code
+   */
+  _generateBaseUri(chunk, rootOutputDir) {
+    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'
+    });`;
+  }
+
+  /**
+   * @returns {string} runtime code
+   */
+  generate() {
+    // name in this context is always the current remote itself.
+    // this code below is in each webpack runtime, host and remotes
+    // remote entries handle their own loading of chunks, so i have fractal self awareness
+    // hosts will likely never run the http chunk loading runtime, they use fs.readFile
+    // remotes only use fs.readFile if we were to cache the chunks on disk after fetching - otherwise its always using http
+    // so for example, if im in hostA and require(remoteb/module) --> console.log of name in runtime code will return remoteb
+
+    const { baseURI, promiseBaseURI, remotes, name } = this.options;
+    const { webpack } = this.context;
+    const chunkHasJs =
+      (webpack && webpack.javascript.JavascriptModulesPlugin.chunkHasJs) ||
+      require('webpack/lib/javascript/JavascriptModulesPlugin').chunkHasJs;
+
+    // workaround for next.js
+    const getInitialChunkIds = (chunk, chunkGraph) => {
+      const initialChunkIds = new Set(chunk.ids);
+      for (const c of chunk.getAllInitialChunks()) {
+        if (c === chunk || chunkHasJs(c, chunkGraph)) continue;
+        for (const id of c.ids) initialChunkIds.add(id);
+      }
+      return initialChunkIds;
+    };
+
+    const { chunkGraph, chunk } = this;
+    const { runtimeTemplate } = this.compilation;
+    const fn = RuntimeGlobals.ensureChunkHandlers;
+    const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+    const withExternalInstallChunk = this.runtimeRequirements.has(
+      RuntimeGlobals.externalInstallChunk
+    );
+    const withOnChunkLoad = this.runtimeRequirements.has(
+      RuntimeGlobals.onChunksLoaded
+    );
+    const withLoading = this.runtimeRequirements.has(
+      RuntimeGlobals.ensureChunkHandlers
+    );
+    const withHmr = this.runtimeRequirements.has(
+      RuntimeGlobals.hmrDownloadUpdateHandlers
+    );
+    const withHmrManifest = this.runtimeRequirements.has(
+      RuntimeGlobals.hmrDownloadManifest
+    );
+
+    const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+    const hasJsMatcher = compileBooleanMatcher(conditionMap);
+    const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+    const outputName = this.compilation.getPath(
+      (
+        (webpack &&
+          webpack.javascript.JavascriptModulesPlugin
+            .getChunkFilenameTemplate) ||
+        require('webpack/lib/javascript/JavascriptModulesPlugin')
+          .getChunkFilenameTemplate
+      )(chunk, this.compilation.outputOptions),
+      {
+        chunk,
+        contentHashType: 'javascript',
+      }
+    );
+    const rootOutputDir = getUndoPath(
+      outputName,
+      this.compilation.outputOptions.path,
+      false
+    );
+
+    const stateExpression = withHmr
+      ? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
+      : undefined;
+
+    return Template.asString([
+      withBaseURI
+        ? 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'
+        )
+      ),
+      '};',
+      '',
+      withOnChunkLoad
+        ? `${
+            RuntimeGlobals.onChunksLoaded
+          }.readFileVm = ${runtimeTemplate.returningFunction(
+            'installedChunks[chunkId] === 0',
+            'chunkId'
+          )};`
+        : '// no on chunks loaded',
+      '',
+      withLoading || withExternalInstallChunk
+        ? `var installChunk = ${runtimeTemplate.basicFunction('chunk', [
+            'var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;',
+            'for(var moduleId in moreModules) {',
+            Template.indent([
+              `if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+              Template.indent([
+                `${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`,
+              ]),
+              '}',
+            ]),
+            '}',
+            `if(runtime) runtime(__webpack_require__);`,
+            'for(var i = 0; i < chunkIds.length; i++) {',
+            Template.indent([
+              'if(installedChunks[chunkIds[i]]) {',
+              Template.indent(['installedChunks[chunkIds[i]][0]();']),
+              '}',
+              'installedChunks[chunkIds[i]] = 0;',
+            ]),
+            '}',
+            withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : '',
+          ])};`
+        : '// no chunk install function needed',
+      '',
+      withLoading
+        ? Template.asString([
+            '// ReadFile + VM.run chunk loading for javascript',
+            `${fn}.readFileVm = function(chunkId, promises) {`,
+            hasJsMatcher !== false
+              ? Template.indent([
+                  '',
+                  'var installedChunkData = installedChunks[chunkId];',
+                  'if(installedChunkData !== 0) { // 0 means "already installed".',
+                  Template.indent([
+                    '// array of [resolve, reject, promise] means "currently loading"',
+                    'if(installedChunkData) {',
+                    Template.indent(['promises.push(installedChunkData[2]);']),
+                    '} else {',
+                    Template.indent([
+                      hasJsMatcher === true
+                        ? 'if(true) { // all chunks have JS'
+                        : `if(${hasJsMatcher('chunkId')}) {`,
+                      Template.indent([
+                        '// load the chunk and return promise to it',
+                        'var promise = new Promise(async function(resolve, reject) {',
+                        Template.indent([
+                          'installedChunkData = installedChunks[chunkId] = [resolve, reject];',
+                          `var filename = require('path').join(__dirname, ${JSON.stringify(
+                            rootOutputDir
+                          )} + ${
+                            RuntimeGlobals.getChunkScriptFilename
+                          }(chunkId));`,
+                          "var fs = require('fs');",
+                          'if(fs.existsSync(filename)) {',
+                          Template.indent([
+                            "fs.readFile(filename, 'utf-8', function(err, content) {",
+                            Template.indent([
+                              'if(err) return reject(err);',
+                              'var chunk = {};',
+                              "require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+                                "(chunk, require, require('path').dirname(filename), filename);",
+                              'installChunk(chunk);',
+                            ]),
+                            '});',
+                          ]),
+                          '} else {',
+                          Template.indent([
+                            loadScriptTemplate,
+
+                            `console.log('needs to load remote module from', ${JSON.stringify(
+                              name
+                            )});`,
+                            `console.log('remotes known to', ${JSON.stringify(
+                              name
+                            )}, ${JSON.stringify(remotes)})`,
+                            // keys are mostly useless here, we want to find remote by its global (unique name)
+                            `var remotes = ${JSON.stringify(
+                              Object.values(remotes).reduce((acc, remote) => {
+                                //TODO: need to handle all other cases like when remote is not a @ syntax string
+                                const [global, url] = remote.split('@');
+                                acc[global] = url;
+                                return acc;
+                              }, {})
+                            )};`,
+                            "Object.assign(global.__remote_scope__._config, remotes)",
+                            "const remoteRegistry = global.__remote_scope__._config",
+                            /* TODO: keying by global should be ok, but need to verify - need to deal with when user passes promise new promise()
+    global will/should still exist - but can only be known at runtime */
+                            `console.log('remotes keyed by global name',remotes)`,
+                            `console.log('remote scope configs',global.__remote_scope__._config)`,
+
+                            `console.log('global.__remote_scope__',global.__remote_scope__)`,
+                            `console.log('global.__remote_scope__[${JSON.stringify(
+                              name
+                            )}]',global.__remote_scope__[${JSON.stringify(
+                              name
+                            )}])`,
+
+                            /*   TODO: this global.REMOTE_CONFIG doesnt work in this v5 core, not sure if i need to keep it or not
+                                 not deleting it yet since i might need this for tracking all the remote entries across systems
+                                 for now, im going to use locally known remote scope from remoteEntry config
+                                 update: We will most likely need this, since remote would not have its own config
+                                 id need to access the host system and find the known url
+                                  basically this is how i create publicPath: auto on servers.
+                                 `var requestedRemote = global.REMOTE_CONFIG[${JSON.stringify(
+                                  name
+                                )}]`,
+                             */
+                            "console.log('about to derive remote making request')",
+                            `var requestedRemote = remoteRegistry[${JSON.stringify(
+                              name
+                            )}]`,
+                            "console.log('requested remote', requestedRemote)",
+                            /*TODO: we need to support when user implements own promise new promise function
+                                    for example i have my own promise remotes, not global@remotename
+                                    so there could be cases where remote may be function still - not sure */
+
+                            /*TODO: need to handle if chunk fetch fails/crashes - ensure server still can keep loading
+                                    right now if you throw an error in here, server will stall forever */
+
+                            `if(typeof requestedRemote === 'function'){
+                    requestedRemote = await requestedRemote()
+                  }`,
+                            `console.log('var requestedRemote',requestedRemote);`,
+
+                            // example: uncomment this and server will never reply
+                            // `var scriptUrl = new URL(requestedRemote.split("@")[1]);`,
+                            // since im looping over remote and creating global at build time, i dont need to split string at runtime
+                            // there may still be a use case for that with promise new promise, depending on how we design it.
+                            `var scriptUrl = new URL(requestedRemote);`,
+
+                            `var chunkName = ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+
+                            `console.log('chunkname to request',chunkName);`,
+                            `var fileToReplace = require('path').basename(scriptUrl.pathname);`,
+                            `scriptUrl.pathname = scriptUrl.pathname.replace(fileToReplace, chunkName);`,
+                            `console.log('will load remote chunk', scriptUrl.toString());`,
+                            `loadScript(scriptUrl.toString(), function(err, content) {`,
+                            Template.indent([
+                              "console.log('load script callback fired')",
+                              "if(err) {console.error('error loading remote chunk', scriptUrl.toString(),'got',content); return reject(err);}",
+                              'var chunk = {};',
+                              'try {',
+                              "require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+                                "(chunk, require, require('path').dirname(filename), filename);",
+                              '} catch (e) {',
+                              "console.log('runInThisContext thew', e)",
+                              '}',
+                              'installChunk(chunk);',
+                            ]),
+                            '});',
+                          ]),
+                          '}',
+                        ]),
+                        '});',
+                        'promises.push(installedChunkData[2] = promise);',
+                      ]),
+                      '} else installedChunks[chunkId] = 0;',
+                    ]),
+                    '}',
+                  ]),
+                  '}',
+                ])
+              : Template.indent(['installedChunks[chunkId] = 0;']),
+            '};',
+          ])
+        : '// no chunk loading',
+      '',
+      withExternalInstallChunk
+        ? Template.asString([
+            'module.exports = __webpack_require__;',
+            `${RuntimeGlobals.externalInstallChunk} = installChunk;`,
+          ])
+        : '// no external install chunk',
+      '',
+      withHmr
+        ? Template.asString([
+            'function loadUpdateChunk(chunkId, updatedModulesList) {',
+            Template.indent([
+              'return new Promise(function(resolve, reject) {',
+              Template.indent([
+                `var filename = require('path').join(__dirname, ${JSON.stringify(
+                  rootOutputDir
+                )} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
+                "require('fs').readFile(filename, 'utf-8', function(err, content) {",
+                Template.indent([
+                  'if(err) return reject(err);',
+                  'var update = {};',
+                  "require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+                    "(update, require, require('path').dirname(filename), filename);",
+                  'var updatedModules = update.modules;',
+                  'var runtime = update.runtime;',
+                  'for(var moduleId in updatedModules) {',
+                  Template.indent([
+                    `if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
+                    Template.indent([
+                      `currentUpdate[moduleId] = updatedModules[moduleId];`,
+                      'if(updatedModulesList) updatedModulesList.push(moduleId);',
+                    ]),
+                    '}',
+                  ]),
+                  '}',
+                  'if(runtime) currentUpdateRuntime.push(runtime);',
+                  'resolve();',
+                ]),
+                '});',
+              ]),
+              '});',
+            ]),
+            '}',
+            '',
+            Template.getFunctionContent(
+              require('../hmr/JavascriptHotModuleReplacement.runtime.js')
+            )
+              .replace(/\$key\$/g, 'readFileVm')
+              .replace(/\$installedChunks\$/g, 'installedChunks')
+              .replace(/\$loadUpdateChunk\$/g, 'loadUpdateChunk')
+              .replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+              .replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+              .replace(
+                /\$ensureChunkHandlers\$/g,
+                RuntimeGlobals.ensureChunkHandlers
+              )
+              .replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+              .replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+              .replace(
+                /\$hmrDownloadUpdateHandlers\$/g,
+                RuntimeGlobals.hmrDownloadUpdateHandlers
+              )
+              .replace(
+                /\$hmrInvalidateModuleHandlers\$/g,
+                RuntimeGlobals.hmrInvalidateModuleHandlers
+              ),
+          ])
+        : '// no HMR',
+      '',
+      withHmrManifest
+        ? Template.asString([
+            `${RuntimeGlobals.hmrDownloadManifest} = function() {`,
+            Template.indent([
+              'return new Promise(function(resolve, reject) {',
+              Template.indent([
+                `var filename = require('path').join(__dirname, ${JSON.stringify(
+                  rootOutputDir
+                )} + ${RuntimeGlobals.getUpdateManifestFilename}());`,
+                "require('fs').readFile(filename, 'utf-8', function(err, content) {",
+                Template.indent([
+                  'if(err) {',
+                  Template.indent([
+                    'if(err.code === "ENOENT") return resolve();',
+                    'return reject(err);',
+                  ]),
+                  '}',
+                  'try { resolve(JSON.parse(content)); }',
+                  'catch(e) { reject(e); }',
+                ]),
+                '});',
+              ]),
+              '});',
+            ]),
+            '}',
+          ])
+        : '// no HMR manifest',
+    ]);
+  }
+}
+
+module.exports = ReadFileChunkLoadingRuntimeModule;

package/src/NodeFederationPlugin.js

@@ -0,0 +1,245 @@
+'use strict';
+// 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')
+
+// Note on ESM.
+// Its possible to use ESM import, but its impossible to invalidate the module cache
+// So once something is imported, its stuck. This is problematic with at-runtime since we want to hot reload node
+// if ESM were used, youd be forced to restart the process to re-import modules or use a worker pool
+// Workaround is possible with query string on end of request, but this leaks memory badly
+// with commonjs, we can at least reset the require cache to "reboot" webpack runtime
+// It *can* leak memory, but ive not been able to replicate this to an extent that would be concerning.
+// ESM WILL leak memory, big difference.
+// Im talking with TC39 about a proposal around "virtual module trees" which would solve many problems.
+// VMT is like Realms but better - easiest analogy would be like forking the main thread, without going off main thread
+// VMT allows for scope isolation, but still allows reflection and non-primitive memory pointers to be shared - perfect for MFP
+
+//TODO: should use extractUrlAndGlobal from internal.js
+//TODO: should use Template system like LoadFileChunk runtime does.
+//TODO: should use vm.runInThisContext instead of eval
+//TODO: global.webpackChunkLoad could use a better convention? I have to use a special http client to get out of my infra firewall
+const executeLoadTemplate = `
+    function executeLoad(remoteUrl) {
+    console.log('remoteUrl',remoteUrl)
+        const scriptUrl = remoteUrl.split("@")[1];
+        const moduleName = remoteUrl.split("@")[0];
+        console.log("executing remote load", scriptUrl);
+        return new Promise(function (resolve, reject) {
+   
+         (global.webpackChunkLoad || global.fetch || require("node-fetch"))(scriptUrl).then(function(res){
+            return res.text();
+          }).then(function(scriptContent){
+            try {
+              const remote = eval(scriptContent + 'module.exports');
+              /* TODO: need something like a chunk loading queue, this can lead to async issues
+               if two containers load the same remote, they can overwrite global scope
+               should check someone is already loading remote and await that */
+              global.__remote_scope__[moduleName] = remote[moduleName] || remote
+              resolve(global.__remote_scope__[moduleName])
+            } catch(e) {
+              console.error('problem executing remote module', moduleName);
+              reject(e);
+            }
+          }).catch((e)=>{
+            console.error('failed to fetch remote', moduleName, scriptUrl);
+            console.error(e);
+            reject(null)
+          })
+        }).catch((e)=>{
+        console.error('error',e);
+          console.warn(moduleName,'is offline, returning fake remote')
+          return {
+            fake: true,
+            get:(arg)=>{
+              console.log('faking', arg,'module on', moduleName);
+
+              return ()=> Promise.resolve();
+            },
+            init:()=>{}
+          }
+        })
+    }
+`;
+
+function buildRemotes(mfConf, webpack) {
+  return Object.entries(mfConf.remotes || {}).reduce(
+    (acc, [name, config]) => {
+// if its already been converted into promise, dont do it again
+      if(config.startsWith('promise ') || config.startsWith('external ')){
+        acc.buildTime[name] = config;
+        return acc;
+      }
+      /*
+  TODO: global remote scope object should go into webpack runtime as a runtime requirement
+   this can be done by referencing my LoadFile, CommonJs plugins in this directory.
+  */
+      const [global, url] = config.split('@');
+      const loadTemplate = `promise new Promise((resolve)=>{
+    if(!global.__remote_scope__) {
+      // create a global scope for container, similar to how remotes are set on window in the browser
+      global.__remote_scope__ = {
+        _config: {},
+      }
+    }
+    
+    global.__remote_scope__._config[${JSON.stringify(global)}] = ${JSON.stringify(url)};
+ 
+    ${executeLoadTemplate}
+    resolve(executeLoad(${JSON.stringify(config)}))
+    }).then(remote=>{
+      console.log(remote);
+      
+      return {
+      get: remote.get,
+      init: (args)=> {
+        console.log(args)
+        return remote.init(args)
+      }
+    }
+  });
+  `;
+      acc.buildTime[name] = loadTemplate;
+      return acc;
+    },
+    { runtime: {}, buildTime: {}, hot: {} }
+  );
+  // return Object.entries(mfConf.remotes || {}).reduce(
+  //   (acc, [name, config]) => {
+  //     const hasMiddleware = config.startsWith('middleware ');
+  //     let middleware;
+  //     if (hasMiddleware) {
+  //       middleware = config.split('middleware ')[1];
+  //     } else {
+  //       middleware = `Promise.resolve(${JSON.stringify(config)})`;
+  //     }
+  //
+  //     const templateStart = `
+  //             var ${webpack.RuntimeGlobals.require} = ${
+  //       webpack.RuntimeGlobals.require
+  //     } ? ${
+  //       webpack.RuntimeGlobals.require
+  //     } : typeof arguments !== 'undefined' ? arguments[2] : false;
+  //              ${executeLoadTemplate}
+  //       global.loadedRemotes = global.loadedRemotes || {};
+  //       if (global.loadedRemotes[${JSON.stringify(name)}]) {
+  //         return global.loadedRemotes[${JSON.stringify(name)}]
+  //       }
+  //       // if using modern output, then there are no arguments on the parent function scope, thus we need to get it via a window global.
+  //
+  //     var shareScope = (${webpack.RuntimeGlobals.require} && ${
+  //       webpack.RuntimeGlobals.shareScopeMap
+  //     }) ? ${
+  //       webpack.RuntimeGlobals.shareScopeMap
+  //     } : global.__webpack_share_scopes__
+  //     var name = ${JSON.stringify(name)}
+  //     `;
+  //     const template = `(remotesConfig) => new Promise((res) => {
+  //     console.log('in template promise',JSON.stringify(remotesConfig))
+  //       executeLoad(remotesConfig).then((remote) => {
+  //
+  //         return Promise.resolve(remote.init(shareScope.default)).then(() => {
+  //           return remote
+  //         })
+  //       })
+  //         .then(function (remote) {
+  //           const proxy = {
+  //             get: remote.get,
+  //             chunkMap: remote.chunkMap,
+  //             path: remotesConfig.toString(),
+  //             init: (arg) => {
+  //               try {
+  //                 return remote.init(shareScope.default)
+  //               } catch (e) {
+  //                 console.log('remote container already initialized')
+  //               }
+  //             }
+  //           }
+  //           if (remote.fake) {
+  //             res(proxy);
+  //             return null
+  //           }
+  //
+  //           Object.assign(global.loadedRemotes, {
+  //             [name]: proxy
+  //           });
+  //
+  //           res(global.loadedRemotes[name])
+  //         })
+  //
+  //
+  //     })`;
+  //
+  //     acc.runtime[name] = `()=> ${middleware}.then((remoteConfig)=>{
+  //   console.log('remoteConfig runtime',remoteConfig);
+  //   if(!global.REMOTE_CONFIG) {
+  //       global.REMOTE_CONFIG = {};
+  //   }
+  //   global.REMOTE_CONFIG[${JSON.stringify(name)}] = remoteConfig;
+  //   ${templateStart}
+  //   const loadTemplate = ${template};
+  //   return loadTemplate(remoteConfig)
+  //   })`;
+  //
+  //     acc.buildTime[name] = `promise ${middleware}.then((remoteConfig)=>{
+  //           if(!global.REMOTE_CONFIG) {
+  //       global.REMOTE_CONFIG = {};
+  //   }
+  //   console.log('remoteConfig buildtime',remoteConfig);
+  //   global.REMOTE_CONFIG[${JSON.stringify(name)}] = remoteConfig;
+  //   ${templateStart};
+  //   const loadTemplate = ${template};
+  //   return loadTemplate(remoteConfig)
+  //   })`;
+  //
+  //     acc.hot[name] = `()=> ${middleware}`;
+  //
+  //     return acc;
+  //   },
+  //   { runtime: {}, buildTime: {}, hot: {} }
+  // );
+}
+
+class NodeFederationPlugin {
+  constructor({ experiments, ...options }, context) {
+    this.options = options || {};
+    this.context = context || {};
+    this.experiments = experiments || {};
+  }
+
+  apply(compiler) {
+    // When used with Next.js, context is needed to use Next.js webpack
+    const { webpack } = compiler;
+
+    const { buildTime, runtime, hot } = buildRemotes(
+      this.options,
+      webpack || require('webpack')
+    );
+    const defs = {
+      'process.env.REMOTES': runtime,
+      'process.env.REMOTE_CONFIG': hot,
+    };
+
+    // need to add this back to enabele runtime remotes, have commented out old promise new promise template
+    // new ((webpack && webpack.DefinePlugin) || require("webpack").DefinePlugin)(
+    //     defs
+    // ).apply(compiler);
+
+    const pluginOptions = {
+      ...this.options,
+      remotes: buildTime,
+    };
+
+    new (this.context.ModuleFederationPlugin || (webpack && webpack.container.ModuleFederationPlugin) ||
+      require('webpack/lib/container/ModuleFederationPlugin'))(
+      pluginOptions
+    ).apply(compiler);
+  }
+}
+
+module.exports = NodeFederationPlugin;

package/src/StreamingTargetPlugin.js

@@ -0,0 +1,42 @@
+const CommonJsChunkLoadingPlugin = require('./CommonJsChunkLoadingPlugin');
+
+class StreamingTargetPlugin {
+  constructor(options, context) {
+    this.options = options || {};
+    this.context = context || {};
+  }
+
+  apply(compiler) {
+    if (compiler.options.target) {
+      console.warn(
+        `target should be set to false while using NodeSoftwareStreamRuntime plugin, actual target: ${compiler.options.target}`
+      );
+    }
+
+    // When used with Next.js, context is needed to use Next.js webpack
+    const { webpack } = compiler;
+
+    // This will enable CommonJsChunkFormatPlugin
+    compiler.options.output.chunkFormat = 'commonjs';
+    // This will force async chunk loading
+    compiler.options.output.chunkLoading = 'async-node';
+    // Disable default config
+    compiler.options.output.enabledChunkLoadingTypes = false;
+
+    new ((webpack && webpack.node && webpack.node.NodeEnvironmentPlugin) ||
+      require('webpack/lib/node/NodeEnvironmentPlugin'))({
+      infrastructureLogging: compiler.options.infrastructureLogging,
+    }).apply(compiler);
+    new ((webpack && webpack.node && webpack.node.NodeTargetPlugin) ||
+      require('webpack/lib/node/NodeTargetPlugin'))().apply(compiler);
+    new CommonJsChunkLoadingPlugin({
+      asyncChunkLoading: true,
+      name: this.options.name,
+      remotes: this.options.remotes,
+      baseURI: compiler.options.output.publicPath, //TODO: should remove?
+      promiseBaseURI: this.options.promiseBaseURI, //TODO: should remove?
+    }).apply(compiler);
+  }
+}
+
+module.exports = StreamingTargetPlugin;

package/src/loadScript.js

@@ -0,0 +1,51 @@
+/**
+ * loadScript(baseURI, fileName, cb)
+ * loadScript(scriptUrl, cb)
+ */
+
+module.exports = `
+    function loadScript(url,cb,chunkID) {
+        var url;
+        var cb = arguments[arguments.length - 1];
+        if (typeof cb !== "function") {
+            throw new Error("last argument should be a function");
+        }
+        if (arguments.length === 2) {
+            url = arguments[0];
+        } else if (arguments.length === 3) {
+            url = new URL(arguments[1], arguments[0]).toString();
+        } else {
+            throw new Error("invalid number of arguments");
+        }
+      if(global.webpackChunkLoad){
+        global.webpackChunkLoad(url).then(function(resp){
+          return resp.text();
+        }).then(function(rawData){
+          cb(null, rawData);
+        }).catch(function(err){
+          console.error('Federated Chunk load failed', error);
+          return cb(error)
+        });
+      } else {
+        //TODO https support
+        let request = (url.startsWith('https') ? require('https') : require('http')).get(url, function (resp) {
+          if (resp.statusCode === 200) {
+            let rawData = '';
+            resp.setEncoding('utf8');
+            resp.on('data', chunk => {
+              rawData += chunk;
+            });
+            resp.on('end', () => {
+              cb(null, rawData);
+            });
+          } else {
+            cb(resp);
+          }
+        });
+        request.on('error', error => {
+          console.error('Federated Chunk load failed', error);
+          return cb(error)
+        });
+      }
+    }
+`;