Properly handle Yarn2 PnP

[mufasa71]

How to properly setup Yarn2 PnP config? Just curious if I am doing it correctly or there are some better ways to do this? If feel this is verbose and a lot of repetition:

local is_pnp = vim.fn.findfile(".pnp.cjs", ".")
local eslint_diag = null_ls.builtins.diagnostics.eslint
local eslint_action = null_ls.builtins.code_actions.eslint

if (is_pnp) then
  eslint_diag = null_ls.builtins.diagnostics.eslint.with({
    dynamic_command = command_resolver.from_yarn_pnp()
  })
  eslint_action = null_ls.code_actions.eslint.with({
    dynamic_command = command_resolver.from_yarn_pnp()
  })
end

null_ls.setup({
  sources = {
    eslint_diag,
    eslint_action,
    -- More config here
  }
})

[jose-elias-alvarez]

Theoretically from_yarn_pnp should fall back to a global executable if it fails to find one locally - is that not the case? If not, could you open an issue?

Either way, you could write a wrapper to make this a bit easier:

-- this part is theoretically unnecessary, but I'm keeping it as an example
local is_pnp = vim.fn.findfile(".pnp.cjs", ".")

local with_yarn_pnp = function(source)
    return source.with({
        dynamic_command = is_pnp and command_resolver.from_yarn_pnp() or nil,
    })
end

null_ls.setup({
  sources = {
    with_yarn_pnp(null_ls.builtins.diagnostics.eslint),
  }
})

[mufasa71]

Just curious why is this line local is_pnp = vim.fn.findfile(".pnp.cjs", ".") theoretically unnecessary? In case of Yarn 2 PnP true it goes to global, but when switching to project which don't support yarn 2 but rather yarn 1 or npm, this strategy will fail apparently. It obviously we need to write fallback to it, not always to global. What is comes to my mind is:

-- this part is theoretically unnecessary, but I'm keeping it as an example
local is_pnp = vim.fn.findfile(".pnp.cjs", ".")
local is_yarn = vim.fn.findfile("yarn.lock", ".")
local is_npm = vim.fn.findfile("package-lock.json", ".")

local with_dynamic_command = function(source)
    if is_yarn and is_pnp then
      return source.with({
          dynamic_command = command_resolver.from_yarn_pnp(),
      })
   end

   if is_npm or is_yarn then
      return source.with({
          dynamic_command = command_resolver.from_node_modules(),
      })
   end

  return source
end

null_ls.setup({
  sources = {
    with_dynamic_command(null_ls.builtins.diagnostics.eslint),
  }
})

[jose-elias-alvarez]

I see, you want it to fall back to node_modules if you're not a Yarn PnP-enabled project.

In that case: depending on the built-in, it may already be configured to use the from_node_modules resolver (see ESLint) so it should be enough to use the logic I originally posted, which leaves dynamic_command as nil if you're not in a Yarn v2+ project. If you want to be explicit, your logic also seems fine.

[mufasa71]

Nice thank you! 🙂

P.S. For people looking for another approach, take a look on volta which automatically resolves which package manager should be used (included PnP). After that there is no need to explicitly define dynamic_command