@softarc/native-federation 4.0.0 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "type": "module",
   "license": "MIT",
   "dependencies": {

package/src/lib/core/build-for-federation.js

@@ -87,8 +87,14 @@ export async function buildForFederation(config, fedOptions, externals, signal)
     if (artifactInfo?.chunks) {
         federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
     }
+    if (fedOptions.integrity) {
+        federationInfo.integrity = {
+            ...(fedOptions.federationCache.integrity ?? {}),
+            ...(artifactInfo?.integrity ?? {}),
+        };
+    }
     writeFederationInfo(federationInfo, fedOptions);
-    writeImportMap(fedOptions.federationCache, fedOptions);
+    writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
     return federationInfo;
 }
 function inferPackageFromSecondary(secondary) {
@@ -123,7 +129,15 @@ async function bundleSeparatePackages(separateBrowser, externals, config, fedOpt
         if (r.chunks) {
             chunks = { ...(acc.chunks ?? {}), ...r.chunks };
         }
-        return { externals: [...acc.externals, ...r.externals], chunks };
+        let integrity = acc.integrity;
+        if (r.integrity) {
+            integrity = { ...(acc.integrity ?? {}), ...r.integrity };
+        }
+        return {
+            externals: [...acc.externals, ...r.externals],
+            chunks,
+            integrity,
+        };
     }, { externals: [] });
 }
 function splitShared(shared) {

package/src/lib/core/bundle-exposed-and-mappings.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { integrityForFile } from '../utils/hash-file.js';
 import { createBuildResultMap, popFromResultMap } from '../utils/build-result-map.js';
 import { logger } from '../utils/logger.js';
 import { normalize } from '../utils/normalize.js';
@@ -55,7 +56,10 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
         }
         throw error;
     }
-    const resultMap = createBuildResultMap(result, hash);
+    const resultMap = createBuildResultMap(result, hash, [
+        ...shared.map(s => s.outName),
+        ...exposes.map(e => e.outName),
+    ]);
     const sharedResult = [];
     const entryFiles = [];
     // Pick shared-mappings
@@ -97,14 +101,26 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
         .forEach(f => popFromResultMap(resultMap, f));
     // Process remaining chunks and lazy loaded internal modules
     let exportedChunks = undefined;
+    const chunkPaths = [];
     if (config.chunks && config.features.denseChunking) {
         for (const entryFile of entryFiles)
             rewriteChunkImports(entryFile);
+        chunkPaths.push(...Object.values(resultMap));
         exportedChunks = {
-            ['mapping-or-exposed']: Object.values(resultMap).map(chunk => path.basename(chunk)),
+            ['mapping-or-exposed']: chunkPaths.map(chunk => path.basename(chunk)),
         };
     }
-    return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks };
+    // Must run after rewriteChunkImports so SRI matches the final on-disk bytes.
+    let integrity;
+    if (fedOptions.integrity) {
+        integrity = {};
+        for (const filePath of [...entryFiles, ...chunkPaths]) {
+            if (!fs.existsSync(filePath))
+                continue;
+            integrity[path.basename(filePath)] = integrityForFile(filePath);
+        }
+    }
+    return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks, integrity };
 }
 export function describeExposed(config, options) {
     const result = [];

package/src/lib/core/bundle-shared.d.ts

@@ -1,5 +1,5 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import type { SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
 import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
 import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
 export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
@@ -9,4 +9,5 @@ export declare function bundleShared(sharedBundles: Record<string, NormalizedExt
 }): Promise<{
     externals: SharedInfo[];
     chunks?: Record<string, string[]>;
+    integrity?: IntegrityMap;
 }>;

package/src/lib/core/bundle-shared.js

@@ -9,6 +9,7 @@ import { toChunkImport } from '../domain/core/chunk.js';
 import { cacheEntry, getChecksum, getFilename } from '../utils/cache-persistence.js';
 import { fileURLToPath } from 'url';
 import { getBuildAdapter } from './build-adapter.js';
+import { integrityForFile } from '../utils/hash-file.js';
 export async function bundleShared(sharedBundles, config, fedOptions, externals, buildOptions) {
     const checksum = getChecksum(sharedBundles, fedOptions.dev ? '1' : '0');
     const folder = fedOptions.packageJson
@@ -20,7 +21,15 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
         if (cacheMetadata) {
             logger.debug(`Checksum of ${buildOptions.bundleName} matched, Skipped artifact bundling`);
             bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-            return { externals: cacheMetadata.externals, chunks: cacheMetadata.chunks };
+            let integrity = cacheMetadata.integrity;
+            if (fedOptions.integrity && !integrity) {
+                integrity = computeIntegrityForFiles(cacheMetadata.files, fedOptions.federationCache.cachePath);
+            }
+            return {
+                externals: cacheMetadata.externals,
+                chunks: cacheMetadata.chunks,
+                integrity,
+            };
         }
     }
     bundleCache.clear();
@@ -111,14 +120,32 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
     else {
         addChunksToResult(chunks, result);
     }
+    const persistedFiles = bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName);
+    // Must run after rewriteImports so SRI matches the bytes copied to dist.
+    const integrity = fedOptions.integrity
+        ? computeIntegrityForFiles(persistedFiles, fedOptions.federationCache.cachePath)
+        : undefined;
     bundleCache.persist({
         checksum,
         externals: result,
-        files: bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName),
+        files: persistedFiles,
         chunks: exportedChunks,
+        integrity,
     });
     bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-    return { externals: result, chunks: exportedChunks };
+    return { externals: result, chunks: exportedChunks, integrity };
+}
+function computeIntegrityForFiles(files, baseDir) {
+    const integrity = {};
+    for (const file of files) {
+        if (file.endsWith('.map'))
+            continue;
+        const fullPath = path.join(baseDir, file);
+        if (!fs.existsSync(fullPath))
+            continue;
+        integrity[path.basename(file)] = integrityForFile(fullPath);
+    }
+    return integrity;
 }
 function rewriteImports(cachedFiles, cachePath) {
     const newSourceFiles = cachedFiles.filter(cf => isSourceFile(cf));

package/src/lib/core/federation-cache.d.ts

@@ -1,8 +1,9 @@
 import type { FederationCache } from '../domain/core/federation-cache.contract.js';
-import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
 export declare function createFederationCache(cachePath: string): FederationCache<undefined>;
 export declare function createFederationCache<TBundlerCache>(cachePath: string, bundlerCache: TBundlerCache): FederationCache<TBundlerCache>;
-export declare function addExternalsToCache(cache: FederationCache, { externals, chunks }: {
+export declare function addExternalsToCache(cache: FederationCache, { externals, chunks, integrity, }: {
     externals: SharedInfo[];
     chunks?: ChunkInfo;
+    integrity?: IntegrityMap;
 }): void;

package/src/lib/core/federation-cache.js

@@ -1,11 +1,16 @@
 export function createFederationCache(cachePath, bundlerCache) {
     return { externals: [], cachePath, bundlerCache };
 }
-export function addExternalsToCache(cache, { externals, chunks }) {
+export function addExternalsToCache(cache, { externals, chunks, integrity, }) {
     cache.externals.push(...externals);
     if (chunks) {
         if (!cache.chunks)
             cache.chunks = {};
         cache.chunks = { ...cache.chunks, ...chunks };
     }
+    if (integrity) {
+        if (!cache.integrity)
+            cache.integrity = {};
+        cache.integrity = { ...cache.integrity, ...integrity };
+    }
 }

package/src/lib/core/rebuild-for-federation.js

@@ -31,7 +31,13 @@ export async function rebuildForFederation(config, fedOptions, externals, modifi
     if (artifactInfo?.chunks) {
         federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
     }
+    if (fedOptions.integrity) {
+        federationInfo.integrity = {
+            ...(federationCache.integrity ?? {}),
+            ...(artifactInfo?.integrity ?? {}),
+        };
+    }
     writeFederationInfo(federationInfo, fedOptions);
-    writeImportMap(federationCache, fedOptions);
+    writeImportMap(federationCache, fedOptions, federationInfo.integrity);
     return federationInfo;
 }

package/src/lib/core/write-import-map.d.ts

@@ -1,6 +1,6 @@
-import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
 import type { FederationOptions } from '../domain/core/federation-options.contract.js';
 export declare function writeImportMap(sharedInfo: {
     externals: SharedInfo[];
     chunks?: ChunkInfo;
-}, fedOption: FederationOptions): void;
+}, fedOption: FederationOptions, fileIntegrity?: IntegrityMap): void;

package/src/lib/core/write-import-map.js

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import { toChunkImport } from '../domain/core/chunk.js';
-export function writeImportMap(sharedInfo, fedOption) {
+export function writeImportMap(sharedInfo, fedOption, fileIntegrity) {
     const imports = sharedInfo.externals.reduce((acc, cur) => {
         return {
             ...acc,
@@ -17,6 +17,17 @@ export function writeImportMap(sharedInfo, fedOption) {
         });
     }
     const importMap = { imports };
+    if (fileIntegrity) {
+        const integrity = {};
+        for (const url of Object.values(imports)) {
+            const sri = fileIntegrity[url];
+            if (sri)
+                integrity[url] = sri;
+        }
+        if (Object.keys(integrity).length > 0) {
+            importMap.integrity = integrity;
+        }
+    }
     const importMapPath = path.join(fedOption.workspaceRoot, fedOption.outputPath, 'importmap.json');
     fs.writeFileSync(importMapPath, JSON.stringify(importMap, null, 2));
 }

package/src/lib/domain/core/federation-cache.contract.d.ts

@@ -1,7 +1,8 @@
-import type { ChunkInfo, SharedInfo } from './federation-info.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from './federation-info.contract.js';
 export type FederationCache<TBundlerCache = unknown> = {
     externals: SharedInfo[];
     chunks?: ChunkInfo;
+    integrity?: IntegrityMap;
     bundlerCache: TBundlerCache;
     cachePath: string;
 };

package/src/lib/domain/core/federation-info.contract.d.ts

@@ -3,6 +3,7 @@ export interface FederationInfo {
     exposes: ExposesInfo[];
     shared: SharedInfo[];
     chunks?: Record<string, string[]>;
+    integrity?: IntegrityMap;
     buildNotificationsEndpoint?: string;
 }
 export type SharedInfo = {
@@ -19,6 +20,7 @@ export type SharedInfo = {
     };
 };
 export type ChunkInfo = Record<string, string[]>;
+export type IntegrityMap = Record<string, string>;
 export interface ExposesInfo {
     key: string;
     outFileName: string;
@@ -30,4 +32,5 @@ export interface ArtifactInfo {
     mappings: SharedInfo[];
     exposes: ExposesInfo[];
     chunks?: ChunkInfo;
+    integrity?: IntegrityMap;
 }

package/src/lib/domain/core/federation-options.contract.d.ts

@@ -13,6 +13,7 @@ export interface FederationOptions {
     packageJson?: string;
     entryPoints?: string[];
     buildNotifications?: BuildNotificationOptions;
+    integrity?: boolean;
 }
 export interface NormalizedFederationOptions<TBundlerCache = unknown> extends FederationOptions {
     federationCache: FederationCache<TBundlerCache>;

package/src/lib/domain/core/index.d.ts

@@ -1,4 +1,4 @@
-export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, } from './federation-info.contract.js';
+export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, IntegrityMap, } from './federation-info.contract.js';
 export { type BuildNotificationOptions, BuildNotificationType, } from './build-notification-options.contract.js';
 export type { FederationOptions, NormalizedFederationOptions, } from './federation-options.contract.js';
 export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, NFBuildAdapterContext, } from './build-adapter.contract.js';

package/src/lib/utils/build-result-map.d.ts

@@ -1,4 +1,4 @@
 import type { NFBuildAdapterResult } from '../domain/core/build-adapter.contract.js';
-export declare function createBuildResultMap(buildResult: NFBuildAdapterResult[], isHashed: boolean): Record<string, string>;
+export declare function createBuildResultMap(buildResult: NFBuildAdapterResult[], isHashed: boolean, expectedNames?: string[]): Record<string, string>;
 export declare function lookupInResultMap(map: Record<string, string>, requestName: string): string;
 export declare function popFromResultMap(map: Record<string, string>, requestName: string): string;

package/src/lib/utils/build-result-map.js

@@ -1,16 +1,17 @@
 import path from 'path';
-export function createBuildResultMap(buildResult, isHashed) {
+function stripHash(fileName) {
+    const start = fileName.lastIndexOf('-');
+    const end = fileName.lastIndexOf('.');
+    if (start < 0 || end < 0 || start > end)
+        return fileName;
+    return fileName.substring(0, start) + fileName.substring(end);
+}
+export function createBuildResultMap(buildResult, isHashed, expectedNames = []) {
+    const expected = new Set(expectedNames.map(n => path.basename(n)));
     const map = {};
     for (const item of buildResult) {
         const resultName = path.basename(item.fileName);
-        let requestName = resultName;
-        if (isHashed) {
-            const start = resultName.lastIndexOf('-');
-            const end = resultName.lastIndexOf('.');
-            const part1 = resultName.substring(0, start);
-            const part2 = resultName.substring(end);
-            requestName = part1 + part2;
-        }
+        const requestName = isHashed && expected.has(stripHash(resultName)) ? stripHash(resultName) : resultName;
         map[requestName] = item.fileName;
     }
     return map;

package/src/lib/utils/cache-persistence.d.ts

@@ -1,21 +1,19 @@
 import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
-import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
 export declare const getDefaultCachePath: (workspaceRoot: string) => string;
 export declare const getFilename: (title: string, dev?: boolean) => string;
 export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0") => string;
+type CacheMetadata = {
+    checksum: string;
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+    integrity?: IntegrityMap;
+    files: string[];
+};
 export declare const cacheEntry: (pathToCache: string, fileName: string) => {
-    getMetadata: (checksum: string) => {
-        checksum: string;
-        externals: SharedInfo[];
-        chunks?: ChunkInfo;
-        files: string[];
-    } | undefined;
-    persist: (payload: {
-        checksum: string;
-        externals: SharedInfo[];
-        chunks?: ChunkInfo;
-        files: string[];
-    }) => void;
+    getMetadata: (checksum: string) => CacheMetadata | undefined;
+    persist: (payload: CacheMetadata) => void;
     copyFiles: (fullOutputPath: string) => void;
     clear: () => void;
 };
+export {};

package/src/lib/utils/hash-file.d.ts

@@ -1 +1,3 @@
 export declare function hashFile(fileName: string): string;
+export type SriAlgorithm = 'sha256' | 'sha384' | 'sha512';
+export declare function integrityForFile(fileName: string, algorithm?: SriAlgorithm): string;

package/src/lib/utils/hash-file.js

@@ -6,3 +6,8 @@ export function hashFile(fileName) {
     hashSum.update(fileBuffer);
     return hashSum.digest('hex');
 }
+export function integrityForFile(fileName, algorithm = 'sha384') {
+    const fileBuffer = fs.readFileSync(fileName);
+    const hash = crypto.createHash(algorithm).update(fileBuffer).digest('base64');
+    return `${algorithm}-${hash}`;
+}