vite_rails 1.0.0

data/lib/vite_rails/config.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Public: Allows to resolve configuration sourced from `config/vite.json` and
+# environment variables, combining them with the default options.
+class ViteRails::Config
+  delegate :as_json, :inspect, to: :@config
+
+  def initialize(config)
+    @config = config.tap { coerce_values(config) }.freeze
+
+    config.each_key do |option|
+      define_singleton_method(option) { @config[option] }
+    end
+  end
+
+  def protocol
+    https ? 'https' : 'http'
+  end
+
+  def host_with_port
+    "#{ host }:#{ port }"
+  end
+
+  # Internal: Path where Vite outputs the manifest file.
+  def manifest_path
+    build_output_dir.join('manifest.json')
+  end
+
+  # Public: The directory where Vite will store the built assets.
+  def build_output_dir
+    public_dir.join(public_output_dir)
+  end
+
+private
+
+  # Internal: Coerces all the configuration values, in case they were passed
+  # as environment variables which are always strings.
+  def coerce_values(config)
+    coerce_booleans(config, 'auto_build', 'https')
+    coerce_paths(config, 'assets_dir', 'build_cache_dir', 'config_path', 'public_dir', 'source_code_dir', 'public_output_dir', 'root')
+    config['port'] = config['port'].to_i
+    config['root'] ||= Rails.root
+  end
+
+  # Internal: Coerces configuration options to boolean.
+  def coerce_booleans(config, *names)
+    names.each { |name| config[name] = [true, 'true'].include?(config[name]) }
+  end
+
+  # Internal: Converts configuration options to pathname.
+  def coerce_paths(config, *names)
+    names.each { |name| config[name] = Pathname.new(config[name]) unless config[name].nil? }
+  end
+
+  class << self
+    # Public: Returns the project configuration for Vite.
+    def resolve_config
+      new DEFAULT_CONFIG.merge(config_from_file).merge(config_from_env)
+    rescue Errno::ENOENT => error
+      warn "Check that your vite.json configuration file is available in the load path. #{ error.message }"
+      new DEFAULT_CONFIG.merge(config_from_env)
+    end
+
+  private
+
+    # Internal: Used to load a JSON file from the specified path.
+    def load_json(path)
+      JSON.parse(File.read(File.expand_path(path))).deep_transform_keys(&:underscore)
+    rescue => error
+      (require 'pry-byebug';binding.pry;);
+    end
+
+    # Internal: Retrieves a configuration option from environment variables.
+    def config_option_from_env(name)
+      ENV["#{ ViteRails::ENV_PREFIX }_#{ name.upcase }"]
+    end
+
+    # Internal: Extracts the configuration options provided as env vars.
+    def config_from_env
+      CONFIGURABLE_WITH_ENV.each_with_object({}) do |key, env_vars|
+        if value = config_option_from_env(key)
+          env_vars[key] = value
+        end
+      end.merge(mode: vite_mode)
+    end
+
+    # Internal: The mode Vite should run on.
+    def vite_mode
+      config_option_from_env('mode') || Rails.env.to_s
+    end
+
+    # Internal: Loads the configuration options provided in a JSON file.
+    def config_from_file
+      path = config_option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path')
+      multi_env_config = load_json(path)
+      multi_env_config.fetch('all', {})
+        .merge(multi_env_config.fetch(vite_mode, {}))
+    end
+  end
+
+  # Internal: Shared configuration with the Vite plugin for Ruby.
+  DEFAULT_CONFIG = load_json("#{ __dir__ }/../../package/default.vite.json").freeze
+
+  # Internal: Configuration options that can be provided as env vars.
+  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + ['root']).freeze
+end

data/lib/vite_rails/dev_server.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Public: Allows to verify if a Vite development server is already running.
+class ViteRails::DevServer
+  # Public: Configure dev server connection timeout (in seconds).
+  # Example:
+  #   ViteRails.dev_server.connect_timeout = 1
+  cattr_accessor(:connect_timeout) { 0.01 }
+
+  def initialize(config)
+    @config = config
+  end
+
+  # Public: Returns true if the Vite development server is reachable.
+  def running?
+    Socket.tcp(host, port, connect_timeout: connect_timeout).close
+    true
+  rescue StandardError
+    false
+  end
+
+  delegate :host, :port, to: :@config
+end

data/lib/vite_rails/dev_server_proxy.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rack/proxy'
+
+# Public: Allows to relay asset requests to the Vite development server.
+class ViteRails::DevServerProxy < Rack::Proxy
+  VITE_DEPENDENCY_PREFIX = '/@'
+
+  def initialize(app = nil, options = {})
+    @vite_rails = options.delete(:vite_rails) || ViteRails.instance
+    options[:streaming] = false if Rails.env.test? && !options.key?(:streaming)
+    super
+  end
+
+  # Rack: Intercept asset requests and send them to the Vite server.
+  def perform_request(env)
+    if vite_should_handle?(env['REQUEST_URI']) && dev_server.running?
+      env['REQUEST_URI'] = env['REQUEST_URI']
+        .sub(vite_asset_url_prefix, '/')
+        .sub('.ts.js', '.ts') # Patch: Rails helpers always append the extension.
+      env['PATH_INFO'], env['QUERY_STRING'] = env['REQUEST_URI'].split('?')
+
+      env['HTTP_HOST'] = env['HTTP_X_FORWARDED_HOST'] = config.host
+      env['HTTP_X_FORWARDED_SERVER'] = config.host_with_port
+      env['HTTP_PORT'] = env['HTTP_X_FORWARDED_PORT'] = config.port.to_s
+      env['HTTP_X_FORWARDED_PROTO'] = env['HTTP_X_FORWARDED_SCHEME'] = config.protocol
+      env['HTTPS'] = env['HTTP_X_FORWARDED_SSL'] = 'off' unless config.https
+      env['SCRIPT_NAME'] = ''
+      super(env)
+    else
+      @app.call(env)
+    end
+  end
+
+private
+
+  delegate :config, :dev_server, to: :@vite_rails
+
+  def vite_should_handle?(url)
+    url.start_with?(vite_asset_url_prefix) || url.start_with?(VITE_DEPENDENCY_PREFIX) ||
+      url.include?('?t=') # Direct Hot Reload
+  end
+
+  def vite_asset_url_prefix
+    @vite_asset_url_prefix ||= "/#{ config.public_output_dir }/"
+  end
+end

data/lib/vite_rails/engine.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+class ViteRails::Engine < Rails::Engine
+  initializer 'vite_rails.proxy' do |app|
+    app.middleware.insert_before 0, ViteRails::DevServerProxy, ssl_verify_none: true if ViteRails.run_proxy?
+  end
+
+  initializer 'vite_rails.helper' do
+    ActiveSupport.on_load(:action_controller) do
+      ActionController::Base.helper(ViteRails::Helper)
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      include ViteRails::Helper
+    end
+  end
+
+  initializer 'vite_rails.logger' do
+    config.after_initialize do
+      ViteRails.logger = if ::Rails.logger.respond_to?(:tagged)
+                           ::Rails.logger
+                         else
+                           ActiveSupport::TaggedLogging.new(::Rails.logger)
+                         end
+    end
+  end
+
+  initializer 'vite_rails.bootstrap' do
+    if defined?(Rails::Server) || defined?(Rails::Console)
+      ViteRails.bootstrap
+      if defined?(Spring)
+        require 'spring/watcher'
+        Spring.after_fork { ViteRails.bootstrap }
+        Spring.watch(ViteRails.config.config_path)
+      end
+    end
+  end
+end

data/lib/vite_rails/helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Public: Allows to render HTML tags for scripts and styles processed by Vite.
+module ViteRails::Helper
+  # Public: Returns the current Vite Rails instance.
+  def current_vite_instance
+    ViteRails.instance
+  end
+
+  # Public: Computes the relative path for the specified given Vite asset.
+  #
+  # Example:
+  #   <%= vite_asset_path 'calendar.css' %> # => "/vite/assets/calendar-1016838bab065ae1e122.css"
+  def vite_asset_path(name, **options)
+    current_vite_instance.manifest.lookup!(name, **options)
+  end
+
+  # Public: Renders a <script> tag for the specified Vite entrypoints.
+  def vite_javascript_tag(*names, type: 'module', **options)
+    javascript_include_tag(*sources_from_vite_manifest_entrypoints(names, type: :javascript), type: type, **options)
+  end
+
+  # Public: Renders a <script> tag for the specified Vite entrypoints.
+  #
+  # NOTE: Because TypeScript is not a valid target in browsers, we only specify
+  # the ts file when running the Vite development server.
+  def vite_typescript_tag(*names, type: 'module', **options)
+    javascript_include_tag(*sources_from_vite_manifest_entrypoints(names, type: :typescript), type: type, **options)
+  end
+
+  # Public: Renders a <link> tag for the specified Vite entrypoints.
+  def vite_stylesheet_tag(*names, **options)
+    stylesheet_link_tag(*sources_from_vite_manifest_entrypoints(names, type: :stylesheet), **options)
+  end
+
+private
+
+  def sources_from_vite_manifest_entrypoints(names, type:)
+    names.flat_map { |name| vite_asset_path(name, type: type) }.uniq
+  end
+end

data/lib/vite_rails/manifest.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Public: Registry for accessing resources managed by Vite, using a generated
+# manifest file which maps entrypoint names to file paths.
+#
+# Example:
+#   lookup_entrypoint('calendar', type: :javascript)
+#   => "/vite/assets/calendar-1016838bab065ae1e314.js"
+#
+# NOTE: Using "autoBuild": true` in `config/vite.json` file will trigger a build
+# on demand as needed, before performing any lookup.
+class ViteRails::Manifest
+  class MissingEntryError < StandardError
+  end
+
+  def initialize(vite_rails)
+    @vite_rails = vite_rails
+  end
+
+  # Public: Strict version of lookup.
+  #
+  # Returns a relative path for the asset, or raises an error if not found.
+  def lookup!(*args, **options)
+    lookup(*args, **options) || missing_entry_error(*args, **options)
+  end
+
+  # Public: Computes the path for a given Vite asset using manifest.json.
+  #
+  # Returns a relative path, or nil if the asset is not found.
+  #
+  # Example:
+  #   ViteRails.manifest.lookup('calendar.js') # => "/vite/assets/calendar-1016838bab065ae1e122.js"
+  def lookup(name, type:)
+    build if should_build?
+
+    find_manifest_entry(with_file_extension(name, type))
+  end
+
+  # Public: Refreshes the cached mappings by reading the updated manifest.
+  def refresh
+    @manifest = load_manifest
+  end
+
+private
+
+  delegate :config, :builder, :dev_server, to: :@vite_rails
+
+  # Public: Returns true if the Vite development server is running.
+  def dev_server_running?
+    ViteRails.run_proxy? && dev_server.running?
+  end
+
+  # NOTE: Auto compilation is convenient when running tests, when the developer
+  # won't focus on the frontend, or when running the Vite server is not desired.
+  def should_build?
+    config.auto_build && !dev_server_running?
+  end
+
+  # Internal: Finds the specified entry in the manifest.
+  def find_manifest_entry(name)
+    if dev_server_running?
+      "/#{ config.public_output_dir.join(name.to_s) }"
+    elsif file = manifest.dig(name.to_s, 'file')
+      "/#{ config.public_output_dir.join(file) }"
+    end
+  end
+
+  # Internal: Performs a Vite build.
+  def build
+    ViteRails.logger.tagged('Vite') { builder.build }
+  end
+
+  # Internal: The parsed data from manifest.json.
+  #
+  # NOTE: When using build-on-demand in development and testing, the manifest
+  # is reloaded automatically before each lookup, to ensure it's always fresh.
+  def manifest
+    return refresh if config.auto_build
+
+    @manifest ||= load_manifest
+  end
+
+  # Internal: Returns a Hash with the entries in the manifest.json.
+  def load_manifest
+    if config.manifest_path.exist?
+      JSON.parse(config.manifest_path.read)
+    else
+      {}
+    end
+  end
+
+  # Internal: Adds a file extension to the file name, unless it already has one.
+  def with_file_extension(name, entry_type)
+    return name unless File.extname(name.to_s).empty?
+
+    "#{ name }.#{ extension_for_type(entry_type) }"
+  end
+
+  # Internal: Allows to receive :javascript and :stylesheet as :type in helpers.
+  def extension_for_type(entry_type)
+    case entry_type
+    when :javascript then 'js'
+    when :stylesheet then 'css'
+    when :typescript then dev_server_running? ? 'ts' : 'js'
+    else entry_type.to_s
+    end
+  end
+
+  # Internal: Raises a detailed message when an entry is missing in the manifest.
+  def missing_entry_error(name, type: nil, **_options)
+    file_name = with_file_extension(name, type)
+    raise ViteRails::Manifest::MissingEntryError, <<~MSG
+      Vite Rails can't find #{ file_name } in #{ config.manifest_path }.
+
+      Possible causes:
+      #{ missing_entry_causes.map { |cause| "\t- #{ cause }" }.join("\n") }
+
+      Your manifest contains:
+      #{ JSON.pretty_generate(@manifest) }
+    MSG
+  end
+
+  def missing_entry_causes
+    local = config.auto_build
+    [
+      (dev_server_running? && 'Vite has not yet re-built your latest changes.'),
+      (local && !dev_server_running? && "\"autoBuild\": false in your #{ config.mode } configuration."),
+      'You have misconfigured config/vite.json file.',
+      (!local && 'Assets have not been precompiled'),
+    ].select(&:itself)
+  rescue StandardError
+    []
+  end
+end

data/lib/vite_rails/runner.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Public: Executes Vite commands, providing conveniences for debugging.
+class ViteRails::Runner
+  def initialize(argv)
+    detect_unsupported_switches!(argv)
+    @argv = argv
+  end
+
+  # Public: Executes Vite with the specified arguments.
+  def run
+    execute_command(@argv.clone)
+  end
+
+private
+
+  UNSUPPORTED_SWITCHES = %w[--host --port --https --root -r --config -c]
+  private_constant :UNSUPPORTED_SWITCHES
+
+  # Internal: Allows to prevent configuration mistakes by ensuring the Rails app
+  # and vite-plugin-ruby are using the same configuration for the dev server.
+  def detect_unsupported_switches!(args)
+    return unless (unsupported = UNSUPPORTED_SWITCHES & args).any?
+
+    $stdout.puts "Please set the following switches in your vite.json instead: #{ unsupported }."
+    exit!
+  end
+
+  # Internal: Executes the command with the specified arguments.
+  def execute_command(args)
+    cmd = vite_executable
+    cmd.prepend('node', '--inspect-brk') if args.include?('--debug')
+    cmd.prepend('node', '--trace-deprecation') if args.delete('--trace-deprecation')
+    args.append('--mode', ENV['RAILS_ENV']) unless args.include?('--mode') || args.include?('-m')
+    cmd += args
+    puts cmd.join(' ')
+    Dir.chdir(File.expand_path('.', Dir.pwd)) { Kernel.exec(ViteRails.env, *cmd) }
+  end
+
+  # Internal: Resolves to an executable for Vite.
+  def vite_executable
+    executable_exists?(path = vite_bin_path) ? [path] : %w[yarn vite]
+  end
+
+  # Internal: Only so that we can easily cover both paths in tests
+  def executable_exists?(path)
+    File.exist?(path)
+  end
+
+  # Internal: Returns a path where a Vite executable should be found.
+  def vite_bin_path
+    ENV["#{ ViteRails::ENV_PREFIX }_VITE_BIN_PATH"] || `yarn bin vite`.chomp
+  rescue StandardError
+    "#{ `npm bin`.chomp }/vite"
+  end
+end