@meteorjs/rspack 3.0.0-rc.1 → 3.0.0

package/lib/clean.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const fs = require('fs');
+
+function isOutside(relative) {
+  return relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
+
+// output.path can be an app's public/ or private/ source directory. Only the
+// configured generated contexts belong to this compiler's cleanup.
+function keepOutsideContexts(outputPath, contexts) {
+  const outputRoot = path.resolve(outputPath);
+  const owned = contexts
+    .filter(context => typeof context === 'string' && context.length > 0)
+    .map(context => path.relative(outputRoot, path.resolve(outputRoot, context)))
+    .filter(context => context && !isOutside(context));
+
+  return filename => {
+    if (typeof filename !== 'string' || filename.includes('\0')) return true;
+    const relative = path.relative(outputRoot, path.resolve(outputRoot, filename));
+    if (isOutside(relative)) return true;
+
+    const canClean = owned.some(context =>
+      relative === context || relative.startsWith(`${context}${path.sep}`) ||
+      // Rspack calls keep on directories before walking their children. Let
+      // it traverse the output root and parents of nested owned contexts.
+      relative === '' || context.startsWith(`${relative}${path.sep}`)
+    );
+    if (!canClean) return true;
+
+    // Rspack follows directory symlinks while cleaning. Check every component,
+    // including the output root, even when it calls keep directly on a file.
+    let current = outputRoot;
+    const segments = relative ? relative.split(path.sep) : [];
+    try {
+      for (const segment of ['', ...segments]) {
+        current = path.join(current, segment);
+        if (fs.lstatSync(current).isSymbolicLink()) return true;
+      }
+    } catch {
+      // If ownership cannot be checked, preserve the path.
+      return true;
+    }
+    return false;
+  };
+}
+
+module.exports = { keepOutsideContexts };

package/lib/clean.test.js

@@ -0,0 +1,125 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { keepOutsideContexts } = require('./clean');
+
+describe('Rspack output cleanup ownership', () => {
+  let root;
+  let outputPath;
+
+  function writeFile(filename, content = 'generated') {
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    fs.writeFileSync(filename, content);
+  }
+
+  function linkDirectory(target, link) {
+    fs.mkdirSync(path.dirname(link), { recursive: true });
+    fs.symlinkSync(target, link, process.platform === 'win32' ? 'junction' : 'dir');
+  }
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'meteor-clean-'));
+    outputPath = path.join(root, 'build', 'build-agent', 'app', 'private');
+    fs.mkdirSync(outputPath, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  test.each([
+    ['build-assets', 'build-chunks'],
+    ['build-assets-test', 'build-chunks-test'],
+    ['build-assets-local-secondary-app-test', 'build-chunks-local-secondary-app-test'],
+    ['generated/assets', 'generated/chunks'],
+  ])('cleans only %s and %s, with absolute or relative callbacks', (assets, chunks) => {
+    writeFile(path.join(outputPath, assets, 'stale.svg'));
+    writeFile(path.join(outputPath, chunks, 'stale.js'));
+    const keep = keepOutsideContexts(outputPath, [assets, chunks]);
+    const cases = [
+      ['', false],
+      [assets, false],
+      [`${assets}/stale.svg`, false],
+      [`${chunks}/stale.js`, false],
+      ['ordinary.txt', true],
+      ['build', true],
+      ['build-notes/guide.txt', true],
+      ['docs/build/guide.txt', true],
+      [`${assets}-another-mode/keep.svg`, true],
+      ['build-assets-local-unrelated/keep.svg', true],
+      ['unrelated/build-chunks/stale.js', true],
+      ['../private-neighbor/build-assets/keep.txt', true],
+    ];
+    for (const [file, expected] of cases) {
+      for (const input of [file, path.resolve(outputPath, file)]) {
+        expect({ input, keep: keep(input) }).toEqual({ input, keep: expected });
+      }
+    }
+  });
+
+  test('traverses a shared parent without cleaning a sibling context', () => {
+    writeFile(path.join(outputPath, 'build-chunks/web.browser/stale.js'));
+    const keep = keepOutsideContexts(outputPath, [
+      'build-chunks/web.browser/assets', 'build-chunks/web.browser',
+    ]);
+    expect(keep(outputPath)).toBe(false);
+    expect(keep(path.join(outputPath, 'build-chunks'))).toBe(false);
+    expect(keep('build-chunks/web.browser/stale.js')).toBe(false);
+    expect(keep('build-chunks/web.browser.legacy/keep.js')).toBe(true);
+    expect(keep('build-chunks/web.cordova/keep.js')).toBe(true);
+  });
+
+  test('keeps files when no safe child context is configured', () => {
+    const keep = keepOutsideContexts(outputPath, ['', '.', '..', '../public', null]);
+    for (const input of [outputPath, 'ordinary.txt', '../public/keep.txt', null, 'bad\0path']) {
+      expect({ input, keep: keep(input) }).toEqual({ input, keep: true });
+    }
+  });
+
+  test.each([
+    ['context root', 'build-assets', 'build-assets', false, 'keep.txt'],
+    ['nested link', 'build-assets/linked', 'build-assets', true, 'keep.txt'],
+    ['custom context parent', 'generated', 'generated/assets', false, 'assets/keep.txt'],
+  ])('keeps a symlink at the %s and paths below it', (_name, linkPath, context, targetInsideOutput, child) => {
+    const target = path.join(targetInsideOutput ? outputPath : root, 'source-assets');
+    writeFile(path.join(target, child), 'source asset');
+    linkDirectory(target, path.join(outputPath, linkPath));
+    writeFile(path.join(outputPath, 'build-chunks/stale.js'));
+    const keep = keepOutsideContexts(outputPath, [context, 'build-chunks']);
+
+    for (const file of [linkPath, `${linkPath}/${child}`]) {
+      expect(keep(file)).toBe(true);
+      expect(keep(path.join(outputPath, file))).toBe(true);
+    }
+    expect(keep('build-chunks/stale.js')).toBe(false);
+  });
+
+  test('keeps a symlinked output root and its generated descendants', () => {
+    const target = path.join(root, 'shared-public');
+    writeFile(path.join(target, 'build-assets/keep.txt'), 'shared asset');
+    fs.rmdirSync(outputPath);
+    linkDirectory(target, outputPath);
+    const keep = keepOutsideContexts(outputPath, ['build-assets']);
+
+    expect(keep(outputPath)).toBe(true);
+    expect(keep('build-assets/keep.txt')).toBe(true);
+  });
+
+  test('preserves an uninspectable path without disabling cleanup elsewhere', () => {
+    const denied = path.join(outputPath, 'build-assets');
+    writeFile(path.join(denied, 'keep.txt'));
+    writeFile(path.join(outputPath, 'build-chunks/stale.js'));
+    const lstat = fs.lstatSync;
+    const spy = jest.spyOn(fs, 'lstatSync').mockImplementation((filename, ...args) => {
+      if (filename === denied) throw Object.assign(new Error('permission denied'), { code: 'EACCES' });
+      return lstat(filename, ...args);
+    });
+    try {
+      const keep = keepOutsideContexts(outputPath, ['build-assets', 'build-chunks']);
+      expect(keep('build-assets/keep.txt')).toBe(true);
+      expect(keep('build-chunks/stale.js')).toBe(false);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "3.0.0-rc.1",
+  "version": "3.0.0",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",

package/rspack.config.js

@@ -31,6 +31,7 @@ const { prepareMeteorRspackConfig } = require("./lib/meteorRspackConfigFactory")
 const { extractLocalDependencies } = require('./lib/localDependenciesHelpers.js');
 const { createTestClientNodePolyfillConfig } = require("./lib/testClientNodePolyfills.js");
 const { createOutputTracker } = require('./lib/compilationOutput.js');
+const { keepOutsideContexts } = require('./lib/clean.js');
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -207,16 +208,6 @@ function createRemoteDevServerConfig() {
   return {};
 }
 
-// Keep files outside of build folders
-function keepOutsideBuild() {
-  return (p) => {
-    const normalized = '/' + path.normalize(p).replaceAll(path.sep, '/').replace(/^\/+/, '');
-    const isInBuildRoot = /\/build(\/|$)/.test(normalized);
-    const isInBuildStar = /\/build-[^/]+(\/|$)/.test(normalized);
-    return !(isInBuildRoot || isInBuildStar);
-  };
-}
-
 /**
  * @param {{ isClient: boolean; isServer: boolean; isDevelopment?: boolean; isProduction?: boolean; isTest?: boolean }} Meteor
  * @param {{ mode?: string; clientEntry?: string; serverEntry?: string; clientOutputFolder?: string; serverOutputFolder?: string; chunksContext?: string; assetsContext?: string; serverAssetsContext?: string }} argv
@@ -644,7 +635,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       cssChunkFilename: `${clientChunkPrefix}[id]${
         isProd ? ".[contenthash]" : ""
       }.css`,
-      ...(isProd && { clean: clientOutputContext ? true : { keep: keepOutsideBuild() } }),
+      ...(isProd && { clean: clientOutputContext ? true : {
+        keep: keepOutsideContexts(clientOutputDir, [assetsContext, chunksContext]),
+      } }),
     },
     optimization: {
       usedExports: true,
@@ -767,7 +760,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       library: { type: "commonjs2" },
       chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
       assetModuleFilename,
-      ...(isProd && { clean: { keep: keepOutsideBuild() } }),
+      ...(isProd && { clean: {
+        keep: keepOutsideContexts(serverOutputDir, [assetsContext, chunksContext]),
+      } }),
     },
     optimization: {
       usedExports: true,