From 94abf689f80b72af3769ba9fa652a5a01687df71 Mon Sep 17 00:00:00 2001 From: Greg Magolan Date: Thu, 26 Sep 2019 14:00:23 -0700 Subject: [PATCH] fix(builtin): support for scoped modules in linker (#1199) --- internal/linker/index.js | 30 ++++++++++++++----- internal/linker/link_node_modules.ts | 29 ++++++++++++++---- internal/linker/test/integration/BUILD.bazel | 2 ++ .../dynamic_linked_scoped_pkg/BUILD.bazel | 10 +++++++ .../dynamic_linked_scoped_pkg/index.js | 5 ++++ internal/linker/test/integration/golden.txt | 2 +- internal/linker/test/integration/program.js | 12 ++++---- .../static_linked_scoped_pkg/BUILD.bazel | 9 ++++++ .../static_linked_scoped_pkg/index.js | 5 ++++ 9 files changed, 85 insertions(+), 19 deletions(-) create mode 100644 internal/linker/test/integration/dynamic_linked_scoped_pkg/BUILD.bazel create mode 100644 internal/linker/test/integration/dynamic_linked_scoped_pkg/index.js create mode 100644 internal/linker/test/integration/static_linked_scoped_pkg/BUILD.bazel create mode 100644 internal/linker/test/integration/static_linked_scoped_pkg/index.js diff --git a/internal/linker/index.js b/internal/linker/index.js index 850fc0c041..099330946b 100644 --- a/internal/linker/index.js +++ b/internal/linker/index.js @@ -40,6 +40,16 @@ Include as much of the build output as you can without disclosing anything confi ${m} `); } + /** + * Create a new directory and any necessary subdirectories + * if they do not exist. + */ + function mkdirp(p) { + if (!fs.existsSync(p)) { + mkdirp(path.dirname(p)); + fs.mkdirSync(p); + } + } function symlink(target, path) { return __awaiter(this, void 0, void 0, function* () { log_verbose(`symlink( ${path} -> ${target} )`); @@ -62,7 +72,7 @@ Include as much of the build output as you can without disclosing anything confi // any unneeded file I/O if (!fs.existsSync(path)) { log_verbose('ERROR\n***\nLooks like we created a bad symlink:' + - `\n pwd ${process.cwd()}\n target ${target}\n***`); + `\n pwd ${process.cwd()}\n target ${target}\n path ${path}\n***`); } } }); @@ -178,8 +188,6 @@ Include as much of the build output as you can without disclosing anything confi if (this.manifest) { return this.lookupDirectory(modulePath); } - // how can we avoid this FS lookup every time? we don't know when process.cwd changed... - // const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; if (exports.runfiles.dir) { return path.join(exports.runfiles.dir, modulePath); } @@ -239,7 +247,7 @@ Include as much of the build output as you can without disclosing anything confi yield symlink(rootDir, 'node_modules'); process.chdir(rootDir); // Symlinks to packages need to reach back to the workspace/runfiles directory - const workspaceRelative = path.relative('.', workspaceDir); + const workspaceAbs = path.resolve(workspaceDir); // Now add symlinks to each of our first-party packages so they appear under the node_modules tree const links = []; const linkModule = (name, root, modulePath) => __awaiter(this, void 0, void 0, function* () { @@ -247,7 +255,7 @@ Include as much of the build output as you can without disclosing anything confi switch (root) { case 'bin': // FIXME(#1196) - target = path.join(workspaceRelative, bin, toWorkspaceDir(modulePath)); + target = path.join(workspaceAbs, bin, toWorkspaceDir(modulePath)); // Spend an extra FS lookup to give better error in this case if (!(yield exists(target))) { // TODO: there should be some docs explaining how users are @@ -261,7 +269,7 @@ Include as much of the build output as you can without disclosing anything confi } break; case 'src': - target = path.join(workspaceRelative, toWorkspaceDir(modulePath)); + target = path.join(workspaceAbs, toWorkspaceDir(modulePath)); break; case 'runfiles': target = runfiles.resolve(modulePath) || ''; @@ -270,6 +278,14 @@ Include as much of the build output as you can without disclosing anything confi yield symlink(target, name); }); for (const m of Object.keys(modules)) { + const segments = m.split('/'); + if (segments.length > 2) { + throw new Error(`module ${m} has more than 2 segments which is not a valid node module name`); + } + if (segments.length == 2) { + // ensure the scope exists + mkdirp(segments[0]); + } const [kind, modulePath] = modules[m]; links.push(linkModule(m, kind, modulePath)); } @@ -289,4 +305,4 @@ Include as much of the build output as you can without disclosing anything confi }))(); } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link_node_modules.js","sourceRoot":"","sources":["../../../../../internal/linker/link_node_modules.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview Creates a node_modules directory in the current working directory\n * and symlinks in the node modules needed to run a program.\n * This replaces the need for custom module resolution logic inside the process.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging\nconst VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];\n\nfunction log_verbose(...m: string[]) {\n  if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m);\n}\n\nfunction panic(m: string) {\n  throw new Error(`Internal error! Please run again with\n   --define=VERBOSE_LOG=1\nand file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md\nInclude as much of the build output as you can without disclosing anything confidential.\n\n  Error:\n  ${m}\n  `);\n}\n\nasync function symlink(target: string, path: string) {\n  log_verbose(`symlink( ${path} -> ${target} )`);\n  // Use junction on Windows since symlinks require elevated permissions.\n  // We only link to directories so junctions work for us.\n  try {\n    await fs.promises.symlink(target, path, 'junction');\n  } catch (e) {\n    if (e.code !== 'EEXIST') {\n      throw e;\n    }\n    // We assume here that the path is already linked to the correct target.\n    // Could add some logic that asserts it here, but we want to avoid an extra\n    // filesystem access so we should only do it under some kind of strict mode.\n  }\n\n  if (VERBOSE_LOGS) {\n    // Be verbose about creating a bad symlink\n    // Maybe this should fail in production as well, but again we want to avoid\n    // any unneeded file I/O\n    if (!fs.existsSync(path)) {\n      log_verbose(\n          'ERROR\\n***\\nLooks like we created a bad symlink:' +\n          `\\n  pwd ${process.cwd()}\\n  target ${target}\\n***`);\n    }\n  }\n}\n\n/**\n * Resolve a root directory string to the actual location on disk\n * where node_modules was installed\n * @param root a string like 'npm/node_modules'\n */\nfunction resolveRoot(root: string|undefined, runfiles: Runfiles) {\n  // create a node_modules directory if no root\n  // this will be the case if only first-party modules are installed\n  if (!root) {\n    if (!fs.existsSync('node_modules')) {\n      log_verbose('no third-party packages; mkdir node_modules in ', process.cwd());\n      fs.mkdirSync('node_modules');\n    }\n    return 'node_modules';\n  }\n\n  // If we got a runfilesManifest map, look through it for a resolution\n  // This will happen if we are running a binary that had some npm packages\n  // \"statically linked\" into its runfiles\n  const fromManifest = runfiles.lookupDirectory(root);\n  if (fromManifest) return fromManifest;\n\n  // Account for Bazel --legacy_external_runfiles\n  // which look like 'my_wksp/external/npm/node_modules'\n  if (fs.existsSync(path.join('external', root))) {\n    log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root));\n    return path.join('external', root);\n  }\n\n  // The repository should be layed out in the parent directory\n  // since bazel sets our working directory to the repository where the build is happening\n  return path.join('..', root);\n}\n\nexport class Runfiles {\n  manifest: Map<string, string>|undefined;\n  dir: string|undefined;\n  /**\n   * If the environment gives us enough hints, we can know the path to the package\n   * in the form workspace_name/path/to/package\n   */\n  packagePath: string|undefined;\n\n  constructor(env: typeof process.env) {\n    // If Bazel sets a variable pointing to a runfiles manifest,\n    // we'll always use it.\n    // Note that this has a slight performance implication on Mac/Linux\n    // where we could use the runfiles tree already laid out on disk\n    // but this just costs one file read for the external npm/node_modules\n    // and one for each first-party module, not one per file.\n    if (!!env['RUNFILES_MANIFEST_FILE']) {\n      this.manifest = this.loadRunfilesManifest(env['RUNFILES_MANIFEST_FILE']!);\n    } else if (!!env['RUNFILES_DIR']) {\n      this.dir = path.resolve(env['RUNFILES_DIR']!);\n    } else {\n      panic(\n          'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable');\n    }\n    // Under --noenable_runfiles (in particular on Windows)\n    // Bazel sets RUNFILES_MANIFEST_ONLY=1.\n    // When this happens, we need to read the manifest file to locate\n    // inputs\n    if (env['RUNFILES_MANIFEST_ONLY'] === '1' && !env['RUNFILES_MANIFEST_FILE']) {\n      log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994\n                 RUNFILES_MANIFEST_FILE should have been set but wasn't.\n                 falling back to using runfiles symlinks.\n                 If you want to test runfiles manifest behavior, add\n                 --spawn_strategy=standalone to the command line.`);\n    }\n\n    const wksp = env['TEST_WORKSPACE'];\n    const target = env['TEST_TARGET'];\n    if (!!wksp && !!target) {\n      // //path/to:target -> //path/to\n      const pkg = target.split(':')[0];\n      this.packagePath = path.posix.join(wksp, pkg);\n    }\n  }\n\n  lookupDirectory(dir: string): string|undefined {\n    if (!this.manifest) return undefined;\n\n    for (const [k, v] of this.manifest) {\n      // Account for Bazel --legacy_external_runfiles\n      // which pollutes the workspace with 'my_wksp/external/...'\n      if (k.startsWith(`${dir}/external`)) continue;\n\n      // Entry looks like\n      // k: npm/node_modules/semver/LICENSE\n      // v: /path/to/external/npm/node_modules/semver/LICENSE\n      // calculate l = length(`/semver/LICENSE`)\n      if (k.startsWith(dir)) {\n        const l = k.length - dir.length;\n        return v.substring(0, v.length - l);\n      }\n    }\n  }\n\n\n  /**\n   * The runfiles manifest maps from short_path\n   * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path\n   * to the actual location on disk where the file can be read.\n   *\n   * In a sandboxed execution, it does not exist. In that case, runfiles must be\n   * resolved from a symlink tree under the runfiles dir.\n   * See https://github.com/bazelbuild/bazel/issues/3726\n   */\n  loadRunfilesManifest(manifestPath: string) {\n    log_verbose(`using runfiles manifest ${manifestPath}`);\n\n    const runfilesEntries = new Map();\n    const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'});\n\n    for (const line of input.split('\\n')) {\n      if (!line) continue;\n      const [runfilesPath, realPath] = line.split(' ');\n      runfilesEntries.set(runfilesPath, realPath);\n    }\n\n    return runfilesEntries;\n  }\n\n  resolve(modulePath: string) {\n    // Look in the runfiles first\n    if (this.manifest) {\n      return this.lookupDirectory(modulePath);\n    }\n    // how can we avoid this FS lookup every time? we don't know when process.cwd changed...\n    // const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined;\n    if (runfiles.dir) {\n      return path.join(runfiles.dir, modulePath);\n    }\n    throw new Error(`could not resolve modulePath ${modulePath}`);\n  }\n\n  resolvePackageRelative(modulePath: string) {\n    if (!this.packagePath) {\n      throw new Error('packagePath could not be determined from the environment');\n    }\n    return this.resolve(path.posix.join(this.packagePath, modulePath));\n  }\n}\n\n// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer.\ndeclare global {\n  interface JSON {\n    parse(b: {toString: () => string}): any;\n  }\n}\n\n// There is no fs.promises.exists function because\n// node core is of the opinion that exists is always too racey to rely on.\nasync function exists(p: string) {\n  try {\n    await fs.promises.stat(p)\n    return true;\n  } catch (e) {\n    if (e.code === 'ENOENT') {\n      return false;\n    }\n    throw e;\n  }\n}\n\n// See link_node_modules.bzl where these three strings\n// are used to indicate which root the linker should target\n// for each package:\n// bin: bazel-bin/path/to/package\n// src: workspace/path/to/package\n// runfiles: look in the runfiles dir/manifest\ntype LinkerRoot = 'bin'|'src'|'runfiles';\n\nexport async function main(args: string[], runfiles: Runfiles) {\n  if (!args || args.length < 1)\n    throw new Error('link_node_modules.js requires one argument: modulesManifest path');\n\n  const [modulesManifest] = args;\n  let {bin, root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest));\n  modules = modules || {};\n  log_verbose(\n      `module manifest: workspace ${workspace}, bin ${bin}, root ${\n          root} with first-party packages\\n`,\n      modules);\n\n  const rootDir = resolveRoot(root, runfiles);\n  log_verbose('resolved root', root, 'to', rootDir);\n\n  // Bazel starts actions with pwd=execroot/my_wksp\n  const workspaceDir = path.resolve('.');\n\n  // Convert from runfiles path\n  // this_wksp/path/to/file OR other_wksp/path/to/file\n  // to execroot path\n  // path/to/file OR external/other_wksp/path/to/file\n  function toWorkspaceDir(p: string) {\n    if (p === workspace) {\n      return '.';\n    }\n    // The manifest is written with forward slash on all platforms\n    if (p.startsWith(workspace + '/')) {\n      return p.substring(workspace.length + 1);\n    }\n    return path.join('external', p);\n  }\n\n  // Create the $pwd/node_modules directory that node will resolve from\n  await symlink(rootDir, 'node_modules');\n  process.chdir(rootDir);\n\n  // Symlinks to packages need to reach back to the workspace/runfiles directory\n  const workspaceRelative = path.relative('.', workspaceDir);\n\n  // Now add symlinks to each of our first-party packages so they appear under the node_modules tree\n  const links = [];\n\n  const linkModule =\n      async (name: string, root: LinkerRoot, modulePath: string) => {\n    let target: string = '<package linking failed>';\n    switch (root) {\n      case 'bin':\n        // FIXME(#1196)\n        target = path.join(workspaceRelative, bin, toWorkspaceDir(modulePath));\n        // Spend an extra FS lookup to give better error in this case\n        if (!await exists(target)) {\n          // TODO: there should be some docs explaining how users are\n          // expected to declare ahead of time where the package is loaded,\n          // how that relates to npm link scenarios,\n          // and where the configuration can go.\n          return Promise.reject(`ERROR: no output directory found for package ${modulePath}\n        Did you mean to declare this as a from-source package?\n        See https://github.com/bazelbuild/rules_nodejs/pull/1197\n        until this feature is properly documented.`);\n        }\n        break;\n      case 'src':\n        target = path.join(workspaceRelative, toWorkspaceDir(modulePath));\n        break;\n      case 'runfiles':\n        target = runfiles.resolve(modulePath) || '<runfiles resolution failed>';\n        break;\n    }\n\n    await symlink(target, name);\n  }\n\n  for (const m of Object.keys(modules)) {\n    const [kind, modulePath] = modules[m];\n    links.push(linkModule(m, kind, modulePath));\n  }\n\n  let code = 0;\n  await Promise.all(links).catch(e => {\n    console.error(e);\n    code = 1;\n  });\n\n  return code;\n}\n\nexport const runfiles = new Runfiles(process.env);\n\nif (require.main === module) {\n  (async () => {\n    process.exitCode = await main(process.argv.slice(2), runfiles);\n  })();\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link_node_modules.js","sourceRoot":"","sources":["../../../../../internal/linker/link_node_modules.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;IAAA;;;;OAIG;IACH,yBAAyB;IACzB,6BAA6B;IAE7B,gEAAgE;IAChE,MAAM,YAAY,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAEnD,SAAS,WAAW,CAAC,GAAG,CAAW;QACjC,IAAI,YAAY;YAAE,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,SAAS,KAAK,CAAC,CAAS;QACtB,MAAM,IAAI,KAAK,CAAC;;;;;;IAMd,CAAC;GACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,SAAS,MAAM,CAAC,CAAS;QACvB,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;YACrB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACxB,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SACjB;IACH,CAAC;IAED,SAAe,OAAO,CAAC,MAAc,EAAE,IAAY;;YACjD,WAAW,CAAC,YAAY,IAAI,OAAO,MAAM,IAAI,CAAC,CAAC;YAC/C,uEAAuE;YACvE,wDAAwD;YACxD,IAAI;gBACF,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;aACrD;YAAC,OAAO,CAAC,EAAE;gBACV,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE;oBACvB,MAAM,CAAC,CAAC;iBACT;gBACD,wEAAwE;gBACxE,2EAA2E;gBAC3E,4EAA4E;aAC7E;YAED,IAAI,YAAY,EAAE;gBAChB,0CAA0C;gBAC1C,2EAA2E;gBAC3E,wBAAwB;gBACxB,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;oBACxB,WAAW,CACP,kDAAkD;wBAClD,WAAW,OAAO,CAAC,GAAG,EAAE,cAAc,MAAM,YAAY,IAAI,OAAO,CAAC,CAAC;iBAC1E;aACF;QACH,CAAC;KAAA;IAED;;;;OAIG;IACH,SAAS,WAAW,CAAC,IAAsB,EAAE,QAAkB;QAC7D,6CAA6C;QAC7C,kEAAkE;QAClE,IAAI,CAAC,IAAI,EAAE;YACT,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;gBAClC,WAAW,CAAC,iDAAiD,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;gBAC9E,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;aAC9B;YACD,OAAO,cAAc,CAAC;SACvB;QAED,qEAAqE;QACrE,yEAAyE;QACzE,wCAAwC;QACxC,MAAM,YAAY,GAAG,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,YAAY;YAAE,OAAO,YAAY,CAAC;QAEtC,+CAA+C;QAC/C,sDAAsD;QACtD,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,EAAE;YAC9C,WAAW,CAAC,mDAAmD,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;YAC9F,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;SACpC;QAED,6DAA6D;QAC7D,wFAAwF;QACxF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,MAAa,QAAQ;QASnB,YAAY,GAAuB;YACjC,4DAA4D;YAC5D,uBAAuB;YACvB,mEAAmE;YACnE,gEAAgE;YAChE,sEAAsE;YACtE,yDAAyD;YACzD,IAAI,CAAC,CAAC,GAAG,CAAC,wBAAwB,CAAC,EAAE;gBACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,wBAAwB,CAAE,CAAC,CAAC;aAC3E;iBAAM,IAAI,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE;gBAChC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAE,CAAC,CAAC;aAC/C;iBAAM;gBACL,KAAK,CACD,8GAA8G,CAAC,CAAC;aACrH;YACD,uDAAuD;YACvD,uCAAuC;YACvC,iEAAiE;YACjE,SAAS;YACT,IAAI,GAAG,CAAC,wBAAwB,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,wBAAwB,CAAC,EAAE;gBAC3E,WAAW,CAAC;;;;kEAIgD,CAAC,CAAC;aAC/D;YAED,MAAM,IAAI,GAAG,GAAG,CAAC,gBAAgB,CAAC,CAAC;YACnC,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,CAAC;YAClC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,EAAE;gBACtB,gCAAgC;gBAChC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;aAC/C;QACH,CAAC;QAED,eAAe,CAAC,GAAW;YACzB,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO,SAAS,CAAC;YAErC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE;gBAClC,+CAA+C;gBAC/C,2DAA2D;gBAC3D,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,GAAG,WAAW,CAAC;oBAAE,SAAS;gBAE9C,mBAAmB;gBACnB,qCAAqC;gBACrC,uDAAuD;gBACvD,0CAA0C;gBAC1C,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBACrB,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;oBAChC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;iBACrC;aACF;QACH,CAAC;QAGD;;;;;;;;WAQG;QACH,oBAAoB,CAAC,YAAoB;YACvC,WAAW,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;YAEvD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAC;YAEjE,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;gBACpC,IAAI,CAAC,IAAI;oBAAE,SAAS;gBACpB,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACjD,eAAe,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;aAC7C;YAED,OAAO,eAAe,CAAC;QACzB,CAAC;QAED,OAAO,CAAC,UAAkB;YACxB,6BAA6B;YAC7B,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACjB,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;aACzC;YACD,IAAI,gBAAQ,CAAC,GAAG,EAAE;gBAChB,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAQ,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;aAC5C;YACD,MAAM,IAAI,KAAK,CAAC,gCAAgC,UAAU,EAAE,CAAC,CAAC;QAChE,CAAC;QAED,sBAAsB,CAAC,UAAkB;YACvC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACrB,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;aAC7E;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;QACrE,CAAC;KACF;IA1GD,4BA0GC;IASD,kDAAkD;IAClD,0EAA0E;IAC1E,SAAe,MAAM,CAAC,CAAS;;YAC7B,IAAI;gBACF,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;gBACzB,OAAO,IAAI,CAAC;aACb;YAAC,OAAO,CAAC,EAAE;gBACV,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE;oBACvB,OAAO,KAAK,CAAC;iBACd;gBACD,MAAM,CAAC,CAAC;aACT;QACH,CAAC;KAAA;IAUD,SAAsB,IAAI,CAAC,IAAc,EAAE,QAAkB;;YAC3D,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;gBAC1B,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;YAEtF,MAAM,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;YAC/B,IAAI,EAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC;YACnF,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;YACxB,WAAW,CACP,8BAA8B,SAAS,SAAS,GAAG,UAC/C,IAAI,8BAA8B,EACtC,OAAO,CAAC,CAAC;YAEb,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YAC5C,WAAW,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;YAElD,iDAAiD;YACjD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAEvC,6BAA6B;YAC7B,oDAAoD;YACpD,mBAAmB;YACnB,mDAAmD;YACnD,SAAS,cAAc,CAAC,CAAS;gBAC/B,IAAI,CAAC,KAAK,SAAS,EAAE;oBACnB,OAAO,GAAG,CAAC;iBACZ;gBACD,8DAA8D;gBAC9D,IAAI,CAAC,CAAC,UAAU,CAAC,SAAS,GAAG,GAAG,CAAC,EAAE;oBACjC,OAAO,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;iBAC1C;gBACD,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;YAClC,CAAC;YAED,qEAAqE;YACrE,MAAM,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YACvC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAEvB,8EAA8E;YAC9E,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAEhD,kGAAkG;YAClG,MAAM,KAAK,GAAG,EAAE,CAAC;YAEjB,MAAM,UAAU,GACZ,CAAO,IAAY,EAAE,IAAgB,EAAE,UAAkB,EAAE,EAAE;gBAC/D,IAAI,MAAM,GAAW,0BAA0B,CAAC;gBAChD,QAAQ,IAAI,EAAE;oBACZ,KAAK,KAAK;wBACR,eAAe;wBACf,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;wBAClE,6DAA6D;wBAC7D,IAAI,CAAC,CAAA,MAAM,MAAM,CAAC,MAAM,CAAC,CAAA,EAAE;4BACzB,2DAA2D;4BAC3D,iEAAiE;4BACjE,0CAA0C;4BAC1C,sCAAsC;4BACtC,OAAO,OAAO,CAAC,MAAM,CAAC,gDAAgD,UAAU;;;mDAGvC,CAAC,CAAC;yBAC5C;wBACD,MAAM;oBACR,KAAK,KAAK;wBACR,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;wBAC7D,MAAM;oBACR,KAAK,UAAU;wBACb,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,8BAA8B,CAAC;wBACxE,MAAM;iBACT;gBAED,MAAM,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC9B,CAAC,CAAA,CAAA;YAED,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBACpC,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;oBACvB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,iEAAiE,CAAC,CAAC;iBAC/F;gBACD,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE;oBACxB,0BAA0B;oBAC1B,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;iBACrB;gBACD,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBACtC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;aAC7C;YAED,IAAI,IAAI,GAAG,CAAC,CAAC;YACb,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;gBACjC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACjB,IAAI,GAAG,CAAC,CAAC;YACX,CAAC,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC;QACd,CAAC;KAAA;IA7FD,oBA6FC;IAEY,QAAA,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAElD,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;QAC3B,CAAC,GAAS,EAAE;YACV,OAAO,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,gBAAQ,CAAC,CAAC;QACjE,CAAC,CAAA,CAAC,EAAE,CAAC;KACN","sourcesContent":["/**\n * @fileoverview Creates a node_modules directory in the current working directory\n * and symlinks in the node modules needed to run a program.\n * This replaces the need for custom module resolution logic inside the process.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n// Run Bazel with --define=VERBOSE_LOGS=1 to enable this logging\nconst VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];\n\nfunction log_verbose(...m: string[]) {\n  if (VERBOSE_LOGS) console.error('[link_node_modules.js]', ...m);\n}\n\nfunction panic(m: string) {\n  throw new Error(`Internal error! Please run again with\n   --define=VERBOSE_LOG=1\nand file an issue: https://github.com/bazelbuild/rules_nodejs/issues/new?template=bug_report.md\nInclude as much of the build output as you can without disclosing anything confidential.\n\n  Error:\n  ${m}\n  `);\n}\n\n/**\n * Create a new directory and any necessary subdirectories\n * if they do not exist.\n */\nfunction mkdirp(p: string) {\n  if (!fs.existsSync(p)) {\n    mkdirp(path.dirname(p));\n    fs.mkdirSync(p);\n  }\n}\n\nasync function symlink(target: string, path: string) {\n  log_verbose(`symlink( ${path} -> ${target} )`);\n  // Use junction on Windows since symlinks require elevated permissions.\n  // We only link to directories so junctions work for us.\n  try {\n    await fs.promises.symlink(target, path, 'junction');\n  } catch (e) {\n    if (e.code !== 'EEXIST') {\n      throw e;\n    }\n    // We assume here that the path is already linked to the correct target.\n    // Could add some logic that asserts it here, but we want to avoid an extra\n    // filesystem access so we should only do it under some kind of strict mode.\n  }\n\n  if (VERBOSE_LOGS) {\n    // Be verbose about creating a bad symlink\n    // Maybe this should fail in production as well, but again we want to avoid\n    // any unneeded file I/O\n    if (!fs.existsSync(path)) {\n      log_verbose(\n          'ERROR\\n***\\nLooks like we created a bad symlink:' +\n          `\\n  pwd ${process.cwd()}\\n  target ${target}\\n  path ${path}\\n***`);\n    }\n  }\n}\n\n/**\n * Resolve a root directory string to the actual location on disk\n * where node_modules was installed\n * @param root a string like 'npm/node_modules'\n */\nfunction resolveRoot(root: string|undefined, runfiles: Runfiles) {\n  // create a node_modules directory if no root\n  // this will be the case if only first-party modules are installed\n  if (!root) {\n    if (!fs.existsSync('node_modules')) {\n      log_verbose('no third-party packages; mkdir node_modules in ', process.cwd());\n      fs.mkdirSync('node_modules');\n    }\n    return 'node_modules';\n  }\n\n  // If we got a runfilesManifest map, look through it for a resolution\n  // This will happen if we are running a binary that had some npm packages\n  // \"statically linked\" into its runfiles\n  const fromManifest = runfiles.lookupDirectory(root);\n  if (fromManifest) return fromManifest;\n\n  // Account for Bazel --legacy_external_runfiles\n  // which look like 'my_wksp/external/npm/node_modules'\n  if (fs.existsSync(path.join('external', root))) {\n    log_verbose('Found legacy_external_runfiles, switching root to', path.join('external', root));\n    return path.join('external', root);\n  }\n\n  // The repository should be layed out in the parent directory\n  // since bazel sets our working directory to the repository where the build is happening\n  return path.join('..', root);\n}\n\nexport class Runfiles {\n  manifest: Map<string, string>|undefined;\n  dir: string|undefined;\n  /**\n   * If the environment gives us enough hints, we can know the path to the package\n   * in the form workspace_name/path/to/package\n   */\n  packagePath: string|undefined;\n\n  constructor(env: typeof process.env) {\n    // If Bazel sets a variable pointing to a runfiles manifest,\n    // we'll always use it.\n    // Note that this has a slight performance implication on Mac/Linux\n    // where we could use the runfiles tree already laid out on disk\n    // but this just costs one file read for the external npm/node_modules\n    // and one for each first-party module, not one per file.\n    if (!!env['RUNFILES_MANIFEST_FILE']) {\n      this.manifest = this.loadRunfilesManifest(env['RUNFILES_MANIFEST_FILE']!);\n    } else if (!!env['RUNFILES_DIR']) {\n      this.dir = path.resolve(env['RUNFILES_DIR']!);\n    } else {\n      panic(\n          'Every node program run under Bazel must have a $RUNFILES_DIR or $RUNFILES_MANIFEST_FILE environment variable');\n    }\n    // Under --noenable_runfiles (in particular on Windows)\n    // Bazel sets RUNFILES_MANIFEST_ONLY=1.\n    // When this happens, we need to read the manifest file to locate\n    // inputs\n    if (env['RUNFILES_MANIFEST_ONLY'] === '1' && !env['RUNFILES_MANIFEST_FILE']) {\n      log_verbose(`Workaround https://github.com/bazelbuild/bazel/issues/7994\n                 RUNFILES_MANIFEST_FILE should have been set but wasn't.\n                 falling back to using runfiles symlinks.\n                 If you want to test runfiles manifest behavior, add\n                 --spawn_strategy=standalone to the command line.`);\n    }\n\n    const wksp = env['TEST_WORKSPACE'];\n    const target = env['TEST_TARGET'];\n    if (!!wksp && !!target) {\n      // //path/to:target -> //path/to\n      const pkg = target.split(':')[0];\n      this.packagePath = path.posix.join(wksp, pkg);\n    }\n  }\n\n  lookupDirectory(dir: string): string|undefined {\n    if (!this.manifest) return undefined;\n\n    for (const [k, v] of this.manifest) {\n      // Account for Bazel --legacy_external_runfiles\n      // which pollutes the workspace with 'my_wksp/external/...'\n      if (k.startsWith(`${dir}/external`)) continue;\n\n      // Entry looks like\n      // k: npm/node_modules/semver/LICENSE\n      // v: /path/to/external/npm/node_modules/semver/LICENSE\n      // calculate l = length(`/semver/LICENSE`)\n      if (k.startsWith(dir)) {\n        const l = k.length - dir.length;\n        return v.substring(0, v.length - l);\n      }\n    }\n  }\n\n\n  /**\n   * The runfiles manifest maps from short_path\n   * https://docs.bazel.build/versions/master/skylark/lib/File.html#short_path\n   * to the actual location on disk where the file can be read.\n   *\n   * In a sandboxed execution, it does not exist. In that case, runfiles must be\n   * resolved from a symlink tree under the runfiles dir.\n   * See https://github.com/bazelbuild/bazel/issues/3726\n   */\n  loadRunfilesManifest(manifestPath: string) {\n    log_verbose(`using runfiles manifest ${manifestPath}`);\n\n    const runfilesEntries = new Map();\n    const input = fs.readFileSync(manifestPath, {encoding: 'utf-8'});\n\n    for (const line of input.split('\\n')) {\n      if (!line) continue;\n      const [runfilesPath, realPath] = line.split(' ');\n      runfilesEntries.set(runfilesPath, realPath);\n    }\n\n    return runfilesEntries;\n  }\n\n  resolve(modulePath: string) {\n    // Look in the runfiles first\n    if (this.manifest) {\n      return this.lookupDirectory(modulePath);\n    }\n    if (runfiles.dir) {\n      return path.join(runfiles.dir, modulePath);\n    }\n    throw new Error(`could not resolve modulePath ${modulePath}`);\n  }\n\n  resolvePackageRelative(modulePath: string) {\n    if (!this.packagePath) {\n      throw new Error('packagePath could not be determined from the environment');\n    }\n    return this.resolve(path.posix.join(this.packagePath, modulePath));\n  }\n}\n\n// TypeScript lib.es5.d.ts has a mistake: JSON.parse does accept Buffer.\ndeclare global {\n  interface JSON {\n    parse(b: {toString: () => string}): any;\n  }\n}\n\n// There is no fs.promises.exists function because\n// node core is of the opinion that exists is always too racey to rely on.\nasync function exists(p: string) {\n  try {\n    await fs.promises.stat(p)\n    return true;\n  } catch (e) {\n    if (e.code === 'ENOENT') {\n      return false;\n    }\n    throw e;\n  }\n}\n\n// See link_node_modules.bzl where these three strings\n// are used to indicate which root the linker should target\n// for each package:\n// bin: bazel-bin/path/to/package\n// src: workspace/path/to/package\n// runfiles: look in the runfiles dir/manifest\ntype LinkerRoot = 'bin'|'src'|'runfiles';\n\nexport async function main(args: string[], runfiles: Runfiles) {\n  if (!args || args.length < 1)\n    throw new Error('link_node_modules.js requires one argument: modulesManifest path');\n\n  const [modulesManifest] = args;\n  let {bin, root, modules, workspace} = JSON.parse(fs.readFileSync(modulesManifest));\n  modules = modules || {};\n  log_verbose(\n      `module manifest: workspace ${workspace}, bin ${bin}, root ${\n          root} with first-party packages\\n`,\n      modules);\n\n  const rootDir = resolveRoot(root, runfiles);\n  log_verbose('resolved root', root, 'to', rootDir);\n\n  // Bazel starts actions with pwd=execroot/my_wksp\n  const workspaceDir = path.resolve('.');\n\n  // Convert from runfiles path\n  // this_wksp/path/to/file OR other_wksp/path/to/file\n  // to execroot path\n  // path/to/file OR external/other_wksp/path/to/file\n  function toWorkspaceDir(p: string) {\n    if (p === workspace) {\n      return '.';\n    }\n    // The manifest is written with forward slash on all platforms\n    if (p.startsWith(workspace + '/')) {\n      return p.substring(workspace.length + 1);\n    }\n    return path.join('external', p);\n  }\n\n  // Create the $pwd/node_modules directory that node will resolve from\n  await symlink(rootDir, 'node_modules');\n  process.chdir(rootDir);\n\n  // Symlinks to packages need to reach back to the workspace/runfiles directory\n  const workspaceAbs = path.resolve(workspaceDir);\n\n  // Now add symlinks to each of our first-party packages so they appear under the node_modules tree\n  const links = [];\n\n  const linkModule =\n      async (name: string, root: LinkerRoot, modulePath: string) => {\n    let target: string = '<package linking failed>';\n    switch (root) {\n      case 'bin':\n        // FIXME(#1196)\n        target = path.join(workspaceAbs, bin, toWorkspaceDir(modulePath));\n        // Spend an extra FS lookup to give better error in this case\n        if (!await exists(target)) {\n          // TODO: there should be some docs explaining how users are\n          // expected to declare ahead of time where the package is loaded,\n          // how that relates to npm link scenarios,\n          // and where the configuration can go.\n          return Promise.reject(`ERROR: no output directory found for package ${modulePath}\n        Did you mean to declare this as a from-source package?\n        See https://github.com/bazelbuild/rules_nodejs/pull/1197\n        until this feature is properly documented.`);\n        }\n        break;\n      case 'src':\n        target = path.join(workspaceAbs, toWorkspaceDir(modulePath));\n        break;\n      case 'runfiles':\n        target = runfiles.resolve(modulePath) || '<runfiles resolution failed>';\n        break;\n    }\n\n    await symlink(target, name);\n  }\n\n  for (const m of Object.keys(modules)) {\n    const segments = m.split('/');\n    if (segments.length > 2) {\n      throw new Error(`module ${m} has more than 2 segments which is not a valid node module name`);\n    }\n    if (segments.length == 2) {\n      // ensure the scope exists\n      mkdirp(segments[0]);\n    }\n    const [kind, modulePath] = modules[m];\n    links.push(linkModule(m, kind, modulePath));\n  }\n\n  let code = 0;\n  await Promise.all(links).catch(e => {\n    console.error(e);\n    code = 1;\n  });\n\n  return code;\n}\n\nexport const runfiles = new Runfiles(process.env);\n\nif (require.main === module) {\n  (async () => {\n    process.exitCode = await main(process.argv.slice(2), runfiles);\n  })();\n}\n"]} \ No newline at end of file diff --git a/internal/linker/link_node_modules.ts b/internal/linker/link_node_modules.ts index 60d106d19b..db5ea65774 100644 --- a/internal/linker/link_node_modules.ts +++ b/internal/linker/link_node_modules.ts @@ -24,6 +24,17 @@ Include as much of the build output as you can without disclosing anything confi `); } +/** + * Create a new directory and any necessary subdirectories + * if they do not exist. + */ +function mkdirp(p: string) { + if (!fs.existsSync(p)) { + mkdirp(path.dirname(p)); + fs.mkdirSync(p); + } +} + async function symlink(target: string, path: string) { log_verbose(`symlink( ${path} -> ${target} )`); // Use junction on Windows since symlinks require elevated permissions. @@ -46,7 +57,7 @@ async function symlink(target: string, path: string) { if (!fs.existsSync(path)) { log_verbose( 'ERROR\n***\nLooks like we created a bad symlink:' + - `\n pwd ${process.cwd()}\n target ${target}\n***`); + `\n pwd ${process.cwd()}\n target ${target}\n path ${path}\n***`); } } } @@ -179,8 +190,6 @@ export class Runfiles { if (this.manifest) { return this.lookupDirectory(modulePath); } - // how can we avoid this FS lookup every time? we don't know when process.cwd changed... - // const runfilesRelative = runfiles.dir ? path.relative('.', runfiles.dir) : undefined; if (runfiles.dir) { return path.join(runfiles.dir, modulePath); } @@ -262,7 +271,7 @@ export async function main(args: string[], runfiles: Runfiles) { process.chdir(rootDir); // Symlinks to packages need to reach back to the workspace/runfiles directory - const workspaceRelative = path.relative('.', workspaceDir); + const workspaceAbs = path.resolve(workspaceDir); // Now add symlinks to each of our first-party packages so they appear under the node_modules tree const links = []; @@ -273,7 +282,7 @@ export async function main(args: string[], runfiles: Runfiles) { switch (root) { case 'bin': // FIXME(#1196) - target = path.join(workspaceRelative, bin, toWorkspaceDir(modulePath)); + target = path.join(workspaceAbs, bin, toWorkspaceDir(modulePath)); // Spend an extra FS lookup to give better error in this case if (!await exists(target)) { // TODO: there should be some docs explaining how users are @@ -287,7 +296,7 @@ export async function main(args: string[], runfiles: Runfiles) { } break; case 'src': - target = path.join(workspaceRelative, toWorkspaceDir(modulePath)); + target = path.join(workspaceAbs, toWorkspaceDir(modulePath)); break; case 'runfiles': target = runfiles.resolve(modulePath) || ''; @@ -298,6 +307,14 @@ export async function main(args: string[], runfiles: Runfiles) { } for (const m of Object.keys(modules)) { + const segments = m.split('/'); + if (segments.length > 2) { + throw new Error(`module ${m} has more than 2 segments which is not a valid node module name`); + } + if (segments.length == 2) { + // ensure the scope exists + mkdirp(segments[0]); + } const [kind, modulePath] = modules[m]; links.push(linkModule(m, kind, modulePath)); } diff --git a/internal/linker/test/integration/BUILD.bazel b/internal/linker/test/integration/BUILD.bazel index f154e01c80..91ab65d977 100644 --- a/internal/linker/test/integration/BUILD.bazel +++ b/internal/linker/test/integration/BUILD.bazel @@ -21,6 +21,7 @@ sh_binary( ":program.js", "//internal/linker:index.js", "//internal/linker/test/integration/static_linked_pkg", + "//internal/linker/test/integration/static_linked_scoped_pkg", "@bazel_tools//tools/bash/runfiles", "@build_bazel_rules_nodejs//toolchains/node:node_bin", ], @@ -35,6 +36,7 @@ linked( "//%s/absolute_import:index.js" % package_name(), ":run_program", "//internal/linker/test/integration/dynamic_linked_pkg", + "//internal/linker/test/integration/dynamic_linked_scoped_pkg", "@npm//semver", ], ) diff --git a/internal/linker/test/integration/dynamic_linked_scoped_pkg/BUILD.bazel b/internal/linker/test/integration/dynamic_linked_scoped_pkg/BUILD.bazel new file mode 100644 index 0000000000..6e863cfbb7 --- /dev/null +++ b/internal/linker/test/integration/dynamic_linked_scoped_pkg/BUILD.bazel @@ -0,0 +1,10 @@ +load("//internal/js_library:js_library.bzl", "js_library") + +package(default_visibility = ["//internal/linker/test:__subpackages__"]) + +js_library( + name = "dynamic_linked_scoped_pkg", + srcs = ["index.js"], + module_from_src = True, + module_name = "@linker_scoped/dynamic_linked", +) diff --git a/internal/linker/test/integration/dynamic_linked_scoped_pkg/index.js b/internal/linker/test/integration/dynamic_linked_scoped_pkg/index.js new file mode 100644 index 0000000000..a88998bdb3 --- /dev/null +++ b/internal/linker/test/integration/dynamic_linked_scoped_pkg/index.js @@ -0,0 +1,5 @@ +function addD(str) { + return `${str}_d`; +} + +exports.addD = addD; \ No newline at end of file diff --git a/internal/linker/test/integration/golden.txt b/internal/linker/test/integration/golden.txt index 7fa3bafab1..7f08382f13 100644 --- a/internal/linker/test/integration/golden.txt +++ b/internal/linker/test/integration/golden.txt @@ -1 +1 @@ -1.2.3_c_b_a +1.2.3_a_b_c_d_e diff --git a/internal/linker/test/integration/program.js b/internal/linker/test/integration/program.js index 3bce634a48..b802f8d2e2 100644 --- a/internal/linker/test/integration/program.js +++ b/internal/linker/test/integration/program.js @@ -1,9 +1,11 @@ -// First-party package from ./static_linked_pkg -// it should get resolved through runfiles +// First-party "static linked" packages +// they should get resolved through runfiles const a = require('static_linked'); -// First-party package from ./dynamic_linked_pkg -// it should get resolved from the execroot +const e = require('@linker_scoped/static_linked'); +// First-party "dynamic linked" packages +// they should get resolved from the execroot const b = require('dynamic_linked'); +const d = require('@linker_scoped/dynamic_linked'); // We've always supported `require('my_workspace')` for absolute imports like Google does it const c = require('build_bazel_rules_nodejs/internal/linker/test/integration/absolute_import'); @@ -11,4 +13,4 @@ const c = require('build_bazel_rules_nodejs/internal/linker/test/integration/abs const semver = require('semver'); // This output should match what's in the golden.txt file -console.log(a.addA(b.addB(c.addC(semver.clean(' =v1.2.3 '))))); +console.log(e.addE(d.addD(c.addC(b.addB(a.addA(semver.clean(' =v1.2.3 '))))))); diff --git a/internal/linker/test/integration/static_linked_scoped_pkg/BUILD.bazel b/internal/linker/test/integration/static_linked_scoped_pkg/BUILD.bazel new file mode 100644 index 0000000000..74a8741930 --- /dev/null +++ b/internal/linker/test/integration/static_linked_scoped_pkg/BUILD.bazel @@ -0,0 +1,9 @@ +load("//internal/js_library:js_library.bzl", "js_library") + +package(default_visibility = ["//internal/linker/test:__subpackages__"]) + +js_library( + name = "static_linked_scoped_pkg", + srcs = ["index.js"], + module_name = "@linker_scoped/static_linked", +) diff --git a/internal/linker/test/integration/static_linked_scoped_pkg/index.js b/internal/linker/test/integration/static_linked_scoped_pkg/index.js new file mode 100644 index 0000000000..37a64cb21b --- /dev/null +++ b/internal/linker/test/integration/static_linked_scoped_pkg/index.js @@ -0,0 +1,5 @@ +function addE(str) { + return `${str}_e`; +} + +exports.addE = addE; \ No newline at end of file