@module-federation/data-prefetch 1.0.16 → 2.0.1

package/src/cli/index.ts

@@ -1,171 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-
-import {
-  encodeName,
-  moduleFederationPlugin,
-  MFPrefetchCommon,
-} from '@module-federation/sdk';
-import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
-import type { Compiler, WebpackPluginInstance } from 'webpack';
-
-import { TEMP_DIR } from '../common/constant';
-import { fileExistsWithCaseSync, fixPrefetchPath } from '../common/node-utils';
-import { getPrefetchId } from '../common/runtime-utils';
-
-const { RuntimeGlobals, Template } = require(
-  normalizeWebpackPath('webpack'),
-) as typeof import('webpack');
-
-export function getFederationGlobalScope(
-  runtimeGlobals: typeof RuntimeGlobals,
-): string {
-  return `${runtimeGlobals.require || '__webpack_require__'}.federation`;
-}
-
-export class PrefetchPlugin implements WebpackPluginInstance {
-  public options: moduleFederationPlugin.ModuleFederationPluginOptions;
-  private _reWriteExports: string;
-
-  constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions) {
-    this.options = options;
-    this._reWriteExports = '';
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  apply(compiler: Compiler) {
-    const { name, exposes } = this.options;
-    if (!exposes) {
-      return;
-    }
-    if (!compiler.options.context) {
-      throw new Error('compiler.options.context is not defined');
-    }
-
-    const { runtimePlugins } = this.options;
-    if (!Array.isArray(runtimePlugins)) {
-      this.options.runtimePlugins = [];
-    }
-
-    const runtimePath = path.resolve(__dirname, '../esm/plugin.js');
-    const sharedPath = path.resolve(__dirname, '../esm/shared/index.js');
-    if (!this.options.runtimePlugins?.includes(runtimePath)) {
-      this.options.runtimePlugins!.push(runtimePath);
-    }
-    if (!this.options.runtimePlugins?.includes(sharedPath)) {
-      this.options.runtimePlugins!.push(sharedPath);
-    }
-
-    const encodedName = encodeName(name as string);
-    const asyncEntryPath = path.resolve(
-      compiler.options.context,
-      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`,
-    );
-    if (fs.existsSync(asyncEntryPath)) {
-      fs.unlinkSync(asyncEntryPath);
-    }
-    if (!this.options.dataPrefetch) {
-      return;
-    }
-
-    const prefetchs: Array<string> = [];
-    const exposeAlias = Object.keys(exposes);
-    exposeAlias.forEach((alias) => {
-      let exposePath;
-      // @ts-ignore
-      const exposeValue = exposes[alias];
-      if (typeof exposeValue === 'string') {
-        exposePath = exposeValue;
-      } else {
-        exposePath = exposeValue.import[0];
-      }
-      const targetPaths = fixPrefetchPath(exposePath);
-      for (const pathItem of targetPaths) {
-        const absolutePath = path.resolve(compiler.options.context!, pathItem);
-        if (fileExistsWithCaseSync(absolutePath)) {
-          prefetchs.push(pathItem);
-          const absoluteAlias = alias.replace('.', '');
-          this._reWriteExports += `export * as ${getPrefetchId(
-            `${name}${absoluteAlias}`,
-          )} from '${absolutePath}';\n`;
-          break;
-        }
-      }
-    });
-
-    if (!this._reWriteExports) {
-      return;
-    }
-    const tempDirRealPath = path.resolve(
-      compiler.options.context,
-      'node_modules',
-      TEMP_DIR,
-    );
-    if (!fs.existsSync(tempDirRealPath)) {
-      fs.mkdirSync(tempDirRealPath);
-    }
-    if (!fs.existsSync(`${tempDirRealPath}/${encodedName}`)) {
-      fs.mkdirSync(`${tempDirRealPath}/${encodedName}`);
-    }
-    fs.writeFileSync(asyncEntryPath, this._reWriteExports);
-    new compiler.webpack.DefinePlugin({
-      FederationDataPrefetch: JSON.stringify(asyncEntryPath),
-    }).apply(compiler);
-  }
-
-  static addRuntime(
-    compiler: Compiler,
-    options: {
-      name: string;
-    },
-  ) {
-    const encodedName = encodeName(options.name as string);
-    if (!compiler.options.context) {
-      throw new Error('compiler.options.context is not defined');
-    }
-    const prefetchEntry = path.resolve(
-      compiler.options.context,
-      `node_modules/.mf/${encodedName}/bootstrap.js`,
-    );
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-
-    return Template.asString([
-      fs.existsSync(prefetchEntry)
-        ? Template.indent([
-            'function injectPrefetch() {',
-            `globalThis.__FEDERATION__ = globalThis.__FEDERATION__ || {};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] || {`,
-            `entryLoading: {},`,
-            `instance: new Map(),`,
-            `__PREFETCH_EXPORTS__: {},`,
-            `};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] || {};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}']['${options.name}'] = import('${prefetchEntry}');`,
-            '}',
-            `${federationGlobal}.prefetch = injectPrefetch`,
-          ])
-        : '',
-      Template.indent([
-        `if(!${federationGlobal}.isMFRemote && ${federationGlobal}.prefetch){`,
-        `${federationGlobal}.prefetch()`,
-        '}',
-      ]),
-    ]);
-  }
-
-  static setRemoteIdentifier() {
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-    return Template.indent([`${federationGlobal}.isMFRemote = true;`]);
-  }
-
-  static removeRemoteIdentifier() {
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-    return Template.indent([`${federationGlobal}.isMFRemote = false;`]);
-  }
-}

package/src/common/constant.ts

@@ -1 +0,0 @@
-export const TEMP_DIR = '.mf';

package/src/common/node-utils.ts

@@ -1,24 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-
-export const fileExistsWithCaseSync = (filepath: string): boolean => {
-  const dir = path.dirname(filepath);
-  if (filepath === '/' || filepath === '.') {
-    return true;
-  }
-  const filenames = fs.readdirSync(dir);
-  if (filenames.indexOf(path.basename(filepath)) === -1) {
-    return false;
-  }
-  return fileExistsWithCaseSync(dir);
-};
-
-export const fixPrefetchPath = (exposePath: string): Array<string> => {
-  const pathExt = ['.js', '.ts'];
-  const extReg = /\.(ts|js|tsx|jsx)$/;
-  if (extReg.test(exposePath)) {
-    return pathExt.map((ext) => exposePath.replace(extReg, `.prefetch${ext}`));
-  } else {
-    return pathExt.map((ext) => exposePath + `.prefetch${ext}`);
-  }
-};

package/src/common/runtime-utils.ts

@@ -1,34 +0,0 @@
-import { getInstance } from '@module-federation/runtime';
-import {
-  encodeName,
-  ModuleInfo,
-  MFPrefetchCommon,
-} from '@module-federation/sdk';
-
-export const getScope = (): string => {
-  return getInstance()!.options.name;
-};
-
-export const getPrefetchId = (id: string): string =>
-  encodeName(`${id}/${MFPrefetchCommon.identifier}`);
-
-export const compatGetPrefetchId = (id: string): string =>
-  encodeName(`${id}/VmokPrefetch`);
-
-export const getSignalFromManifest = (remoteSnapshot: ModuleInfo): boolean => {
-  if (!remoteSnapshot) {
-    return false;
-  }
-
-  if (
-    !('prefetchEntry' in remoteSnapshot) &&
-    !('prefetchInterface' in remoteSnapshot)
-  ) {
-    return false;
-  }
-
-  if (!remoteSnapshot.prefetchEntry && !remoteSnapshot.prefetchInterface) {
-    return false;
-  }
-  return true;
-};

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './prefetch';
-export * from './plugin';

package/src/logger/index.ts

@@ -1,3 +0,0 @@
-import { Logger } from '@module-federation/sdk';
-
-export default new Logger('[Module Federation Data Prefetch]');

package/src/plugin.ts

@@ -1,191 +0,0 @@
-import type { FederationRuntimePlugin } from '@module-federation/runtime/types';
-import { ModuleInfo, getResourceUrl } from '@module-federation/sdk';
-
-import { getSignalFromManifest } from './common/runtime-utils';
-import { MFDataPrefetch } from './prefetch';
-import logger from './logger';
-
-interface Loading {
-  id: string;
-  promise: Promise<
-    Array<{
-      value: any;
-      functionId: string;
-    }>
-  >;
-}
-const loadingArray: Array<Loading> = [];
-const strategy = 'loaded-first';
-let sharedFlag = strategy;
-// eslint-disable-next-line max-lines-per-function
-export const prefetchPlugin = (): FederationRuntimePlugin => ({
-  name: 'data-prefetch-runtime-plugin',
-  initContainer(options) {
-    const { remoteSnapshot, remoteInfo, id, origin } = options;
-    const snapshot = remoteSnapshot as ModuleInfo;
-    const { name } = remoteInfo;
-
-    const prefetchOptions = {
-      name,
-      remote: remoteInfo,
-      origin,
-      remoteSnapshot: snapshot,
-    };
-    const signal = getSignalFromManifest(snapshot);
-    if (!signal) {
-      return options;
-    }
-    if (sharedFlag !== strategy) {
-      throw new Error(
-        `[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`,
-      );
-    }
-
-    const instance =
-      MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
-
-    let prefetchUrl;
-    // @ts-expect-error
-    if (snapshot.prefetchEntry) {
-      // @ts-expect-error
-      prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry as string);
-    }
-
-    const exist = loadingArray.find((loading) => loading.id === id);
-    if (exist) {
-      return options;
-    }
-    const promise = instance.loadEntry(prefetchUrl).then(async () => {
-      const projectExports = instance!.getProjectExports();
-      if (projectExports instanceof Promise) {
-        await projectExports;
-      }
-      return Promise.resolve().then(() => {
-        const exports = instance!.getExposeExports(id);
-        logger.info(
-          `1. Start Prefetch initContainer: ${id} - ${performance.now()}`,
-        );
-        const result = Object.keys(exports).map((k) => {
-          const value = instance!.prefetch({
-            id,
-            functionId: k,
-          });
-          const functionId = k;
-
-          return {
-            value,
-            functionId,
-          };
-        });
-        return result;
-      });
-    });
-
-    loadingArray.push({
-      id,
-      promise,
-    });
-    return options;
-  },
-
-  afterResolve(options) {
-    const { remoteSnapshot, remoteInfo, id, origin } = options;
-    const snapshot = remoteSnapshot as ModuleInfo;
-    const { name } = remoteInfo;
-
-    const prefetchOptions = {
-      name,
-      remote: remoteInfo,
-      origin,
-      remoteSnapshot: snapshot,
-    };
-    const signal = getSignalFromManifest(snapshot);
-    if (!signal) {
-      return options;
-    }
-
-    const inited = loadingArray.some((info) => info.id === id);
-    if (!inited) {
-      return options;
-    }
-
-    if (sharedFlag !== strategy) {
-      throw new Error(
-        `[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`,
-      );
-    }
-
-    const instance =
-      MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
-
-    let prefetchUrl;
-    // @ts-expect-error
-    if (snapshot.prefetchEntry) {
-      // @ts-expect-error
-      prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry as string);
-    }
-
-    const index = loadingArray.findIndex((loading) => loading.id === id);
-    // clear cache
-    if (index !== -1) {
-      loadingArray.splice(index, 1);
-    }
-    const promise = instance.loadEntry(prefetchUrl).then(async () => {
-      const projectExports = instance!.getProjectExports();
-      if (projectExports instanceof Promise) {
-        await projectExports;
-      }
-      return Promise.resolve().then(() => {
-        const exports = instance!.getExposeExports(id);
-        logger.info(
-          `1. Start Prefetch afterResolve: ${id} - ${performance.now()}`,
-        );
-        const result = Object.keys(exports).map((k) => {
-          const value = instance!.prefetch({
-            id,
-            functionId: k,
-          });
-          const functionId = k;
-
-          return {
-            value,
-            functionId,
-          };
-        });
-        return result;
-      });
-    });
-
-    loadingArray.push({
-      id,
-      promise,
-    });
-    return options;
-  },
-  async onLoad(options) {
-    const { remote, id } = options;
-    const { name } = remote;
-    const promise = loadingArray.find((loading) => loading.id === id)?.promise;
-
-    if (promise) {
-      const prefetch = await promise;
-      const prefetchValue = prefetch.map((result) => result.value);
-      await Promise.all(prefetchValue);
-      const instance = MFDataPrefetch.getInstance(name);
-
-      prefetch.forEach((result: { value: any; functionId: string }) => {
-        const { value, functionId } = result;
-        instance!.memorize(id + functionId, value);
-      });
-    }
-    return options;
-  },
-
-  beforeLoadShare(options) {
-    const shareInfo = options.shareInfo;
-    sharedFlag = shareInfo?.strategy || sharedFlag;
-    return options;
-  },
-});
-
-export default prefetchPlugin;

package/src/prefetch.ts

@@ -1,207 +0,0 @@
-import {
-  FederationHost,
-  getRemoteEntry,
-  getRemoteInfo,
-} from '@module-federation/runtime';
-import {
-  loadScript,
-  ModuleInfo,
-  ProviderModuleInfo,
-} from '@module-federation/sdk';
-import { Remote } from '@module-federation/runtime/types';
-
-import { getPrefetchId, compatGetPrefetchId } from './common/runtime-utils';
-
-declare module '@module-federation/runtime' {
-  export interface Federation {
-    __PREFETCH__: {
-      entryLoading: Record<string, undefined | Promise<void>>;
-      instance: Map<string, MFDataPrefetch>;
-      __PREFETCH_EXPORTS__: Record<string, Promise<Record<string, any>>>;
-    };
-  }
-}
-
-type PrefetchExports = Record<string, any>;
-
-export interface DataPrefetchOptions {
-  name: string;
-  remote?: Remote;
-  origin?: FederationHost;
-  remoteSnapshot?: ModuleInfo;
-}
-
-export interface prefetchOptions {
-  id: string;
-  functionId?: string;
-  cacheStrategy?: () => boolean;
-  refetchParams?: any;
-}
-
-// @ts-ignore init global variable for test
-globalThis.__FEDERATION__ ??= {};
-globalThis.__FEDERATION__.__PREFETCH__ ??= {
-  entryLoading: {},
-  instance: new Map(),
-  __PREFETCH_EXPORTS__: {},
-};
-export class MFDataPrefetch {
-  public prefetchMemory: Map<string, Promise<any>>;
-  public recordOutdate: Record<string, Record<string, boolean>>;
-  private _exports: Record<string, any>;
-  private _options: DataPrefetchOptions;
-
-  constructor(options: DataPrefetchOptions) {
-    this.prefetchMemory = new Map();
-    this.recordOutdate = {};
-    this._exports = {};
-    this._options = options;
-    this.global.instance.set(options.name, this);
-  }
-
-  get global(): Record<string, any> {
-    return globalThis.__FEDERATION__.__PREFETCH__;
-  }
-
-  static getInstance(id: string): MFDataPrefetch | undefined {
-    return globalThis.__FEDERATION__.__PREFETCH__.instance.get(id);
-  }
-
-  async loadEntry(entry: string | undefined): Promise<any> {
-    const { name, remoteSnapshot, remote, origin } = this._options;
-
-    if (entry) {
-      const { buildVersion, globalName } = remoteSnapshot as ProviderModuleInfo;
-      const uniqueKey = globalName || `${name}:${buildVersion}`;
-
-      if (!this.global.entryLoading[uniqueKey]) {
-        this.global.entryLoading[uniqueKey] = loadScript(entry, {});
-      }
-      return this.global.entryLoading[uniqueKey];
-    } else {
-      const remoteInfo = getRemoteInfo(remote as Remote);
-      const module = origin!.moduleCache.get(remoteInfo.name);
-      return getRemoteEntry({
-        origin: origin!,
-        remoteInfo,
-        remoteEntryExports: module ? module.remoteEntryExports : undefined,
-      });
-    }
-  }
-
-  getProjectExports() {
-    if (Object.keys(this._exports).length > 0) {
-      return this._exports;
-    }
-    const { name } = this._options;
-    const exportsPromise =
-      globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__?.[name];
-    const resolve = exportsPromise.then(
-      (exports: Record<string, Record<string, any>> = {}) => {
-        // Match prefetch based on the function name suffix so that other capabilities can be expanded later.
-        // Not all functions should be directly identified as prefetch functions
-        const memory: Record<string, Record<string, any>> = {};
-        Object.keys(exports).forEach((key) => {
-          memory[key] = {};
-          const exportVal = exports[key];
-          Object.keys(exportVal).reduce(
-            (memo: Record<string, any>, current: string) => {
-              if (
-                current.toLocaleLowerCase().endsWith('prefetch') ||
-                current.toLocaleLowerCase() === 'default'
-              ) {
-                memo[current] = exportVal[current];
-              }
-              return memo;
-            },
-            memory[key],
-          );
-        });
-        this.memorizeExports(memory);
-      },
-    );
-    return resolve;
-  }
-
-  memorizeExports(exports: Record<string, any>): void {
-    this._exports = exports;
-  }
-
-  getExposeExports(id: string): PrefetchExports {
-    const prefetchId = getPrefetchId(id);
-    const compatId = compatGetPrefetchId(id);
-    const prefetchExports =
-      this._exports[prefetchId] || (this._exports[compatId] as PrefetchExports);
-    return prefetchExports || {};
-  }
-
-  prefetch(prefetchOptions: prefetchOptions): any {
-    const { id, functionId = 'default', refetchParams } = prefetchOptions;
-    let prefetchResult;
-    const prefetchId = getPrefetchId(id);
-    const compatId = compatGetPrefetchId(id);
-    const memorizeId = id + functionId;
-    const memory = this.prefetchMemory.get(memorizeId);
-    if (!this.checkOutdate(prefetchOptions) && memory) {
-      return memory;
-    }
-
-    const prefetchExports =
-      this._exports[prefetchId] || (this._exports[compatId] as PrefetchExports);
-    if (!prefetchExports) {
-      return;
-    }
-    const executePrefetch = prefetchExports[functionId];
-    if (typeof executePrefetch === 'function') {
-      if (refetchParams) {
-        prefetchResult = executePrefetch(refetchParams);
-      } else {
-        prefetchResult = executePrefetch();
-      }
-    } else {
-      throw new Error(
-        `[Module Federation Data Prefetch]: No prefetch function called ${functionId} export in prefetch file`,
-      );
-    }
-    this.memorize(memorizeId, prefetchResult);
-    return prefetchResult;
-  }
-
-  memorize(id: string, value: any): void {
-    this.prefetchMemory.set(id, value);
-  }
-
-  markOutdate(
-    markOptions: Omit<prefetchOptions, 'cacheStrategy'>,
-    isOutdate: boolean,
-  ): void {
-    const { id, functionId = 'default' } = markOptions;
-    if (!this.recordOutdate[id]) {
-      this.recordOutdate[id] = {};
-    }
-    this.recordOutdate[id][functionId] = isOutdate;
-  }
-
-  checkOutdate(outdateOptions: prefetchOptions): boolean {
-    const { id, functionId = 'default', cacheStrategy } = outdateOptions;
-    if (typeof cacheStrategy === 'function') {
-      return cacheStrategy();
-    }
-
-    if (!this.recordOutdate[id]) {
-      this.recordOutdate[id] = {};
-    }
-    if (this.recordOutdate[id][functionId]) {
-      this.markOutdate(
-        {
-          id,
-          functionId,
-        },
-        false,
-      );
-      return true;
-    } else {
-      return false;
-    }
-  }
-}