@jsreport/jsreport-core 3.11.3 → 3.12.0

package/lib/worker/sandbox/isolatedRequire.js

@@ -0,0 +1,462 @@
+const Module = require('module')
+const path = require('path')
+const fs = require('fs')
+
+const REQUIRE_RESOLVE_CACHE = new Map()
+const REQUIRE_SCRIPT_CACHE = new Map()
+const PACKAGE_JSON_CACHE = new Map()
+
+let ALL_BUILTIN_MODULES
+
+// The isolated require is a function that replicates the node.js require but that does not
+// cache the modules with the standard node.js cache, instead its uses its own cache in order
+// to bring isolated modules across renders and without memory leaks.
+// most of the code is copied from node.js source code and adapted a bit
+// (you will see in some parts specific links to node.js source code counterpart for reference)
+function isolatedRequire (_moduleId, requireFromRootDirectory, isolatedModulesMeta) {
+  const parentModule = typeof _moduleId !== 'string' ? _moduleId.parent : null
+  const moduleId = parentModule ? _moduleId.moduleId : _moduleId
+
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#LL1134C3-L1134C27
+  validateString(moduleId, 'id')
+
+  if (moduleId === '') {
+    throw createInvalidArgValueError('id', moduleId, 'must be a non-empty string')
+  }
+
+  if (isBuiltinModule(moduleId)) {
+    // built-in modules can not be require from other part than the node.js require
+    // perhaps in the future it can be possible:
+    // https://github.com/nodejs/node/issues/31852
+    // https://github.com/nodejs/node/issues/28823
+    return require(moduleId)
+  }
+
+  const { modulesCache, requireExtensions } = isolatedModulesMeta
+  const fullModulePath = resolveFilename(requireFromRootDirectory, moduleId, { parentModulePath: parentModule?.path })
+
+  if (modulesCache[fullModulePath]) {
+    return modulesCache[fullModulePath].exports
+  }
+
+  const mod = new IsolatedModule(fullModulePath, parentModule)
+
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1133
+  // we can not add this to the IsolatedModule.prototype because we need access to other variables
+  mod.require = function (id) {
+    return isolatedRequire({ parent: this, moduleId: id }, requireFromRootDirectory, isolatedModulesMeta)
+  }
+
+  modulesCache[fullModulePath] = mod
+
+  mod.filename = fullModulePath
+  mod.paths = Module._nodeModulePaths(path.dirname(fullModulePath))
+
+  const extension = findLongestRegisteredExtension(fullModulePath, requireExtensions)
+
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1113
+  // allow .mjs to be overridden
+  if (fullModulePath.endsWith('.mjs') && !requireExtensions['.mjs']) {
+    throw createRequireESMError(fullModulePath)
+  }
+
+  const moduleResolver = requireExtensions[extension]
+
+  moduleResolver(mod, fullModulePath)
+
+  mod.loaded = true
+
+  return mod.exports
+}
+
+function setDefaultRequireExtensions (currentExtensions, requireFromRootDirectory, compileScript) {
+  const extensions = Object.create(null)
+
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1263
+  extensions['.js'] = function (_module, filename) {
+    const dirname = path.dirname(filename)
+
+    // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1273
+    if (filename.endsWith('.js')) {
+      const pkg = readPackageScope(filename)
+
+      // Function require shouldn't be used in ES modules.
+      if (pkg?.data?.type === 'module') {
+        const parent = _module.parent
+        const parentPath = parent?.filename
+        throw createRequireESMError(filename, parentPath)
+      }
+    }
+
+    let compiledScript
+
+    if (REQUIRE_SCRIPT_CACHE.has(filename)) {
+      compiledScript = REQUIRE_SCRIPT_CACHE.get(filename)
+    } else {
+      let moduleContent = fs.readFileSync(filename, 'utf8')
+
+      moduleContent = removeShebangFromModuleContent(moduleContent)
+
+      const moduleWrappedContent = Module.wrap(moduleContent)
+
+      compiledScript = compileScript(moduleWrappedContent, filename, false)
+
+      REQUIRE_SCRIPT_CACHE.set(filename, compiledScript)
+    }
+
+    // we run module in same context than main context because we want to reproduce the same behavior
+    // than older versions of jsreport, in which the module code is executed in the same context than main
+    // (because older version was using normal require, and that is how the normal node.js
+    // require works when evaluating modules code).
+    // Choosing different context means things like constructors (Number, String) and instanceof
+    // checks have different results and we wanted to keep the same behavior than older versions,
+    // however one benefit of running the modules code in same context is that we don't have to care
+    // about re-expose the node.js globals (like Buffer, process, etc) to the module code, because
+    // the main context already have those
+    const runScript = () => {
+      return compiledScript.runInThisContext({
+        displayErrors: true
+      })
+    }
+
+    const moduleWrappedFn = runScript()
+
+    const requireInModule = makeRequireFunction(_module, requireFromRootDirectory, currentExtensions)
+
+    const args = [_module.exports, requireInModule, _module, filename, dirname]
+
+    moduleWrappedFn.apply(_module.exports, args)
+  }
+
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1313
+  extensions['.json'] = function (_module, filename) {
+    const content = fs.readFileSync(filename, 'utf8')
+
+    try {
+      setOwnProperty(_module, 'exports', JSON.parse(stripBOM(content)))
+    } catch (err) {
+      err.message = filename + ': ' + err.message
+      throw err
+    }
+  }
+
+  // https://github.com/nodejs/node/blob/v16.11.0/lib/internal/modules/cjs/loader.js#L1176
+  extensions['.node'] = function (_module, filename) {
+    // Be aware this doesn't use `content`
+    return process.dlopen(_module, path.toNamespacedPath(filename))
+  }
+
+  Object.assign(currentExtensions, extensions)
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L225
+function IsolatedModule (id = '', parent) {
+  this.id = id
+  this.path = path.dirname(id)
+  setOwnProperty(this, 'exports', {})
+  this.filename = null
+  this.loaded = false
+  // NOTE: since we don't set parent we don't keep track of children either
+  // (because to correctly track it we would need to store the module instance
+  // and not just the module.exports like we do now, if the need appears we can do it)
+  this.children = []
+  // NOTE: this property is already deprecated (according to node.js docs),
+  // it seems it does not make sense to replicate
+  // something here, however if the need appears we can check what we can do about it
+  // we should be aware of the expected values it carries according to the node.js docs
+  // https://nodejs.org/api/modules.html#moduleparent
+  this.parent = undefined
+
+  // this is always false for our case, because our modules we never run during the
+  // Node.js preload phase
+  Object.defineProperty(this, 'isPreloading', {
+    get () { return false }
+  })
+}
+
+// NOTE: we can not use Module.isBuiltin because it is not available on node 16
+// we can upgrade our implementation to just use Module.isBuiltin when we drop support for node 16
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L252
+function isBuiltinModule (moduleId) {
+  // use the standard function when available
+  if (Module.isBuiltin) {
+    return Module.isBuiltin(moduleId)
+  }
+
+  // the only version in which this code would run is node 16 and early versions of node 18
+  // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L252
+  if (!ALL_BUILTIN_MODULES) {
+    ALL_BUILTIN_MODULES = new Set(Module.builtinModules.flatMap((bm) => [bm, `node:${bm}`]))
+  }
+
+  return ALL_BUILTIN_MODULES.has(moduleId)
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/helpers.js#L65
+function makeRequireFunction (mod, requireFromRootDirectory, currentExtensions) {
+  const requireFn = function require (path) {
+    return mod.require(path)
+  }
+
+  function resolve (request, options) {
+    const extra = {
+      parentModulePath: mod.path,
+      options
+    }
+
+    return resolveFilename(requireFromRootDirectory, request, extra)
+  }
+
+  requireFn.resolve = resolve
+
+  function paths (request) {
+    validateString(request, 'request')
+    return Module._resolveLookupPaths(request, mod)
+  }
+
+  resolve.paths = paths
+
+  setOwnProperty(requireFn, 'main', process.mainModule)
+
+  // Enable support to add extra extension types
+  requireFn.extensions = currentExtensions
+
+  // NOTE: we pass just use empty object here, it is not going to be set/used by us anywhere
+  // we just provide it for back-compatibility in case some module expect it to exists
+  requireFn.cache = Object.create(null)
+
+  return requireFn
+}
+
+function resolveFilename (requireFromRootDirectory, moduleId, extra) {
+  const { parentModulePath, options } = extra
+  const useCache = options == null
+  const resolveCacheKey = parentModulePath ? `${parentModulePath}::${moduleId}` : moduleId
+  let fullModulePath
+
+  if (useCache && REQUIRE_RESOLVE_CACHE.has(resolveCacheKey)) {
+    fullModulePath = REQUIRE_RESOLVE_CACHE.get(resolveCacheKey)
+  } else {
+    if (parentModulePath) {
+      const optionsToUse = { ...options }
+
+      // search from the parent module path by default if not explicit .paths has been passed
+      if (optionsToUse.paths == null) {
+        optionsToUse.paths = [parentModulePath]
+      }
+
+      fullModulePath = requireFromRootDirectory.resolve(moduleId, optionsToUse)
+    } else {
+      fullModulePath = requireFromRootDirectory.resolve(moduleId)
+    }
+
+    if (useCache) {
+      REQUIRE_RESOLVE_CACHE.set(resolveCacheKey, fullModulePath)
+    }
+  }
+
+  return fullModulePath
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L496
+// Find the longest (possibly multi-dot) extension registered in extensions
+function findLongestRegisteredExtension (fullPath, extensions) {
+  const name = path.basename(fullPath)
+  let currentExtension
+  let index
+  let startIndex = 0
+
+  while ((index = name.indexOf('.', startIndex)) !== -1) {
+    startIndex = index + 1
+
+    if (index === 0) {
+      // Skip dotfiles like .gitignore
+      continue
+    }
+
+    currentExtension = name.slice(index)
+
+    if (extensions[currentExtension]) {
+      return currentExtension
+    }
+  }
+
+  return '.js'
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L404
+function readPackageScope (checkPath) {
+  const sep = path.sep
+  const rootSeparatorIndex = checkPath.indexOf(sep)
+  let separatorIndex
+
+  do {
+    separatorIndex = checkPath.lastIndexOf(sep)
+    checkPath = checkPath.slice(0, separatorIndex)
+
+    if (checkPath.endsWith(sep + 'node_modules')) {
+      return false
+    }
+
+    const pjson = readPackage(checkPath + sep)
+
+    if (pjson) {
+      return {
+        data: pjson,
+        path: checkPath
+      }
+    }
+  } while (separatorIndex > rootSeparatorIndex)
+
+  return false
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L362
+function readPackage (requestPath) {
+  const jsonPath = path.resolve(requestPath, 'package.json')
+
+  const existing = PACKAGE_JSON_CACHE.get(jsonPath)
+
+  if (existing !== undefined) {
+    return existing
+  }
+
+  let json
+
+  try {
+    json = fs.readFileSync(jsonPath, 'utf8')
+  } catch (error) {}
+
+  if (json === undefined) {
+    PACKAGE_JSON_CACHE.set(jsonPath, false)
+    return false
+  }
+
+  try {
+    const filtered = filterOwnProperties(JSON.parse(json), [
+      'name',
+      'main',
+      'exports',
+      'imports',
+      'type'
+    ])
+
+    PACKAGE_JSON_CACHE.set(jsonPath, filtered)
+    return filtered
+  } catch (e) {
+    e.path = jsonPath
+    e.message = 'Error parsing ' + jsonPath + ': ' + e.message
+    throw e
+  }
+}
+
+function removeShebangFromModuleContent (content) {
+  let moduleContent = content
+  // https://github.com/nodejs/node/blob/v7.5.0/lib/module.js#L511
+  // remove shebang
+  const contLen = moduleContent.length
+
+  if (contLen >= 2) {
+    if (
+      /* # */
+      moduleContent.charCodeAt(0) === 35 &&
+      /* ! */
+      moduleContent.charCodeAt(1) === 33
+    ) {
+      if (contLen === 2) {
+        // Exact match
+        moduleContent = ''
+      } else {
+        // Find end of shebang line and slice it off
+        let i = 2
+
+        for (; i < contLen; ++i) {
+          const code = moduleContent.charCodeAt(i)
+          /* \n || \r */
+          if (code === 10 || code === 13) {
+            break
+          }
+        }
+
+        if (i === contLen) {
+          moduleContent = ''
+        } else {
+          // Note that this actually includes the newline character(s) in the
+          // new output. This duplicates the behavior of the regular
+          // expression that was previously used to replace the shebang line
+          moduleContent = moduleContent.slice(i)
+        }
+      }
+    }
+  }
+
+  return moduleContent
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/helpers.js#L143
+function stripBOM (content) {
+  if (content.charCodeAt() === 0xFEFF) {
+    content = content.slice(1)
+  }
+  return content
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/util.js#L548
+function setOwnProperty (obj, key, value) {
+  return Object.defineProperty(obj, key, {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  })
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/util.js#L529
+function filterOwnProperties (source, keys) {
+  const filtered = Object.create(null)
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      filtered[key] = source[key]
+    }
+  }
+
+  return filtered
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/errors.js#L1518
+// simplified version of the require ESM error
+function createRequireESMError (filename, parentPath) {
+  const parentPathExtraMsg = parentPath ? ` from ${parentPath}` : ''
+  const error = new Error(`require() of ES Module ${filename}${parentPathExtraMsg} not supported.`)
+
+  error.name = 'Error [ERR_REQUIRE_ESM]'
+
+  return error
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/errors.js#L1279
+function createInvalidArgValueError (name, value, reason) {
+  const error = new TypeError(`The argument '${name}' ${reason}. Received ${value}`)
+
+  error.name = 'TypeError [ERR_INVALID_ARG_VALUE]'
+
+  return error
+}
+
+// https://github.com/nodejs/node/blob/v18.14.2/lib/internal/validators.js#L161
+function validateString (value, name) {
+  if (typeof value !== 'string') {
+    const error = new TypeError(`The "${name}" argument must be of type string. Received type ${typeof value} (${value})`)
+
+    error.name = 'TypeError [ERR_INVALID_ARG_TYPE]'
+
+    throw error
+  }
+}
+
+module.exports = isolatedRequire
+module.exports.setDefaultRequireExtensions = setDefaultRequireExtensions