make middleware thread safe

Author: caifara

lib/inertia_rails/middleware.rb

@@ -5,70 +5,69 @@ def initialize(app)
     end
 
     def call(env)
-      @env = env
-
       status, headers, body = @app.call(env)
       request = ActionDispatch::Request.new(env)
 
       ::InertiaRails.reset!
 
-      # Inertia errors are added to the session via redirect_to 
-      request.session.delete(:inertia_errors) unless keep_inertia_errors?(status)
+      # Inertia errors are added to the session via redirect_to
+      request.session.delete(:inertia_errors) unless keep_inertia_errors?(status, env)
 
-      status = 303 if inertia_non_post_redirect?(status)
+      status = 303 if inertia_non_post_redirect?(status, env)
 
-      return stale_inertia_get? ? force_refresh(request) : [status, headers, body]
+      return stale_inertia_get?(env) ? force_refresh(request) : [status, headers, body]
     end
 
     private
 
-    def keep_inertia_errors?(status)
-      redirect_status?(status) || stale_inertia_request?
+    def keep_inertia_errors?(status, env)
+      redirect_status?(status) || stale_inertia_request?(env)
     end
 
-    def stale_inertia_request?
-      inertia_request? && version_stale?
+    def stale_inertia_request?(env)
+      inertia_request?(env) && version_stale?(env)
     end
 
     def redirect_status?(status)
       [301, 302].include? status
     end
 
-    def non_get_redirectable_method?
-      ['PUT', 'PATCH', 'DELETE'].include? request_method
+    def non_get_redirectable_method?(env)
+      ["PUT", "PATCH", "DELETE"].include? request_method(env)
     end
 
-    def inertia_non_post_redirect?(status)
-      inertia_request? && redirect_status?(status) && non_get_redirectable_method?
+    def inertia_non_post_redirect?(status, env)
+      inertia_request?(env) && redirect_status?(status) && non_get_redirectable_method?(env)
     end
 
-    def stale_inertia_get?
-      get? && stale_inertia_request?
+    def stale_inertia_get?(env)
+      get?(env) && stale_inertia_request?(env)
     end
 
-    def get?
-      request_method == 'GET'
+    def get?(env)
+      request_method(env) == "GET"
     end
 
-    def request_method
-      @env['REQUEST_METHOD']
+    def request_method(env)
+      env["REQUEST_METHOD"]
     end
 
-    def inertia_version
-      @env['HTTP_X_INERTIA_VERSION']
+    def inertia_version(env)
+      env["HTTP_X_INERTIA_VERSION"]
     end
 
-    def inertia_request?
-      @env['HTTP_X_INERTIA'].present?
+    def inertia_request?(env)
+      env["HTTP_X_INERTIA"].present?
     end
 
-    def version_stale?
-      sent_version != saved_version
+    def version_stale?(env)
+      sent_version(env) != saved_version
     end
 
-    def sent_version
-      return nil if inertia_version.nil?
-      InertiaRails.version.is_a?(Numeric) ? inertia_version.to_f : inertia_version
+    def sent_version(env)
+      return nil if inertia_version(env).nil?
+
+      InertiaRails.version.is_a?(Numeric) ? inertia_version(env).to_f : inertia_version(env)
     end
 
     def saved_version
@@ -77,7 +76,7 @@ def saved_version
 
     def force_refresh(request)
       request.flash.keep
-      Rack::Response.new('', 409, {'X-Inertia-Location' => request.original_url}).finish
+      Rack::Response.new("", 409, { "X-Inertia-Location" => request.original_url }).finish
     end
   end
 end

spec/inertia/middleware_spec.rb

@@ -28,6 +28,24 @@
 
       it { is_expected.to eq 303 }
     end
+
+    it 'is thread safe' do
+      delete_request_proc = -> { delete redirect_test_path, headers: { 'X-Inertia' => true } }
+      get_request_proc = -> { get empty_test_path }
+
+      statusses = []
+
+      threads = []
+
+      100.times do
+        threads << Thread.new { statusses << delete_request_proc.call }
+        threads << Thread.new { get_request_proc.call }
+      end
+
+      threads.each(&:join)
+
+      expect(statusses.uniq).to eq([303])
+    end
   end
 
   context 'a request not originating from inertia' do