@module-federation/treeshake-server 0.0.1 → 2.0.1

package/dist/server.js

@@ -26,7 +26,7 @@ const external_node_fs_namespaceObject = require("node:fs");
 var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const SERVER_VERSION = 'v0-011501';
+const SERVER_VERSION = 'v0-0205';
 const UPLOADED_DIR = '_shared-tree-shaking';
 const external_pino_namespaceObject = require("pino");
 var external_pino_default = /*#__PURE__*/ __webpack_require__.n(external_pino_namespaceObject);
@@ -87,7 +87,8 @@ class LocalObjectStore {
         _define_property(this, "rootDir", void 0);
         _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}/`;
     }
 }
@@ -223,8 +224,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 {
@@ -258,14 +263,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");
@@ -300,8 +306,8 @@ const CheckTreeShakingSchema = ConfigSchema.extend({
     uploadOptions: UploadOptionsSchema.optional()
 });
 const external_node_crypto_namespaceObject = require("node:crypto");
-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 STATS_NAME = 'mf-stats.json';
 const external_node_child_process_namespaceObject = require("node:child_process");
 let runtimeEnv = {};
@@ -399,11 +405,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;
@@ -412,15 +418,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 || {}
     };
@@ -461,28 +474,29 @@ 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/'
+                npm_config_registry: process.env.MF_NPM_REGISTRY || 'https://registry.npmjs.org/'
             }
         });
     } finally{
@@ -497,12 +511,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) {
@@ -520,22 +535,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
     });
@@ -635,7 +659,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}`);
@@ -653,25 +677,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,
@@ -733,16 +758,20 @@ async function uploadProject(uploadResults, sharedFilePaths, normalizedConfig, p
                 version: s.version,
                 globalName: s.globalName,
                 cdnUrl,
-                type: s.type
+                type: s.type,
+                modules: s.modules,
+                canTreeShaking: s.canTreeShaking
             });
         } catch (error) {
             logger_logger.error(`Failed to upload ${s.name}@${s.version}: ${error}`);
         }
         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}`);
         });
     }
 }
@@ -751,14 +780,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,
@@ -771,7 +800,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
                 });
@@ -783,9 +812,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');
@@ -798,16 +828,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',
@@ -845,16 +886,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',
@@ -899,6 +951,7 @@ maintenanceRoute.post('/', async (c)=>{
 const routes = new external_hono_namespaceObject.Hono();
 routes.route('/build', buildRoute);
 routes.route('/clean-cache', maintenanceRoute);
+const timeout_namespaceObject = require("hono/timeout");
 function createApp(deps, opts) {
     var _opts_appExtensions, _opts_frontendAdapters;
     if (null == opts ? void 0 : opts.logger) setLogger(opts.logger);
@@ -920,6 +973,7 @@ function createApp(deps, opts) {
     }));
     app.use('*', loggerMiddleware);
     app.use('*', createDiMiddleware(deps));
+    app.use('*', (0, timeout_namespaceObject.timeout)(60000));
     if (null == opts ? void 0 : null == (_opts_appExtensions = opts.appExtensions) ? void 0 : _opts_appExtensions.length) for (const extend of opts.appExtensions)extend(app);
     app.get('/tree-shaking-shared/healthz', (c)=>c.json({
             status: 'ok',
@@ -1013,7 +1067,8 @@ function createServer(opts) {
     return (0, node_server_namespaceObject.serve)({
         fetch: opts.app.fetch,
         port,
-        hostname
+        hostname,
+        overrideGlobalObjects: false
     });
 }
 const hasIndexHtml = (dir)=>Boolean(dir && external_node_fs_default().existsSync(external_node_path_default().join(dir, 'index.html')));
@@ -1074,11 +1129,8 @@ async function main() {
         port: resolved.port,
         hostname: resolved.hostname
     });
-    console.log(`Build service listening on http://${resolved.hostname}:${resolved.port}`);
-    if (frontendAdapters.length) {
-        const basePath = process.env.TREESHAKE_FRONTEND_BASE_PATH ?? '/tree-shaking';
-        console.log(`Treeshake UI available at http://${resolved.hostname}:${resolved.port}${basePath}`);
-    }
+    console.log('Build service listening.');
+    if (frontendAdapters.length) console.log('Treeshake UI available.');
 }
 main().catch((err)=>{
     console.error(err);