Please add support for pnpm

[justin808]

Originally from @mattp0123

Is your feature request related to a problem? Please describe.

If one uses pnpm...

When I run bin/rails generate react_on_rails:install, it says:

ERROR: yarn is required. Please install it before continuing. https://yarnpkg.com/en/docs/install
ERROR: react_on_rails generator prerequisites not met!

Describe the solution you'd like
Please add support for pnpm, it's a very powerful modern front-end tool.

[tomdracz]

Agree with this conceptually, needs to be generic and not just yarn, npm, pnpm. We shouldn't quite care what is the package manager/runner

[sharang-d]

Hey @Judahmeek, I see this was closed as completed but I can't find the relevant code or documentation. Can you point me to some?

[ahangarha]

@sharang-d I believe closing it as completed was a mistake. I changed the status to closed as not planned for now which is more appropriate. So we improve our focus on more important issues.

If you have an active use case for this, please let us know. We can open it up any time.

[sharang-d]

@ahangarha Got it, thanks.

We're moving to pnpm from yarn so I wanted to see if it works. We're redefining the rake tasks to use pnpm instead of yarn as it isn't supported but it'd be nice to have this gem support it directly.

[G-Rath]

If the idea is to try and support package managers in general (or at least "the big three"), it probably makes sense to update the title of this issue to reflect that, for visibility.

I personally support this, and would be very happy to help if folks are open to an iterative approach - I feel like the best path forward is probably to try and start with some "manual" conditional support, encapsulated into a class/module that could make sense to eventually publish into a dedicated gem for other libraries to use; from my personal experience dealing with supporting these packages managers, I've found the actual differences between them are easily handled in this sort of automation space.

Here's a straw man that I think could be a good approach to start with

class NotImplementedError < StandardError; end

class PackageManager
  # @param [PackageJson | nil] [package_json]
  def initialize(package_json = nil)
    # @type [PackageJson]
    @package_json = package_json
  end

  def install(opts = [])
    raise NotImplementedError
  end

  # @param [Array<String>] packages
  # @param [Symbol] type
  # @param [Array<String>] [opts]
  def add_and_install(packages, type = :production, opts = [])
    raise NotImplementedError
  end

  # @param [String] cmd
  # @param [Array<String>] args
  # @param [Array<String>] [opts]
  def run_script(cmd, args, opts = [])
    raise NotImplementedError
  end
end

class NpmPackageManager < PackageManager
  def install(opts = [])
    run(opts, "install", [])
  end

  def add_and_install(packages, type = :production, opts = [])
    if type == :peer
      add_peer_dependencies(packages)
      install(opts)

      return
    end

    run(opts, "install #{cmd}", [package_type_install_flag(type)] + packages)
  end

  def run_script(cmd, args, opts = [])
    run(opts, "run #{cmd} --", args)
  end

  private

  def run(opts, cmd, args)
    `npm #{opts.join(" ")} #{cmd} #{args.join(" ")}`
  end

  # @param [Array<String>] packages
  def add_peer_dependencies(packages)
    raise StandardError, "package.json is required for this" if @package_json.nil?

    @package_json.modify do |package_json|
      peer_dependencies = package_json.fetch("peerDependencies", {})

      packages.each do |pkg|
        scoped = pkg.start_with?("@")

        pkg = pkg.delete_prefix("@")
        pkg, version = pkg.split("@")

        version = "*" unless version
        pkg = "@#{pkg}" if scoped

        peer_dependencies[pkg] = version
      end

      package_json["peerDependencies"] = peer_dependencies
    end
  end

  def package_type_install_flag(type)
    case type
    when :production
      return "--save-prod"
    when :dev
      return "--save-dev"
    when :optional
      return "--save-optional"
    else
      raise StandardError, "unsupported package install type \"#{type}\""
    end
  end
end

class YarnPackageManager
  def install(opts = [])
    run(opts, "install", [])
  end

  def add_and_install(packages, type = :production, opts = [])
    run(opts, "add #{cmd}", [package_type_install_flag(type)] + packages)
  end

  def run_script(cmd, args, opts = [])
    run(opts, "run #{cmd}", args)
  end

  private

  def run(opts, cmd, args)
    `yarn #{opts.join(" ")} #{cmd} #{args.join(" ")}`
  end

  def package_type_install_flag(type)
    case type
    when :production
      return ""
    when :dev
      return "--dev"
    when :peer
      return "--peer"
    when :optional
      return "--optional"
    else
      raise StandardError, "unsupported package install type \"#{type}\""
    end
  end
end

class PnpmPackageManager
  def install(opts = [])
    run(opts, "install", [])
  end

  def add_and_install(packages, type = :production, opts = [])
    run(opts, "add #{cmd}", [package_type_install_flag(type)] + packages)
  end

  def run_script(cmd, args, opts = [])
    run(opts, "run #{cmd} --", args)
  end

  private

  def run(opts, cmd, args)
    `pnpm #{opts.join(" ")} #{cmd} #{args.join(" ")}`
  end

  def package_type_install_flag(type)
    case type
    when :production
      return "--save-prod"
    when :dev
      return "--save-dev"
    when :peer
      return "--save-peer"
    when :optional
      return "--save-optional"
    else
      raise StandardError, "unsupported package install type \"#{type}\""
    end
  end
end

class PackageJson
  # @return [PackageManager]
  attr_reader :manager

  def initialize(path_to_package_json, package_manager = nil)
    @path = path_to_package_json

    package_manager = determine_package_manager if package_manager.nil?

    use_package_manager(package_manager)
  end

  def use_package_manager(package_manager_name)
    case package_manager_name
    when :npm
      @manager = NpmPackageManager.new
    when :yarn
      @manager = YarnPackageManager.new
    when :pnpm
      @manager = PnpmPackageManager.new
    else
      raise StandardError, "unsupported package manager \"#{package_manager_name}\""
    end
  end

  def modify
    write_package_json(yield read_package_json)
  end

  private

  def read_package_json
    JSON.parse(File.read(@path))
  end

  def write_package_json(content)
    File.write(@path, JSON.pretty_generate(content))
  end

  def determine_package_manager
    read_package_json.fetch("packageManager", nil)&.to_sym
  end
end

package_json = PackageJson.new("package.json", :yarn)
package_json.manager.add_and_install(
  %w[
    eslint-plugin-react
    eslint-plugin-react-hooks
    eslint-plugin-jsx-a11y
    eslint-plugin-jest
    eslint-plugin-jest-formatting
    eslint-plugin-jest-dom
    eslint-plugin-testing-library
  ],
  :dev
)

[willemorvets]

I can take a shot at this... if that brings joy 🙂.

[ahangarha]

@willemorvets Why not? 🙂

[G-Rath]

I'm working on a thing for this - hoping to have something to show in the next couple of days