feat(@parcel/transformer-js): Rewrite __dirname/__filename to be relative to asset.filePath

packages/core/integration-tests/test/fs.js

@@ -201,7 +201,10 @@ describe('fs', function () {
       assert(contents.includes("require('fs')"));
       assert(contents.includes('readFileSync'));
 
-      await outputFS.writeFile(path.join(distDir, 'test.txt'), 'hey');
+      await outputFS.writeFile(
+        path.join(__dirname, '/integration/fs-node/', 'test.txt'),
+        'hey',
+      );
       let output = await run(b);
       assert.equal(output, 'hey');
     });

packages/core/integration-tests/test/integration/env-node-replacements/index.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const path = require('path');
+const otherFunction = require('./other/function')
+const subFunction = require('./sub/index')
+
+module.exports = function () {
+  const data = fs.readFileSync(path.join(__dirname, 'data', 'test.txt'), 'utf8')
+  const firstDirnameTest = path.join(__dirname, 'data')
+  const secondDirnameTest = path.join(__dirname, 'other-data')
+  const firstFilenameTest = __filename
+  const secondFilenameTest = `${__filename}?query-string=test`
+  const other = otherFunction()
+  const sub = subFunction()
+
+  return {
+    data,
+    firstDirnameTest,
+    secondDirnameTest,
+    firstFilenameTest,
+    secondFilenameTest,
+    other,
+    sub,
+  }
+}

packages/core/integration-tests/test/integration/env-node-replacements/other/function.js

@@ -0,0 +1,6 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = function () {
+  return fs.readFileSync(path.join(__dirname, '..', 'data', 'test.txt'), 'utf8')
+}

packages/core/integration-tests/test/integration/env-node-replacements/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "env-node-replacements",
+  "engines": {
+    "node": ">=14"
+  }
+}

packages/core/integration-tests/test/integration/env-node-replacements/sub/index.js

@@ -0,0 +1,6 @@
+module.exports = function () {
+  return {
+    dirname: __dirname,
+    filename: __filename
+  }
+}

packages/core/integration-tests/test/javascript.js

@@ -2678,6 +2678,141 @@ describe('javascript', function () {
     });
   });
 
+  it('should replace __dirname and __filename with path relative to asset.filePath', async function () {
+    let b = await bundle(
+      path.join(__dirname, '/integration/env-node-replacements/index.js'),
+    );
+
+    let dist = await outputFS.readFile(b.getBundles()[0].filePath, 'utf8');
+    assert(
+      dist.includes(
+        'require("path").resolve(__dirname, "../test/integration/env-node-replacements")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'require("path").resolve(__dirname, "../test/integration/env-node-replacements/other")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'require("path").resolve(__dirname, "../test/integration/env-node-replacements", "index.js")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'require("path").resolve(__dirname, "../test/integration/env-node-replacements/sub")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'require("path").resolve(__dirname, "../test/integration/env-node-replacements/sub", "index.js")',
+      ),
+    );
+    let f = await run(b);
+    let output = f();
+    assert.equal(output.data, 'hello');
+    assert.equal(output.other, 'hello');
+    assert.equal(
+      output.firstDirnameTest,
+      path.join(__dirname, '/integration/env-node-replacements/data'),
+    );
+    assert.equal(
+      output.secondDirnameTest,
+      path.join(__dirname, '/integration/env-node-replacements/other-data'),
+    );
+    assert.equal(
+      output.firstFilenameTest,
+      path.join(__dirname, '/integration/env-node-replacements/index.js'),
+    );
+    assert.equal(
+      output.secondFilenameTest,
+      path.join(
+        __dirname,
+        '/integration/env-node-replacements/index.js?query-string=test',
+      ),
+    );
+    assert.equal(
+      output.sub.dirname,
+      path.join(__dirname, '/integration/env-node-replacements/sub'),
+    );
+    assert.equal(
+      output.sub.filename,
+      path.join(__dirname, '/integration/env-node-replacements/sub/index.js'),
+    );
+  });
+
+  it('should replace __dirname and __filename with path relative to asset.filePath with scope hoisting', async function () {
+    let b = await bundle(
+      path.join(__dirname, '/integration/env-node-replacements/index.js'),
+      {
+        mode: 'production',
+        defaultTargetOptions: {
+          shouldScopeHoist: true,
+          shouldOptimize: false,
+        },
+      },
+    );
+
+    let dist = await outputFS.readFile(b.getBundles()[0].filePath, 'utf8');
+    assert(
+      dist.includes(
+        'path.resolve(__dirname, "../test/integration/env-node-replacements")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'path.resolve(__dirname, "../test/integration/env-node-replacements/other")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'path.resolve(__dirname, "../test/integration/env-node-replacements", "index.js")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'path.resolve(__dirname, "../test/integration/env-node-replacements/sub")',
+      ),
+    );
+    assert(
+      dist.includes(
+        'path.resolve(__dirname, "../test/integration/env-node-replacements/sub", "index.js")',
+      ),
+    );
+    let f = await run(b);
+    let output = f();
+    assert.equal(output.data, 'hello');
+    assert.equal(output.other, 'hello');
+    assert.equal(
+      output.firstDirnameTest,
+      path.join(__dirname, '/integration/env-node-replacements/data'),
+    );
+    assert.equal(
+      output.secondDirnameTest,
+      path.join(__dirname, '/integration/env-node-replacements/other-data'),
+    );
+    assert.equal(
+      output.firstFilenameTest,
+      path.join(__dirname, '/integration/env-node-replacements/index.js'),
+    );
+    assert.equal(
+      output.secondFilenameTest,
+      path.join(
+        __dirname,
+        '/integration/env-node-replacements/index.js?query-string=test',
+      ),
+    );
+    assert.equal(
+      output.sub.dirname,
+      path.join(__dirname, '/integration/env-node-replacements/sub'),
+    );
+    assert.equal(
+      output.sub.filename,
+      path.join(__dirname, '/integration/env-node-replacements/sub/index.js'),
+    );
+  });
+
   it('should work when multiple files use globals with scope hoisting', async function () {
     let b = await bundle(
       path.join(__dirname, '/integration/globals/multiple.js'),

packages/packagers/js/src/DevPackager.js

@@ -1,7 +1,12 @@
 // @flow strict-local
 import type {BundleGraph, PluginOptions, NamedBundle} from '@parcel/types';
 
-import {PromiseQueue, relativeBundlePath, countLines} from '@parcel/utils';
+import {
+  PromiseQueue,
+  relativeBundlePath,
+  countLines,
+  normalizeSeparators,
+} from '@parcel/utils';
 import SourceMap from '@parcel/source-map';
 import invariant from 'assert';
 import path from 'path';
@@ -116,6 +121,20 @@ export class DevPackager {
         wrapped += JSON.stringify(deps);
         wrapped += ']';
 
+        if (
+          this.bundle.env.isNode() &&
+          asset.meta.has_node_replacements === true
+        ) {
+          const relPath = normalizeSeparators(
+            path.relative(
+              this.bundle.target.distDir,
+              path.dirname(asset.filePath),
+            ),
+          );
+          wrapped = wrapped.replace('$parcel$dirnameReplace', relPath);
+          wrapped = wrapped.replace('$parcel$filenameReplace', relPath);
+        }
+
         if (this.bundle.env.sourceMap) {
           if (mapBuffer) {
             map.addBuffer(mapBuffer, lineOffset);

packages/packagers/js/src/ScopeHoistingPackager.js

@@ -8,12 +8,18 @@ import type {
   NamedBundle,
 } from '@parcel/types';
 
-import {PromiseQueue, relativeBundlePath, countLines} from '@parcel/utils';
+import {
+  PromiseQueue,
+  relativeBundlePath,
+  countLines,
+  normalizeSeparators,
+} from '@parcel/utils';
 import SourceMap from '@parcel/source-map';
 import nullthrows from 'nullthrows';
 import invariant from 'assert';
 import ThrowableDiagnostic from '@parcel/diagnostic';
 import globals from 'globals';
+import path from 'path';
 
 import {ESMOutputFormat} from './ESMOutputFormat';
 import {CJSOutputFormat} from './CJSOutputFormat';
@@ -405,6 +411,14 @@ export class ScopeHoistingPackager {
       this.usedHelpers.add('$parcel$global');
     }
 
+    if (this.bundle.env.isNode() && asset.meta.has_node_replacements) {
+      const relPath = normalizeSeparators(
+        path.relative(this.bundle.target.distDir, path.dirname(asset.filePath)),
+      );
+      code = code.replace('$parcel$dirnameReplace', relPath);
+      code = code.replace('$parcel$filenameReplace', relPath);
+    }
+
     let [depMap, replacements] = this.buildReplacements(asset, deps);
     let [prepend, prependLines, append] = this.buildAssetPrelude(asset, deps);
     if (prependLines > 0) {

packages/transformers/js/core/src/lib.rs

@@ -18,6 +18,7 @@ mod fs;
 mod global_replacer;
 mod hoist;
 mod modules;
+mod node_replacer;
 mod typeof_replacer;
 mod utils;
 
@@ -51,6 +52,7 @@ use fs::inline_fs;
 use global_replacer::GlobalReplacer;
 use hoist::{hoist, CollectResult, HoistResult};
 use modules::esm2cjs;
+use node_replacer::NodeReplacer;
 use typeof_replacer::*;
 use utils::{CodeHighlight, Diagnostic, DiagnosticSeverity, SourceLocation, SourceType};
 
@@ -69,6 +71,7 @@ pub struct Config {
   env: HashMap<swc_atoms::JsWord, swc_atoms::JsWord>,
   inline_fs: bool,
   insert_node_globals: bool,
+  node_replacer: bool,
   is_browser: bool,
   is_worker: bool,
   is_type_script: bool,
@@ -102,6 +105,7 @@ pub struct TransformResult {
   diagnostics: Option<Vec<Diagnostic>>,
   needs_esm_helpers: bool,
   used_env: HashSet<swc_atoms::JsWord>,
+  has_node_replacements: bool,
 }
 
 fn targets_to_versions(targets: &Option<HashMap<String, String>>) -> Option<Versions> {
@@ -396,6 +400,28 @@ pub fn transform(config: Config) -> Result<TransformResult, std::io::Error> {
               module.fold_with(&mut passes)
             };
 
+            let mut has_node_replacements = false;
+
+            let module = module.fold_with(
+              // Replace __dirname and __filename with placeholders in Node env
+              &mut Optional::new(
+                NodeReplacer {
+                  source_map: &source_map,
+                  items: &mut global_deps,
+                  globals: HashMap::new(),
+                  project_root: Path::new(&config.project_root),
+                  filename: Path::new(&config.filename),
+                  decls: &mut decls,
+                  global_mark,
+                  scope_hoist: config.scope_hoist,
+                  has_node_replacements: &mut has_node_replacements,
+                },
+                config.node_replacer,
+              ),
+            );
+
+            result.has_node_replacements = has_node_replacements;
+
             let module = module.fold_with(
               // Collect dependencies
               &mut dependency_collector(