Restrict process and Buffer globals to CommonJS

lib/internal/bootstrap/loaders.js

@@ -140,7 +140,8 @@ let internalBinding;
 const loaderExports = {
   internalBinding,
   NativeModule,
-  require: nativeModuleRequire
+  require: nativeModuleRequire,
+  cjsContext: { __proto__: null, process: undefined, Buffer: undefined }
 };
 
 const loaderId = 'internal/bootstrap/loaders';

lib/internal/bootstrap/pre_execution.js

@@ -262,28 +262,27 @@ function initializeDeprecations() {
                                 'Please use public APIs instead.', 'DEP0111');
   }
 
-  // Create global.process and global.Buffer as getters so that we have a
-  // deprecation path for these in ES Modules.
-  // See https://github.com/nodejs/node/pull/26334.
-  let _process = process;
+  // Create global.process and global.Buffer as getters to allow deprecation.
+  const { cjsContext } = require('internal/bootstrap/loaders');
+  cjsContext.process = process;
+  cjsContext.Buffer = Buffer;
   Object.defineProperty(global, 'process', {
     get() {
-      return _process;
+      return cjsContext.process;
     },
     set(value) {
-      _process = value;
+      cjsContext.process = value;
     },
     enumerable: false,
     configurable: true
   });
 
-  let _Buffer = Buffer;
   Object.defineProperty(global, 'Buffer', {
     get() {
-      return _Buffer;
+      return cjsContext.Buffer;
     },
     set(value) {
-      _Buffer = value;
+      cjsContext.Buffer = value;
     },
     enumerable: false,
     configurable: true

lib/internal/modules/cjs/loader.js

@@ -23,7 +23,7 @@
 
 const { JSON, Object, Reflect } = primordials;
 
-const { NativeModule } = require('internal/bootstrap/loaders');
+const { NativeModule, cjsContext } = require('internal/bootstrap/loaders');
 const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
 const { deprecate } = require('internal/util');
 const vm = require('vm');
@@ -703,37 +703,35 @@ function wrapSafe(filename, content) {
         return loader.import(specifier, normalizeReferrerURL(filename));
       } : undefined,
     });
+  } else {
+    const compiledWrapper = compileFunction(
+      content,
+      filename,
+      0,
+      0,
+      undefined,
+      false,
+      undefined,
+      [cjsContext],
+      [
+        'exports',
+        'require',
+        'module',
+        '__filename',
+        '__dirname',
+      ]
+    );
+    if (experimentalModules) {
+      const { callbackMap } = internalBinding('module_wrap');
+      callbackMap.set(compiledWrapper, {
+        importModuleDynamically: async (specifier) => {
+          const loader = await asyncESM.loaderPromise;
+          return loader.import(specifier, normalizeReferrerURL(filename));
+        }
+      });
+    }
+    return compiledWrapper;
   }
-
-  const compiledWrapper = compileFunction(
-    content,
-    filename,
-    0,
-    0,
-    undefined,
-    false,
-    undefined,
-    [],
-    [
-      'exports',
-      'require',
-      'module',
-      '__filename',
-      '__dirname',
-    ]
-  );
-
-  if (experimentalModules) {
-    const { callbackMap } = internalBinding('module_wrap');
-    callbackMap.set(compiledWrapper, {
-      importModuleDynamically: async (specifier) => {
-        const loader = await asyncESM.loaderPromise;
-        return loader.import(specifier, normalizeReferrerURL(filename));
-      }
-    });
-  }
-
-  return compiledWrapper;
 }
 
 // Run the file contents in the correct scope or sandbox. Expose

lib/internal/modules/esm/deprecate_process_buffer.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { cjsContext } = require('internal/bootstrap/loaders');
+const { getStackSourceName } = internalBinding('contextify');
+const { deprecate } = require('internal/util');
+const { Object } = primordials;
+
+module.exports = () => {
+  // Deprecate global.process and global.Buffer access in ES Modules.
+  const processGetter = deprecate(
+    () => cjsContext.process,
+    'global.process is deprecated in ECMAScript Modules. ' +
+        'Please use `import process from \'process\'` instead.', 'DEP0XXX');
+  Object.defineProperty(global, 'process', {
+    get() {
+      const sourceName = getStackSourceName(1);
+      if (sourceName && sourceName.startsWith('file://'))
+        return processGetter();
+      return cjsContext.process;
+    },
+    set(value) {
+      cjsContext.process = value;
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  const bufferGetter = deprecate(
+    () => cjsContext.Buffer,
+    'global.Buffer is deprecated in ECMAScript Modules. ' +
+        'Please use `import { Buffer } from \'buffer\'` instead.', 'DEP0YYY');
+  Object.defineProperty(global, 'Buffer', {
+    get() {
+      const sourceName = getStackSourceName(1);
+      if (sourceName && sourceName.startsWith('file://'))
+        return bufferGetter();
+      return cjsContext.Buffer;
+    },
+    set(value) {
+      cjsContext.Buffer = value;
+    },
+    enumerable: false,
+    configurable: true
+  });
+};

lib/internal/modules/esm/translators.js

@@ -21,6 +21,8 @@ const fs = require('fs');
 const { fileURLToPath, URL } = require('url');
 const { debuglog } = require('internal/util/debuglog');
 const { promisify } = require('internal/util');
+const deprecateProcessBufferAccess =
+    require('internal/modules/esm/deprecate_process_buffer');
 const esmLoader = require('internal/process/esm_loader');
 const {
   ERR_UNKNOWN_BUILTIN_MODULE
@@ -43,7 +45,12 @@ async function importModuleDynamically(specifier, { url }) {
 }
 
 // Strategy for loading a standard JavaScript module
+let firstModule = true;
 translators.set('module', async function moduleStrategy(url) {
+  if (firstModule) {
+    deprecateProcessBufferAccess();
+    firstModule = false;
+  }
   const source = `${await readFileAsync(new URL(url))}`;
   debug(`Translating StandardModule ${url}`);
   const { ModuleWrap, callbackMap } = internalBinding('module_wrap');

node.gyp

@@ -150,6 +150,7 @@
       'lib/internal/modules/esm/loader.js',
       'lib/internal/modules/esm/create_dynamic_module.js',
       'lib/internal/modules/esm/default_resolve.js',
+      'lib/internal/modules/esm/deprecate_process_buffer.js',
       'lib/internal/modules/esm/module_job.js',
       'lib/internal/modules/esm/module_map.js',
       'lib/internal/modules/esm/translators.js',

src/node_contextify.cc

@@ -66,6 +66,8 @@ using v8::PropertyHandlerFlags;
 using v8::Script;
 using v8::ScriptCompiler;
 using v8::ScriptOrigin;
+using v8::StackFrame;
+using v8::StackTrace;
 using v8::String;
 using v8::Symbol;
 using v8::Uint32;
@@ -221,6 +223,7 @@ void ContextifyContext::Init(Environment* env, Local<Object> target) {
   env->SetMethod(target, "makeContext", MakeContext);
   env->SetMethod(target, "isContext", IsContext);
   env->SetMethod(target, "compileFunction", CompileFunction);
+  env->SetMethod(target, "getStackSourceName", GetStackSourceName);
 }
 
 
@@ -285,6 +288,30 @@ void ContextifyContext::IsContext(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result.FromJust());
 }
 
+void ContextifyContext::GetStackSourceName(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK_EQ(args.Length(), 1);
+  CHECK(args[0]->IsNumber());
+
+  int32_t stack_depth = args[0].As<Integer>()->Value();
+
+  Local<StackFrame> frame;
+  do {
+    Local<StackTrace> stack =
+        StackTrace::CurrentStackTrace(env->isolate(),
+                                      stack_depth + 1);
+    if (stack_depth >= stack->GetFrameCount()) {
+      return;
+    }
+    frame = stack->GetFrame(env->isolate(), stack_depth++);
+  } while (frame->IsEval());
+
+  Local<Value> script_name = frame->GetScriptName();
+
+  args.GetReturnValue().Set(script_name);
+}
 
 void ContextifyContext::WeakCallback(
     const WeakCallbackInfo<ContextifyContext>& data) {

src/node_contextify.h

@@ -57,6 +57,8 @@ class ContextifyContext {
  private:
   static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStackSourceName(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CompileFunction(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void WeakCallback(

test/common/index.mjs

@@ -1,12 +1,7 @@
 // Flags: --experimental-modules
 /* eslint-disable node-core/require-common-first, node-core/required-modules */
 
-import { createRequireFromPath } from 'module';
-import { fileURLToPath as toPath } from 'url';
-
-function createRequire(metaUrl) {
-  return createRequireFromPath(toPath(metaUrl));
-}
+import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
 const common = require('./index.js');

test/message/async_error_sync_esm.out

@@ -5,4 +5,3 @@ Error: test
     at async three (*fixtures*async-error.js:20:3)
     at async four (*fixtures*async-error.js:24:3)
     at async main (*message*async_error_sync_esm.mjs:7:5)
-(node:*) [DEP0130] DeprecationWarning: Module.createRequireFromPath() is deprecated. Use Module.createRequire() instead.

test/parallel/test-global-buffer-dep.mjs

@@ -0,0 +1,9 @@
+// Flags: --experimental-modules
+import { expectWarning } from '../common/index.mjs';
+
+global.Buffer;
+
+expectWarning('DeprecationWarning',
+              'global.Buffer is deprecated in ECMAScript Modules. ' +
+              'Please use `import { Buffer } from \'buffer\'` instead.',
+              'DEP0YYY');

test/parallel/test-global-process-dep-eval.mjs

@@ -0,0 +1,9 @@
+// Flags: --experimental-modules
+import { expectWarning } from '../common/index.mjs';
+
+(0, eval)('process');
+
+expectWarning('DeprecationWarning',
+              'global.process is deprecated in ECMAScript Modules. ' +
+              'Please use `import process from \'process\'` instead.',
+              'DEP0XXX');

test/parallel/test-global-process-dep-nested-eval.mjs

@@ -0,0 +1,9 @@
+// Flags: --experimental-modules
+import { expectWarning } from '../common/index.mjs';
+
+new Function('return new Function("eval(process)")')()();
+
+expectWarning('DeprecationWarning',
+              'global.process is deprecated in ECMAScript Modules. ' +
+              'Please use `import process from \'process\'` instead.',
+              'DEP0XXX');

test/parallel/test-global-process-dep.mjs

@@ -0,0 +1,9 @@
+// Flags: --experimental-modules
+import { expectWarning } from '../common/index.mjs';
+
+process;
+
+expectWarning('DeprecationWarning',
+              'global.process is deprecated in ECMAScript Modules. ' +
+              'Please use `import process from \'process\'` instead.',
+              'DEP0XXX');