Feat/avoid extract same zip (#2450)

ilteoood · web-flow · commit 3d6161311bd8 · 2024-05-06T07:37:06.000+02:00
diff --git a/.changeset/bright-shirts-leave.md b/.changeset/bright-shirts-leave.md
@@ -0,0 +1,6 @@
+---
+'@module-federation/native-federation-typescript': minor
+'@module-federation/native-federation-tests': minor
+---
+
+perf(native-federation): extract archive only if needed
diff --git a/packages/native-federation-tests/src/index.ts b/packages/native-federation-tests/src/index.ts
@@ -1,5 +1,4 @@
 import ansiColors from 'ansi-colors';
-import { rm } from 'fs/promises';
 import { resolve } from 'path';
 import { mergeDeepRight, mergeRight } from 'rambda';
 import { build } from 'tsup';
@@ -9,8 +8,11 @@ import { retrieveHostConfig } from './configurations/hostPlugin';
 import { retrieveRemoteConfig } from './configurations/remotePlugin';
 import { HostOptions } from './interfaces/HostOptions';
 import { RemoteOptions } from './interfaces/RemoteOptions';
-import { createTestsArchive, downloadTypesArchive } from './lib/archiveHandler';
-import { cleanMocksFolder } from './lib/mocksClean';
+import {
+  createTestsArchive,
+  deleteTestsFolder,
+  downloadTypesArchive,
+} from './lib/archiveHandler';
 
 export const NativeFederationTestsRemote = createUnplugin(
   (options: RemoteOptions) => {
@@ -37,9 +39,8 @@ export const NativeFederationTestsRemote = createUnplugin(
 
           await createTestsArchive(remoteOptions, compiledFilesFolder);
 
-          if (remoteOptions.deleteTestsFolder) {
-            await rm(compiledFilesFolder, { recursive: true, force: true });
-          }
+          await deleteTestsFolder(remoteOptions, compiledFilesFolder);
+
           console.log(ansiColors.green('Federated mocks created correctly'));
         } catch (error) {
           console.error(
@@ -82,17 +83,10 @@ export const NativeFederationTestsRemote = createUnplugin(
 export const NativeFederationTestsHost = createUnplugin(
   (options: HostOptions) => {
     const { hostOptions, mapRemotesToDownload } = retrieveHostConfig(options);
+    const typesDownloader = downloadTypesArchive(hostOptions);
     return {
       name: 'native-federation-tests/host',
       async writeBundle() {
-        if (hostOptions.deleteTestsFolder) {
-          await cleanMocksFolder(
-            hostOptions,
-            Object.keys(mapRemotesToDownload),
-          );
-        }
-
-        const typesDownloader = downloadTypesArchive(hostOptions);
         const downloadPromises =
           Object.entries(mapRemotesToDownload).map(typesDownloader);
 
diff --git a/packages/native-federation-tests/src/lib/archiveHandler.test.ts b/packages/native-federation-tests/src/lib/archiveHandler.test.ts
@@ -41,7 +41,9 @@ describe('archiveHandler', () => {
   });
 
   describe('downloadTypesArchive', () => {
-    const archivePath = join(tmpDir, 'testsHostFolder');
+    const destinationFolder = 'testsHostFolder';
+    const archivePath = join(tmpDir, destinationFolder);
+    const fileToDownload = 'https://foo.it';
     const hostOptions = {
       moduleFederationConfig: {},
       mocksFolder: archivePath,
@@ -66,10 +68,37 @@ describe('archiveHandler', () => {
       axios.get = vi.fn().mockResolvedValueOnce({ data: zip.toBuffer() });
 
       await downloadTypesArchive(hostOptions)([
-        'testsHostFolder',
-        'https://foo.it',
+        destinationFolder,
+        fileToDownload,
       ]);
       expect(existsSync(archivePath)).toBeTruthy();
     });
+
+    it('correctly extracts downloaded archive - skips same zip file', async () => {
+      const zip = new AdmZip();
+      await zip.addLocalFolderPromise(tmpDir, {});
+
+      axios.get = vi.fn().mockResolvedValue({ data: zip.toBuffer() });
+
+      const downloader = downloadTypesArchive(hostOptions);
+
+      await downloader([destinationFolder, fileToDownload]);
+      await downloader([destinationFolder, fileToDownload]);
+
+      expect(existsSync(archivePath)).toBeTruthy();
+      expect(axios.get).toHaveBeenCalledTimes(2);
+      expect(axios.get.mock.calls[0]).toStrictEqual([
+        fileToDownload,
+        {
+          responseType: 'arraybuffer',
+        },
+      ]);
+      expect(axios.get.mock.calls[1]).toStrictEqual([
+        fileToDownload,
+        {
+          responseType: 'arraybuffer',
+        },
+      ]);
+    });
   });
 });
diff --git a/packages/native-federation-tests/src/lib/archiveHandler.ts b/packages/native-federation-tests/src/lib/archiveHandler.ts
@@ -1,7 +1,9 @@
 import AdmZip from 'adm-zip';
 import ansiColors from 'ansi-colors';
 import axios from 'axios';
-import { join } from 'path';
+import { createHash } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
 
 import { HostOptions } from '../interfaces/HostOptions';
 import { RemoteOptions } from '../interfaces/RemoteOptions';
@@ -26,8 +28,24 @@ const downloadErrorLogger =
     };
   };
 
+export const deleteTestsFolder = async (
+  options: Required<HostOptions> | Required<RemoteOptions>,
+  destinationPath: string,
+) => {
+  if (options.deleteTestsFolder) {
+    await rm(destinationPath, {
+      recursive: true,
+      force: true,
+    }).catch((error) =>
+      console.error(ansiColors.red(`Unable to remove tests folder, ${error}`)),
+    );
+  }
+};
+
 export const downloadTypesArchive = (hostOptions: Required<HostOptions>) => {
   const retriesPerFile: Record<string, number> = {};
+  const hashPerFile: Record<string, string> = {};
+
   return async ([destinationFolder, fileToDownload]: string[]) => {
     retriesPerFile[fileToDownload] = 0;
     const destinationPath = join(hostOptions.mocksFolder, destinationFolder);
@@ -38,8 +56,19 @@ export const downloadTypesArchive = (hostOptions: Required<HostOptions>) => {
           .get(fileToDownload, { responseType: 'arraybuffer' })
           .catch(downloadErrorLogger(destinationFolder, fileToDownload));
 
-        const zip = new AdmZip(Buffer.from(response.data));
-        zip.extractAllTo(destinationPath, true);
+        const responseBuffer = Buffer.from(response.data);
+
+        const hash = createHash('sha256').update(responseBuffer).digest('hex');
+
+        if (hashPerFile[fileToDownload] !== hash) {
+          await deleteTestsFolder(hostOptions, destinationPath);
+
+          const zip = new AdmZip(responseBuffer);
+          zip.extractAllTo(destinationPath, true);
+
+          hashPerFile[fileToDownload] = hash;
+        }
+
         break;
       } catch (error: any) {
         console.error(
diff --git a/packages/native-federation-tests/src/lib/mocksClean.ts b/packages/native-federation-tests/src/lib/mocksClean.ts
diff --git a/packages/native-federation-typescript/src/index.ts b/packages/native-federation-typescript/src/index.ts
@@ -1,14 +1,17 @@
 import ansiColors from 'ansi-colors';
-import { rm } from 'fs/promises';
-import { resolve } from 'path';
+import { resolve } from 'node:path';
 import { mergeDeepRight } from 'rambda';
 import { UnpluginOptions, createUnplugin } from 'unplugin';
 
 import { retrieveHostConfig } from './configurations/hostPlugin';
 import { retrieveRemoteConfig } from './configurations/remotePlugin';
 import { HostOptions } from './interfaces/HostOptions';
 import { RemoteOptions } from './interfaces/RemoteOptions';
-import { createTypesArchive, downloadTypesArchive } from './lib/archiveHandler';
+import {
+  createTypesArchive,
+  deleteTypesFolder,
+  downloadTypesArchive,
+} from './lib/archiveHandler';
 import {
   compileTs,
   retrieveMfTypesPath,
@@ -19,6 +22,7 @@ export const NativeFederationTypeScriptRemote = createUnplugin(
   (options: RemoteOptions) => {
     const { remoteOptions, tsConfig, mapComponentsToExpose } =
       retrieveRemoteConfig(options);
+    const typesPath = retrieveMfTypesPath(tsConfig, remoteOptions);
     return {
       name: 'native-federation-typescript/remote',
       async writeBundle() {
@@ -27,12 +31,8 @@ export const NativeFederationTypeScriptRemote = createUnplugin(
 
           await createTypesArchive(tsConfig, remoteOptions);
 
-          if (remoteOptions.deleteTypesFolder) {
-            await rm(retrieveMfTypesPath(tsConfig, remoteOptions), {
-              recursive: true,
-              force: true,
-            });
-          }
+          await deleteTypesFolder(remoteOptions, typesPath);
+
           console.log(ansiColors.green('Federated types created correctly'));
         } catch (error) {
           console.error(
@@ -79,21 +79,10 @@ export const NativeFederationTypeScriptRemote = createUnplugin(
 export const NativeFederationTypeScriptHost = createUnplugin(
   (options: HostOptions) => {
     const { hostOptions, mapRemotesToDownload } = retrieveHostConfig(options);
+    const typesDownloader = downloadTypesArchive(hostOptions);
     return {
       name: 'native-federation-typescript/host',
       async writeBundle() {
-        if (hostOptions.deleteTypesFolder) {
-          await rm(hostOptions.typesFolder, {
-            recursive: true,
-            force: true,
-          }).catch((error) =>
-            console.error(
-              ansiColors.red(`Unable to remove types folder, ${error}`),
-            ),
-          );
-        }
-
-        const typesDownloader = downloadTypesArchive(hostOptions);
         const downloadPromises =
           Object.entries(mapRemotesToDownload).map(typesDownloader);
 
diff --git a/packages/native-federation-typescript/src/lib/archiveHandler.test.ts b/packages/native-federation-typescript/src/lib/archiveHandler.test.ts
@@ -75,6 +75,35 @@ describe('archiveHandler', () => {
       });
     });
 
+    it('correctly extracts downloaded archive - skips same zip file', async () => {
+      const archivePath = join(tmpDir, destinationFolder);
+
+      const zip = new AdmZip();
+      await zip.addLocalFolderPromise(tmpDir, {});
+
+      axios.get = vi.fn().mockResolvedValue({ data: zip.toBuffer() });
+
+      const downloader = downloadTypesArchive(hostOptions);
+
+      await downloader([destinationFolder, fileToDownload]);
+      await downloader([destinationFolder, fileToDownload]);
+
+      expect(existsSync(archivePath)).toBeTruthy();
+      expect(axios.get).toHaveBeenCalledTimes(2);
+      expect(axios.get.mock.calls[0]).toStrictEqual([
+        fileToDownload,
+        {
+          responseType: 'arraybuffer',
+        },
+      ]);
+      expect(axios.get.mock.calls[1]).toStrictEqual([
+        fileToDownload,
+        {
+          responseType: 'arraybuffer',
+        },
+      ]);
+    });
+
     it('correctly handles exception', async () => {
       const message = 'Rejected value';
 
diff --git a/packages/native-federation-typescript/src/lib/archiveHandler.ts b/packages/native-federation-typescript/src/lib/archiveHandler.ts
@@ -1,7 +1,9 @@
 import AdmZip from 'adm-zip';
 import ansiColors from 'ansi-colors';
 import axios from 'axios';
-import { join } from 'path';
+import { createHash } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
 import typescript from 'typescript';
 
 import { HostOptions } from '../interfaces/HostOptions';
@@ -36,8 +38,24 @@ const downloadErrorLogger =
     };
   };
 
+export const deleteTypesFolder = async (
+  options: Required<HostOptions> | Required<RemoteOptions>,
+  destinationPath: string,
+) => {
+  if (options.deleteTypesFolder) {
+    await rm(destinationPath, {
+      recursive: true,
+      force: true,
+    }).catch((error) =>
+      console.error(ansiColors.red(`Unable to remove types folder, ${error}`)),
+    );
+  }
+};
+
 export const downloadTypesArchive = (hostOptions: Required<HostOptions>) => {
   const retriesPerFile: Record<string, number> = {};
+  const hashPerFile: Record<string, string> = {};
+
   return async ([destinationFolder, fileToDownload]: string[]) => {
     retriesPerFile[fileToDownload] = 0;
     const destinationPath = join(hostOptions.typesFolder, destinationFolder);
@@ -48,8 +66,19 @@ export const downloadTypesArchive = (hostOptions: Required<HostOptions>) => {
           .get(fileToDownload, { responseType: 'arraybuffer' })
           .catch(downloadErrorLogger(destinationFolder, fileToDownload));
 
-        const zip = new AdmZip(Buffer.from(response.data));
-        zip.extractAllTo(destinationPath, true);
+        const responseBuffer = Buffer.from(response.data);
+
+        const hash = createHash('sha256').update(responseBuffer).digest('hex');
+
+        if (hashPerFile[fileToDownload] !== hash) {
+          await deleteTypesFolder(hostOptions, destinationPath);
+
+          const zip = new AdmZip(responseBuffer);
+          zip.extractAllTo(destinationPath, true);
+
+          hashPerFile[fileToDownload] = hash;
+        }
+
         break;
       } catch (error: any) {
         console.error(
