@softarc/native-federation 4.0.1 → 4.1.1

package/package.json

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

package/src/lib/config/with-native-federation.js

@@ -15,7 +15,7 @@ export function withNativeFederation(config) {
         skip,
         externals: config.externals ?? [],
         features: {
-            mappingVersion: config.features?.mappingVersion ?? false,
+            mappingVersion: config.features?.mappingVersion ?? true,
             ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
             denseChunking: config.features?.denseChunking ?? false,
         },

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.d.ts

@@ -4,3 +4,4 @@ import { type NormalizedFederationOptions } from '../domain/core/federation-opti
 export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
 export declare function describeExposed(config: NormalizedFederationConfig, options: NormalizedFederationOptions): Array<ExposesInfo>;
 export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions): Array<SharedInfo>;
+export declare function getMappingVersion(fileName: string, workspaceRoot: string): string;

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';
@@ -64,19 +65,7 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
     // Pick shared-mappings
     for (const item of shared) {
         const distEntryFile = popFromResultMap(resultMap, item.outName);
-        sharedResult.push({
-            packageName: item.key,
-            outFileName: path.basename(distEntryFile),
-            requiredVersion: '',
-            singleton: true,
-            strictVersion: false,
-            version: config.features.mappingVersion ? getMappingVersion(item.fileName) : '',
-            dev: !fedOptions.dev
-                ? undefined
-                : {
-                    entryPoint: normalize(path.normalize(item.fileName)),
-                },
-        });
+        sharedResult.push(toSharedMappingInfo(item.fileName, item.key, path.basename(distEntryFile), config, fedOptions));
         entryFiles.push(distEntryFile);
     }
     const exposedResult = [];
@@ -100,14 +89,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 = [];
@@ -128,30 +129,46 @@ export function describeExposed(config, options) {
 export function describeSharedMappings(config, fedOptions) {
     const result = [];
     for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
-        result.push({
-            packageName: mappedImport,
-            outFileName: '',
-            requiredVersion: '',
-            singleton: true,
-            strictVersion: false,
-            version: config.features.mappingVersion ? getMappingVersion(mappedPath) : '',
-            dev: !fedOptions.dev
-                ? undefined
-                : {
-                    entryPoint: normalize(path.normalize(mappedPath)),
-                },
-        });
+        result.push(toSharedMappingInfo(mappedPath, mappedImport, '', config, fedOptions));
     }
     return result;
 }
-function getMappingVersion(fileName) {
-    const entryFileDir = path.dirname(fileName);
-    const cand1 = path.join(entryFileDir, 'package.json');
-    const cand2 = path.join(path.dirname(entryFileDir), 'package.json');
-    const packageJsonPath = [cand1, cand2].find(cand => fs.existsSync(cand));
-    if (packageJsonPath) {
-        const json = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        return json.version ?? '';
+function toSharedMappingInfo(mappedPath, mappedImport, outFileName, config, fedOptions) {
+    const mappingVersion = config.features.mappingVersion
+        ? getMappingVersion(mappedPath, fedOptions.workspaceRoot)
+        : '';
+    return {
+        packageName: mappedImport,
+        outFileName,
+        requiredVersion: mappingVersion.length > 0 ? '~' + mappingVersion : '',
+        singleton: true,
+        strictVersion: config.features.mappingVersion,
+        version: mappingVersion,
+        dev: !fedOptions.dev
+            ? undefined
+            : {
+                entryPoint: normalize(path.normalize(mappedPath)),
+            },
+    };
+}
+export function getMappingVersion(fileName, workspaceRoot) {
+    const resolvedRoot = path.resolve(workspaceRoot);
+    let dir = path.dirname(path.resolve(fileName));
+    while (true) {
+        const candidate = path.join(dir, 'package.json');
+        try {
+            const json = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+            if (typeof json.version === 'string' && json.version)
+                return json.version;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                logger.warn(`[getMappingVersion] Failed to parse ${candidate}: ${err.message}`);
+            }
+        }
+        const parent = path.dirname(dir);
+        if (dir === resolvedRoot || parent === dir)
+            return '';
+        dir = parent;
     }
-    return '';
 }

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/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}`;
+}