@module-federation/treeshake-server 0.0.1 → 0.23.0

package/dist/index.js

@@ -77,8 +77,12 @@ const loggerMiddleware = async (c, next)=>{
     c.set('logger', child);
     await next();
 };
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
 const zod_validator_namespaceObject = require("@hono/zod-validator");
 const external_nanoid_namespaceObject = require("nanoid");
+const external_p_limit_namespaceObject = require("p-limit");
+var external_p_limit_default = /*#__PURE__*/ __webpack_require__.n(external_p_limit_namespaceObject);
 const parseNormalizedKey = (key)=>{
     const res = key.split('@');
     return {
@@ -112,14 +116,15 @@ function normalizeConfig(config) {
     return normalizedConfig;
 }
 function extractBuildConfig(config, type) {
-    const { shared, plugins, target, libraryType, usedExports } = config;
+    const { shared, plugins, target, libraryType, usedExports, hostName } = config;
     return {
         shared,
         plugins,
         target,
         libraryType,
         usedExports,
-        type
+        type,
+        hostName
     };
 }
 const external_zod_namespaceObject = require("zod");
@@ -154,10 +159,8 @@ const CheckTreeShakingSchema = ConfigSchema.extend({
     uploadOptions: UploadOptionsSchema.optional()
 });
 const external_node_crypto_namespaceObject = require("node:crypto");
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-const external_node_os_namespaceObject = require("node:os");
-var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const STATS_NAME = 'mf-stats.json';
@@ -257,11 +260,11 @@ const startPeriodicPrune = (intervalMs = DEFAULT_INTERVAL)=>{
         maybePrune();
     }, intervalMs);
 };
-const createUniqueTempDirByKey = (key)=>{
+const createUniqueTempDirByKey = async (key)=>{
     const base = external_node_path_default().join(external_node_os_default().tmpdir(), `re-shake-share-${key}`);
     let candidate = base;
     for(;;)try {
-        external_node_fs_default().mkdirSync(candidate, {
+        await promises_default().mkdir(candidate, {
             recursive: false
         });
         return candidate;
@@ -270,15 +273,22 @@ const createUniqueTempDirByKey = (key)=>{
         candidate = `${base}-${rand}`;
     }
 };
-const prepareProject = (config, excludeShared)=>{
+const prepareProject = async (config, excludeShared)=>{
     const key = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify(config)).digest('hex');
-    const dir = createUniqueTempDirByKey(key);
-    const templateDir = external_node_path_default().join(__dirname, '..', 'template', 're-shake-share');
-    external_node_fs_default().cpSync(templateDir, dir, {
+    const dir = await createUniqueTempDirByKey(key);
+    const templateDir = external_node_path_default().join(__dirname, '.', 'template', 're-shake-share');
+    await promises_default().cp(templateDir, dir, {
         recursive: true
     });
     const pkgPath = external_node_path_default().join(dir, 'package.json');
-    const pkg = JSON.parse(external_node_fs_default().readFileSync(pkgPath, 'utf-8'));
+    const indexPath = external_node_path_default().join(dir, 'index.ts');
+    const rspackConfigPath = external_node_path_default().join(dir, 'rspack.config.ts');
+    const [pkgContent, indexContent, rspackConfigContent] = await Promise.all([
+        promises_default().readFile(pkgPath, 'utf-8'),
+        promises_default().readFile(indexPath, 'utf-8'),
+        promises_default().readFile(rspackConfigPath, 'utf-8')
+    ]);
+    const pkg = JSON.parse(pkgContent);
     const deps = {
         ...pkg.dependencies || {}
     };
@@ -319,25 +329,26 @@ const prepareProject = (config, excludeShared)=>{
     });
     pluginOptionStr += '\n]';
     pkg.dependencies = deps;
-    external_node_fs_default().writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    const newPkgContent = JSON.stringify(pkg, null, 2);
     const sharedImportPlaceholder = "${SHARED_IMPORT}";
+    const newIndexContent = indexContent.replace(sharedImportPlaceholder, sharedImport);
     const pluginsPlaceholder = "${ PLUGINS }";
     const mfConfigPlaceholder = "${ MF_CONFIG }";
-    const indexPath = external_node_path_default().join(dir, 'index.ts');
-    const indexContent = external_node_fs_default().readFileSync(indexPath, 'utf-8');
-    external_node_fs_default().writeFileSync(indexPath, indexContent.replace(sharedImportPlaceholder, sharedImport));
-    const rspackConfigPath = external_node_path_default().join(dir, 'rspack.config.ts');
-    let cfg = external_node_fs_default().readFileSync(rspackConfigPath, 'utf-8');
+    let cfg = rspackConfigContent;
     cfg += pluginImportStr;
     cfg = cfg.replace(pluginsPlaceholder, pluginOptionStr);
     cfg = cfg.replace(mfConfigPlaceholder, JSON.stringify(mfConfig, null, 2));
-    external_node_fs_default().writeFileSync(rspackConfigPath, cfg);
+    await Promise.all([
+        promises_default().writeFile(pkgPath, newPkgContent),
+        promises_default().writeFile(indexPath, newIndexContent),
+        promises_default().writeFile(rspackConfigPath, cfg)
+    ]);
     return dir;
 };
 const installDependencies = async (cwd)=>{
     markInstallStart();
     try {
-        await runCommand('pnpm i', {
+        await runCommand("pnpm i --ignore-scripts --prefer-offline --reporter=silent ", {
             cwd,
             env: {
                 npm_config_registry: 'https://registry.npmjs.org/'
@@ -355,12 +366,13 @@ const buildProject = async (cwd, type)=>{
             cwd
         })));
 };
-const retrieveSharedFilepaths = (projectDir, type)=>{
+const retrieveSharedFilepaths = async (projectDir, type)=>{
     const sharedFilepaths = [];
-    const collectSharedFilepaths = (t)=>{
+    const collectSharedFilepaths = async (t)=>{
         const dir = 'full' === t ? 'full-shared' : 'dist';
         const distDir = external_node_path_default().join(projectDir, dir);
-        const stats = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(distDir, STATS_NAME), 'utf-8'));
+        const statsContent = await promises_default().readFile(external_node_path_default().join(distDir, STATS_NAME), 'utf-8');
+        const stats = JSON.parse(statsContent);
         stats.shared.forEach((s)=>{
             const { name, version, fallback, fallbackName } = s;
             if (fallback && fallbackName) {
@@ -378,22 +390,31 @@ const retrieveSharedFilepaths = (projectDir, type)=>{
             }
         });
     };
-    collectSharedFilepaths(type);
+    await collectSharedFilepaths(type);
     return sharedFilepaths;
 };
 const runBuild = async (normalizedConfig, excludeShared, type)=>{
-    const tmpDir = prepareProject(normalizedConfig, excludeShared);
+    const tStart = Date.now();
+    const tmpDir = await prepareProject(normalizedConfig, excludeShared);
+    const tPrepare = Date.now();
+    logger_logger.info(`prepareProject took ${tPrepare - tStart}ms`);
     await installDependencies(tmpDir);
+    const tInstall = Date.now();
+    logger_logger.info(`installDependencies took ${tInstall - tPrepare}ms`);
     await buildProject(tmpDir, type);
-    const sharedFilePaths = retrieveSharedFilepaths(tmpDir, type);
+    const tBuild = Date.now();
+    logger_logger.info(`buildProject took ${tBuild - tInstall}ms`);
+    const sharedFilePaths = await retrieveSharedFilepaths(tmpDir, type);
+    const tRetrieve = Date.now();
+    logger_logger.info(`retrieveSharedFilepaths took ${tRetrieve - tBuild}ms`);
     return {
         sharedFilePaths,
         dir: tmpDir
     };
 };
-function cleanUp(tmpDir) {
+async function cleanUp(tmpDir) {
     if (!tmpDir) return;
-    external_node_fs_default().rmSync(tmpDir, {
+    await promises_default().rm(tmpDir, {
         recursive: true,
         force: true
     });
@@ -495,7 +516,7 @@ async function uploadToCacheStore(sharedFilePaths, normalizedConfig, store) {
                 const jsonFilePath = filepath.replace(/\.js$/, '.json');
                 const jsonFile = JSON.stringify(res);
                 const jsonCdnUrl = cdnPath.replace(/\.js$/, '.json');
-                external_node_fs_default().writeFileSync(jsonFilePath, jsonFile);
+                await promises_default().writeFile(jsonFilePath, jsonFile);
                 await store.uploadFile(jsonFilePath, jsonCdnUrl);
             } catch (error) {
                 logger_logger.error(`Failed to upload ${name}@${version} json file: ${error}`);
@@ -513,25 +534,26 @@ const downloadToFile = async (url, destPath)=>{
     const res = await fetch(url);
     if (!res.ok) throw new Error(`Download failed: ${res.status} ${res.statusText} - ${url}`);
     const buf = Buffer.from(await res.arrayBuffer());
-    await external_node_fs_default().promises.mkdir(external_node_path_default().dirname(destPath), {
+    await promises_default().mkdir(external_node_path_default().dirname(destPath), {
         recursive: true
     });
-    await external_node_fs_default().promises.writeFile(destPath, buf);
+    await promises_default().writeFile(destPath, buf);
     return destPath;
 };
-async function uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher) {
-    const tmpDir = createUniqueTempDirByKey(`upload-project${Date.now().toString()}`);
+async function uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher, store) {
+    const tmpDir = await createUniqueTempDirByKey(`upload-project${Date.now().toString()}`);
     const uploaded = [];
     try {
         for (const item of uploadResults)try {
-            const config = normalizedConfig[normalizedKey(item.name, item.version)];
+            const sharedKey = normalizedKey(item.name, item.version);
+            const config = normalizedConfig[sharedKey];
             if (!config) {
                 logger_logger.error(`No config found for ${item.name}`);
                 continue;
             }
             const { uploadOptions } = config;
             if (!uploadOptions) throw new Error(`No uploadOptions found for ${item.name}`);
-            const filename = external_node_path_default().basename(new URL(item.cdnUrl).pathname);
+            const filename = external_node_path_default().basename(new URL(item.cdnUrl, 'http://dummy.com').pathname);
             const localPath = external_node_path_default().join(tmpDir, filename);
             const hash = createCacheHash({
                 ...config,
@@ -600,9 +622,11 @@ async function uploadProject(uploadResults, sharedFilePaths, normalizedConfig, p
         }
         return uploaded;
     } finally{
-        external_node_fs_default().rmSync(tmpDir, {
+        promises_default().rm(tmpDir, {
             recursive: true,
             force: true
+        }).catch((err)=>{
+            logger_logger.error(`Failed to cleanup dir ${tmpDir}: ${err}`);
         });
     }
 }
@@ -611,14 +635,14 @@ async function upload(sharedFilePaths, uploadResults, normalizedConfig, uploadOp
     if (!uploadOptions) {
         const hydrated = await Promise.all(uploadResults.map(async (item)=>{
             if ('full' !== item.type) return item;
-            const tmpDir = createUniqueTempDirByKey(`download-full-json${Date.now().toString()}`);
+            const tmpDir = await createUniqueTempDirByKey(`download-full-json${Date.now().toString()}`);
             const jsonPath = external_node_path_default().join(tmpDir, `${item.name}-${item.version}.json`);
             try {
                 const tJson0 = Date.now();
                 await downloadToFile(item.cdnUrl.replace('.js', '.json'), jsonPath);
                 const tJson = Date.now() - tJson0;
                 logger_logger.info(`Downloaded ${item.name}@${item.version} json in ${tJson}ms`);
-                const jsonContent = JSON.parse(external_node_fs_default().readFileSync(jsonPath, 'utf8'));
+                const jsonContent = JSON.parse(await promises_default().readFile(jsonPath, 'utf8'));
                 return {
                     ...item,
                     canTreeShaking: jsonContent.canTreeShaking,
@@ -631,7 +655,7 @@ async function upload(sharedFilePaths, uploadResults, normalizedConfig, uploadOp
                     canTreeShaking: item.canTreeShaking ?? true
                 };
             } finally{
-                external_node_fs_default().rmSync(tmpDir, {
+                await promises_default().rm(tmpDir, {
                     recursive: true,
                     force: true
                 });
@@ -643,9 +667,10 @@ async function upload(sharedFilePaths, uploadResults, normalizedConfig, uploadOp
         ];
     }
     if (!publisher) throw new Error('uploadOptions provided but no projectPublisher configured (configure the selected adapter to enable it or omit uploadOptions)');
-    const projectUploadResults = await uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher);
+    const projectUploadResults = await uploadProject(uploadResults, sharedFilePaths, normalizedConfig, publisher, store);
     return projectUploadResults;
 }
+const buildLimit = external_p_limit_default()(Math.max(1, external_node_os_default().cpus().length));
 const buildRoute = new external_hono_namespaceObject.Hono();
 buildRoute.post('/', (0, zod_validator_namespaceObject.zValidator)('json', ConfigSchema), async (c)=>{
     const logger = c.get('logger');
@@ -658,16 +683,27 @@ buildRoute.post('/', (0, zod_validator_namespaceObject.zValidator)('json', Confi
     const store = c.get('objectStore');
     const publisher = c.get('projectPublisher');
     try {
+        const t0 = Date.now();
         const { cacheItems, excludeShared, restConfig } = await retrieveCacheItems(normalizedConfig, 're-shake', store);
+        const tRetrieveCache = Date.now();
+        logger.info(`retrieveCacheItems took ${tRetrieveCache - t0}ms`);
         let sharedFilePaths = [];
         let dir;
         if (Object.keys(restConfig).length > 0) {
-            const buildResult = await runBuild(normalizedConfig, excludeShared, 're-shake');
+            const buildResult = await buildLimit(()=>runBuild(normalizedConfig, excludeShared, 're-shake'));
             sharedFilePaths = buildResult.sharedFilePaths;
             dir = buildResult.dir;
         }
+        const tBuild = Date.now();
+        logger.info(`runBuild took ${tBuild - tRetrieveCache}ms`);
         const uploadResults = await upload(sharedFilePaths, cacheItems, normalizedConfig, body.uploadOptions, store, publisher);
-        cleanUp(dir);
+        const tUpload = Date.now();
+        logger.info(`upload took ${tUpload - tBuild}ms`);
+        cleanUp(dir).catch((err)=>{
+            logger.error(`Failed to cleanup dir ${dir}: ${err}`);
+        });
+        const tCleanUp = Date.now();
+        logger.info(`cleanUp scheduled (non-blocking) took ${tCleanUp - tUpload}ms`);
         return c.json({
             jobId,
             status: 'success',
@@ -705,16 +741,27 @@ async function handleCheckTreeshake(c, body) {
     const store = c.get('objectStore');
     const publisher = c.get('projectPublisher');
     try {
+        const t0 = Date.now();
         const { cacheItems, excludeShared, restConfig } = await retrieveCacheItems(normalizedConfig, 'full', store);
+        const tRetrieveCache = Date.now();
+        logger.info(`retrieveCacheItems took ${tRetrieveCache - t0}ms`);
         let sharedFilePaths = [];
         let dir;
         if (Object.keys(restConfig).length > 0) {
-            const buildResult = await runBuild(normalizedConfig, excludeShared, 'full');
+            const buildResult = await buildLimit(()=>runBuild(normalizedConfig, excludeShared, 'full'));
             sharedFilePaths = buildResult.sharedFilePaths;
             dir = buildResult.dir;
         }
+        const tBuild = Date.now();
+        logger.info(`runBuild took ${tBuild - tRetrieveCache}ms`);
         const uploadResults = await upload(sharedFilePaths, cacheItems, normalizedConfig, body.uploadOptions, store, publisher);
-        cleanUp(dir);
+        const tUpload = Date.now();
+        logger.info(`upload took ${tUpload - tBuild}ms`);
+        cleanUp(dir).catch((err)=>{
+            logger.error(`Failed to cleanup dir ${dir}: ${err}`);
+        });
+        const tCleanUp = Date.now();
+        logger.info(`cleanUp scheduled (non-blocking) took ${tCleanUp - tUpload}ms`);
         return c.json({
             jobId,
             status: 'success',
@@ -759,6 +806,8 @@ maintenanceRoute.post('/', async (c)=>{
 const routes = new external_hono_namespaceObject.Hono();
 routes.route('/build', buildRoute);
 routes.route('/clean-cache', maintenanceRoute);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 function contentTypeByExt(filePath) {
     if (filePath.endsWith('.js')) return "application/javascript";
     if (filePath.endsWith('.json')) return 'application/json';
@@ -881,7 +930,8 @@ class LocalObjectStore {
         localObjectStore_define_property(this, "rootDir", void 0);
         localObjectStore_define_property(this, "publicBaseUrl", void 0);
         this.rootDir = (null == opts ? void 0 : opts.rootDir) ?? external_node_path_default().join(process.cwd(), 'log', 'static');
-        const base = (null == opts ? void 0 : opts.publicBaseUrl) ?? '/';
+        const port = process.env.PORT || 3000;
+        const base = (null == opts ? void 0 : opts.publicBaseUrl) === '/' ? `http://localhost:${port}/` : (null == opts ? void 0 : opts.publicBaseUrl) ?? '/';
         this.publicBaseUrl = base.endsWith('/') ? base : `${base}/`;
     }
 }