feat(nf): Updated to cache per bundle

Author: Aukevanoost

libs/native-federation-core/src/lib/core/build-for-federation.ts

@@ -14,15 +14,7 @@ import { FederationOptions } from './federation-options';
 import { writeFederationInfo } from './write-federation-info';
 import { writeImportMap } from './write-import-map';
 import { logger } from '../utils/logger';
-import {
-  copyCacheToDist,
-  getCachedMetadata,
-  getCachePath,
-  getChecksum,
-  purgeCacheFolder,
-  storeCachedMetadata,
-} from './get-cache';
-import path from 'path';
+import { getCachePath } from './get-cache';
 import { normalizeFilename } from '../utils/normalize';
 
 export interface BuildParams {
@@ -35,6 +27,8 @@ export const defaultBuildParams: BuildParams = {
   skipShared: false,
 };
 
+const sharedPackageInfoCache: SharedInfo[] = [];
+
 export async function buildForFederation(
   config: NormalizedFederationConfig,
   fedOptions: FederationOptions,
@@ -67,24 +61,16 @@ export async function buildForFederation(
     );
   }
 
-  const cacheFolder = getCachePath(
+  const pathToCache = getCachePath(
     fedOptions.workspaceRoot,
     normalizeFilename(config.name)
   );
-  const cacheChecksum = getChecksum(config.shared);
-
-  const sharedPackageInfoCache: SharedInfo[] = getCachedMetadata(
-    cacheFolder,
-    cacheChecksum
-  );
 
   if (!buildParams.skipShared && sharedPackageInfoCache.length > 0) {
     logger.info('Checksum matched, re-using cached externals.');
   }
 
   if (!buildParams.skipShared && sharedPackageInfoCache.length === 0) {
-    purgeCacheFolder(cacheFolder);
-
     const { sharedBrowser, sharedServer, separateBrowser, separateServer } =
       splitShared(config.shared);
 
@@ -96,7 +82,7 @@ export async function buildForFederation(
         fedOptions,
         externals,
         'browser',
-        cacheFolder
+        { pathToCache, metaDataFile: 'meta-browser-shared.json' }
       );
 
       logger.measure(
@@ -115,7 +101,7 @@ export async function buildForFederation(
         fedOptions,
         externals,
         'node',
-        cacheFolder
+        { pathToCache, metaDataFile: 'meta-node-shared.json' }
       );
       logger.measure(
         start,
@@ -132,7 +118,7 @@ export async function buildForFederation(
         config,
         fedOptions,
         'browser',
-        cacheFolder
+        pathToCache
       );
       logger.measure(
         start,
@@ -149,20 +135,14 @@ export async function buildForFederation(
         config,
         fedOptions,
         'node',
-        cacheFolder
+        pathToCache
       );
       logger.measure(
         start,
         '[build artifacts] - To bundle all separate node externals'
       );
       sharedPackageInfoCache.push(...separatePackageInfoServer);
     }
-
-    copyCacheToDist(
-      cacheFolder,
-      path.join(fedOptions.workspaceRoot, fedOptions.outputPath)
-    );
-    storeCachedMetadata(cacheFolder, cacheChecksum, sharedPackageInfoCache);
   }
 
   const sharedMappingInfo = !artefactInfo
@@ -208,7 +188,7 @@ async function bundleSeparate(
   config: NormalizedFederationConfig,
   fedOptions: FederationOptions,
   platform: 'node' | 'browser',
-  dest: string
+  pathToCache: string
 ) {
   const bundlePromises = Object.entries(separateBrowser).map(
     async ([key, shared]) => {
@@ -222,7 +202,10 @@ async function bundleSeparate(
         fedOptions,
         filteredExternals,
         platform,
-        dest
+        {
+          pathToCache,
+          metaDataFile: `meta-${platform}-${normalizeFilename(key)}.json`,
+        }
       );
     }
   );

libs/native-federation-core/src/lib/core/bundle-shared.ts

@@ -17,20 +17,48 @@ import {
   isSourceFile,
   rewriteChunkImports,
 } from '../utils/rewrite-chunk-imports';
+import {
+  copyCacheToDist,
+  getCachedMetadata,
+  getChecksum,
+  purgeCacheFolder,
+  storeCachedMetadata,
+} from './get-cache';
 
 export async function bundleShared(
   sharedBundles: Record<string, NormalizedSharedConfig>,
   config: NormalizedFederationConfig,
   fedOptions: FederationOptions,
   externals: string[],
   platform: 'browser' | 'node' = 'browser',
-  dest: string
+  cache: { pathToCache: string; metaDataFile: string }
 ): Promise<Array<SharedInfo>> {
+  const checksum = getChecksum(sharedBundles);
   const folder = fedOptions.packageJson
     ? path.dirname(fedOptions.packageJson)
     : fedOptions.workspaceRoot;
 
-  fs.mkdirSync(dest, { recursive: true });
+  fs.mkdirSync(cache.pathToCache, { recursive: true });
+
+  const sharedPackageInfoCache = getCachedMetadata(
+    cache.pathToCache,
+    cache.metaDataFile,
+    checksum
+  );
+
+  if (sharedPackageInfoCache) {
+    logger.info(
+      `Checksum of ${cache.metaDataFile} matched, Skipped artifact bundling`
+    );
+    copyCacheToDist(
+      cache.pathToCache,
+      cache.metaDataFile,
+      path.join(fedOptions.workspaceRoot, fedOptions.outputPath)
+    );
+    return sharedPackageInfoCache;
+  }
+
+  purgeCacheFolder(cache.pathToCache, cache.metaDataFile);
 
   const inferredPackageInfos = Object.keys(sharedBundles)
     .filter((packageName) => !sharedBundles[packageName].packageInfo)
@@ -66,7 +94,7 @@ export async function bundleShared(
     path.join(fullOutputPath, ep.outName)
   );
   const entryPoints = allEntryPoints.filter(
-    (ep) => !fs.existsSync(path.join(dest, ep.outName))
+    (ep) => !fs.existsSync(path.join(cache.pathToCache, ep.outName))
   );
 
   if (entryPoints.length > 0) {
@@ -93,7 +121,7 @@ export async function bundleShared(
       entryPoints,
       tsConfigPath: fedOptions.tsConfig,
       external: [...additionalExternals, ...externals],
-      outdir: dest,
+      outdir: cache.pathToCache,
       mappedPaths: config.sharedMappings,
       dev: fedOptions.dev,
       kind: 'shared-package',
@@ -103,9 +131,7 @@ export async function bundleShared(
     });
 
     const cachedFiles = bundleResult.map((br) => path.basename(br.fileName));
-    rewriteImports(cachedFiles, dest);
-
-    // copyCacheToOutput(cachedFiles, cachePath, fullOutputPath);
+    rewriteImports(cachedFiles, cache.pathToCache);
   } catch (e) {
     logger.error('Error bundling shared npm package ');
     if (e instanceof Error) {
@@ -156,6 +182,18 @@ export async function bundleShared(
 
   addChunksToResult(chunks, result, fedOptions.dev);
 
+  storeCachedMetadata(cache.pathToCache, cache.metaDataFile, {
+    checksum,
+    externals: result,
+    files: bundleResult.map((r) => r.fileName.split('/').pop() ?? r.fileName),
+  });
+
+  copyCacheToDist(
+    cache.pathToCache,
+    cache.metaDataFile,
+    path.join(fedOptions.workspaceRoot, fedOptions.outputPath)
+  );
+
   return result;
 }
 

libs/native-federation-core/src/lib/core/get-cache.ts

@@ -3,6 +3,7 @@ import fs from 'fs';
 import crypto from 'crypto';
 import { NormalizedSharedConfig } from '../config/federation-config';
 import { SharedInfo } from '@softarc/native-federation-runtime';
+import { logger } from '../utils/logger';
 
 export const getCachePath = (workspaceRoot: string, project: string) =>
   path.join(workspaceRoot, 'node_modules/.cache/native-federation', project);
@@ -26,60 +27,79 @@ export const getChecksum = (
 
 export const getCachedMetadata = (
   pathToCache: string,
+  file: string,
   checksum: string
-): SharedInfo[] => {
-  const metadataFile = path.join(pathToCache, 'metadata.json');
-  if (!fs.existsSync(metadataFile)) return [];
+): SharedInfo[] | false => {
+  const metadataFile = path.join(pathToCache, file);
+  if (!fs.existsSync(metadataFile)) return false;
 
-  const cachedResult: { checksum: string; externals: SharedInfo[] } =
-    JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
-  if (cachedResult.checksum !== checksum) return [];
+  const cachedResult: {
+    checksum: string;
+    externals: SharedInfo[];
+    files: string[];
+  } = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+  if (cachedResult.checksum !== checksum) return false;
   return cachedResult.externals;
 };
 
 export const storeCachedMetadata = (
   pathToCache: string,
-  checksum: string,
-  externals: SharedInfo[]
+  file: string,
+  payload: { checksum: string; externals: SharedInfo[]; files: string[] }
 ) => {
   fs.writeFileSync(
-    path.join(pathToCache, 'metadata.json'),
-    JSON.stringify({ checksum, externals }, undefined, 2),
+    path.join(pathToCache, file),
+    JSON.stringify(payload, undefined, 2),
     'utf-8'
   );
 };
 
 export const copyCacheToDist = (
   pathToCache: string,
+  file: string,
   fullOutputPath: string
 ) => {
-  fs.readdirSync(pathToCache).forEach((file) => {
-    if (file === 'metadata.json') return;
+  const metadataFile = path.join(pathToCache, file);
+  if (!fs.existsSync(metadataFile))
+    throw new Error(
+      'Error copying artifacts to dist, metadata file could not be found.'
+    );
+
+  const cachedResult: {
+    checksum: string;
+    externals: SharedInfo[];
+    files: string[];
+  } = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+
+  fs.mkdirSync(path.dirname(fullOutputPath), { recursive: true });
+
+  cachedResult.files.forEach((file) => {
     const cachedFile = path.join(pathToCache, file);
     const distFileName = path.join(fullOutputPath, file);
 
     if (fs.existsSync(cachedFile)) {
       fs.copyFileSync(cachedFile, distFileName);
     }
-    console.log(file);
   });
-  fs.mkdirSync(path.dirname(fullOutputPath), { recursive: true });
 };
 
-export const purgeCacheFolder = (pathToCache: string) => {
-  if (!fs.existsSync(pathToCache)) return;
-
-  try {
-    fs.rmSync(pathToCache, { recursive: true, force: true });
-  } catch (error) {
-    // Fallback for older Node.js versions or if rmSync fails
-    try {
-      fs.rmdirSync(pathToCache, { recursive: true });
-    } catch (fallbackError) {
-      console.warn(
-        `Failed to purge cache folder: ${pathToCache}`,
-        fallbackError
-      );
-    }
+export const purgeCacheFolder = (pathToCache: string, file: string) => {
+  const metadataFile = path.join(pathToCache, file);
+  if (!fs.existsSync(metadataFile)) {
+    logger.warn(
+      `Could not purge cache, metadata file '${file}' could not be found.`
+    );
   }
+
+  const cachedResult: {
+    checksum: string;
+    externals: SharedInfo[];
+    files: string[];
+  } = JSON.parse(fs.readFileSync(metadataFile, 'utf-8'));
+
+  cachedResult.files.forEach((file) => {
+    const cachedFile = path.join(pathToCache, file);
+
+    if (fs.existsSync(cachedFile)) fs.unlinkSync(cachedFile);
+  });
 };