Use middleware instead Rails controller for model query

- By using middleware instead of a Rails controller, it skips many middlewares
  that aren't needed for our model query request. In big Rails apps, this
  could be a big performance improvement.
- Although Rails engine also supports being used as a middleware, it still
  requires registering routes to the application. That doesn't always work
  depends on the app's own rules on how to register routes.
- Compare to Rails engine, middleware is a more flexible way to integrate
  with Rails apps and also a lot lighter.

Author: st0012

Gemfile.lock

@@ -206,6 +206,7 @@ GEM
     sorbet (0.5.10782)
       sorbet-static (= 0.5.10782)
     sorbet-runtime (0.5.10782)
+    sorbet-static (0.5.10782-universal-darwin-21)
     sorbet-static (0.5.10782-universal-darwin-22)
     sorbet-static (0.5.10782-x86_64-linux)
     sorbet-static-and-runtime (0.5.10782)
@@ -246,6 +247,7 @@ GEM
     zeitwerk (2.6.7)
 
 PLATFORMS
+  arm64-darwin-21
   arm64-darwin-22
   x86_64-linux
 

app/assets/config/ruby_lsp_rails_manifest.js

@@ -3,7 +3,7 @@
 
 require "sorbet-runtime"
 require "ruby_lsp_rails/version"
-require "ruby_lsp_rails/engine"
+require "ruby_lsp_rails/railtie"
 
 module RubyLSP
   module Rails

app/assets/images/rails_ruby_lsp_rails/.keep

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    class Middleware
+      extend T::Sig
+
+      PATH_REGEXP = %r{/ruby_lsp_rails/models/(?<model_name>.+)}
+
+      sig { params(app: T.untyped).void }
+      def initialize(app)
+        @app = app
+      end
+
+      sig { params(env: T::Hash[T.untyped, T.untyped]).returns(T::Array[T.untyped]) }
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        # TODO: improve the model name regex
+        match = request.path.match(PATH_REGEXP)
+
+        if match
+          resolve_database_info_from_model(match[:model_name])
+        else
+          @app.call(env)
+        end
+      rescue
+        @app.call(env)
+      end
+
+      private
+
+      sig { params(model_name: String).returns(T::Array[T.untyped]) }
+      def resolve_database_info_from_model(model_name)
+        const = ActiveSupport::Inflector.safe_constantize(model_name)
+
+        if const && const < ActiveRecord::Base
+          begin
+            schema_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
+          rescue => e
+            warn("Could not locate schema: #{e.message}")
+          end
+
+          body = JSON.dump({
+            columns: const.columns.map { |column| [column.name, column.type] },
+            schema_file: schema_file,
+          })
+
+          [200, { "Content-Type" => "application/json" }, [body]]
+        else
+          not_found
+        end
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def not_found
+        [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
+      end
+    end
+  end
+end

app/assets/stylesheets/ruby_lsp_rails/application.css

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp_rails/middleware"
+
+module RubyLsp
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "ruby_lsp_rails.setup" do |app|
+        app.config.middleware.insert_after(ActionDispatch::ShowExceptions, RubyLsp::Rails::Middleware)
+
+        config.after_initialize do |_app|
+          if defined?(::Rails::Server)
+            ssl_enable, host, port = ::Rails::Server::Options.new.parse!(ARGV).values_at(:SSLEnable, :Host, :Port)
+            app_uri = "#{ssl_enable ? "https" : "http"}://#{host}:#{port}"
+            File.write("#{::Rails.root}/tmp/app_uri.txt", app_uri)
+          end
+        end
+      end
+    end
+  end
+end

app/controllers/concerns/.keep

@@ -18,14 +18,3 @@ module Rails
     def configure(&block); end
   end
 end
-
-module RubyLsp
-  module Rails
-    class Engine
-      class << self
-        sig { returns(ActionDispatch::Routing::RouteSet) }
-        def routes; end
-      end
-    end
-  end
-end

app/controllers/ruby_lsp/rails/application_controller.rb

@@ -6,10 +6,8 @@
 module RubyLsp
   module Rails
     class ModelsControllerTest < ActionDispatch::IntegrationTest
-      T.unsafe(self).include(Engine.routes.url_helpers)
-
       test "GET show returns column information for existing models" do
-        get model_url(model: "User")
+        get "/ruby_lsp_rails/models/User"
         assert_response(:success)
         assert_equal(
           {
@@ -28,12 +26,12 @@ class ModelsControllerTest < ActionDispatch::IntegrationTest
       end
 
       test "GET show returns not_found if model doesn't exist" do
-        get model_url(model: "NonExistentModel")
+        get "/ruby_lsp_rails/models/Foo"
         assert_response(:not_found)
       end
 
       test "GET show returns not_found if class is not a model" do
-        get model_url(model: "ApplicationJob")
+        get "/ruby_lsp_rails/models/ApplicationJob"
         assert_response(:not_found)
       end
     end