rage-rb 0.5.2 → 0.7.0

data/lib/rage/controller/api.rb

@@ -8,7 +8,7 @@ class RageController::API
     # sends a correct response down to the server;
     # returns the name of the newly defined method;
     def __register_action(action)
-      raise "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
+      raise Rage::Errors::RouterError, "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
 
       before_actions_chunk = if @__before_actions
         filtered_before_actions = @__before_actions.select do |h|
@@ -25,7 +25,7 @@ class RageController::API
             "unless #{h[:unless]}"
           end
 
-          <<-RUBY
+          <<~RUBY
             #{h[:name]} #{condition}
             return [@__status, @__headers, @__body] if @__rendered
           RUBY
@@ -36,9 +36,34 @@ class RageController::API
         ""
       end
 
+      after_actions_chunk = if @__after_actions
+        filtered_after_actions = @__after_actions.select do |h|
+          (!h[:only] || h[:only].include?(action)) &&
+            (!h[:except] || !h[:except].include?(action))
+        end
+
+        lines = filtered_after_actions.map! do |h|
+          condition = if h[:if] && h[:unless]
+            "if #{h[:if]} && !#{h[:unless]}"
+          elsif h[:if]
+            "if #{h[:if]}"
+          elsif h[:unless]
+            "unless #{h[:unless]}"
+          end
+
+          <<~RUBY
+            #{h[:name]} #{condition}
+          RUBY
+        end
+
+        lines.join("\n")
+      else
+        ""
+      end
+
       rescue_handlers_chunk = if @__rescue_handlers
         lines = @__rescue_handlers.map do |klasses, handler|
-          <<-RUBY
+          <<~RUBY
           rescue #{klasses.join(", ")} => __e
             #{handler}(__e)
             [@__status, @__headers, @__body]
@@ -50,26 +75,60 @@ class RageController::API
         ""
       end
 
-      class_eval <<-RUBY,  __FILE__, __LINE__ + 1
+      activerecord_loaded = Rage.config.internal.rails_mode && defined?(::ActiveRecord)
+
+      class_eval <<~RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.enable_query_cache!
+            RUBY
+          end}
+
           #{before_actions_chunk}
           #{action}
 
+          #{if !after_actions_chunk.empty?
+            <<~RUBY
+              @__rendered = true
+              #{after_actions_chunk}
+            RUBY
+          end}
+
           [@__status, @__headers, @__body]
 
           #{rescue_handlers_chunk}
+
+        ensure
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.disable_query_cache!
+              if ActiveRecord::Base.connection_pool.active_connection?
+                ActiveRecord::Base.connection_handler.clear_active_connections!
+              end
+            RUBY
+          end}
+
+          #{if method_defined?(:append_info_to_payload) || private_method_defined?(:append_info_to_payload)
+            <<~RUBY
+              context = {}
+              append_info_to_payload(context)
+              Thread.current[:rage_logger][:context] = context
+            RUBY
+          end}
         end
       RUBY
     end
 
     # @private
-    attr_writer :__before_actions, :__rescue_handlers
+    attr_writer :__before_actions, :__after_actions, :__rescue_handlers
 
     # @private
     # pass the variable down to the child; the child will continue to use it until changes need to be made;
     # only then the object will be copied; the frozen state communicates that the object is shared with the parent;
     def inherited(klass)
       klass.__before_actions = @__before_actions.freeze
+      klass.__after_actions = @__after_actions.freeze
       klass.__rescue_handlers = @__rescue_handlers.freeze
     end
 
@@ -148,29 +207,12 @@ class RageController::API
     #   end
     # @note The block form doesn't receive an argument and is executed on the controller level as if it was a regular method.
     def before_action(action_name = nil, **opts, &block)
-      if block_given?
-        action_name = define_tmp_method(block)
-      elsif action_name.nil?
-        raise "No handler provided. Pass the `action_name` parameter or provide a block."
-      end
-
-       _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
+      action = prepare_action_params(action_name, **opts, &block)
 
       if @__before_actions && @__before_actions.frozen?
         @__before_actions = @__before_actions.dup
       end
 
-      action = {
-        name: action_name,
-        only: _only && Array(_only),
-        except: _except && Array(_except),
-        if: _if,
-        unless: _unless
-      }
-
-      action[:if] = define_tmp_method(action[:if]) if action[:if].is_a?(Proc)
-      action[:unless] = define_tmp_method(action[:unless]) if action[:unless].is_a?(Proc)
-
       if @__before_actions.nil?
         @__before_actions = [action]
       elsif i = @__before_actions.find_index { |a| a[:name] == action_name }
@@ -180,6 +222,32 @@ class RageController::API
       end
     end
 
+    # Register a new `after_action` hook. Calls with the same `action_name` will overwrite the previous ones.
+    #
+    # @param action_name [String, nil] the name of the callback to add
+    # @param [Hash] opts action options
+    # @option opts [Symbol, Array<Symbol>] :only restrict the callback to run only for specific actions
+    # @option opts [Symbol, Array<Symbol>] :except restrict the callback to run for all actions except specified
+    # @option opts [Symbol, Proc] :if only run the callback if the condition is true
+    # @option opts [Symbol, Proc] :unless only run the callback if the condition is false
+    # @example
+    #   after_action :log_detailed_metrics, only: :create
+    def after_action(action_name = nil, **opts, &block)
+      action = prepare_action_params(action_name, **opts, &block)
+
+      if @__after_actions && @__after_actions.frozen?
+        @__after_actions = @__after_actions.dup
+      end
+
+      if @__after_actions.nil?
+        @__after_actions = [action]
+      elsif i = @__after_actions.find_index { |a| a[:name] == action_name }
+        @__after_actions[i] = action
+      else
+        @__after_actions << action
+      end
+    end
+
     # Prevent a `before_action` hook from running.
     #
     # @param action_name [String] the name of the callback to skip
@@ -208,24 +276,54 @@ class RageController::API
 
       @__before_actions[i] = action
     end
-  end # class << self
 
-  # @private
-  DEFAULT_HEADERS = { "content-type" => "application/json; charset=utf-8" }.freeze
+    private
+
+    # used by `before_action` and `after_action`
+    def prepare_action_params(action_name = nil, **opts, &block)
+      if block_given?
+        action_name = define_tmp_method(block)
+      elsif action_name.nil?
+        raise "No handler provided. Pass the `action_name` parameter or provide a block."
+      end
+
+       _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
+
+      action = {
+        name: action_name,
+        only: _only && Array(_only),
+        except: _except && Array(_except),
+        if: _if,
+        unless: _unless
+      }
+
+      action[:if] = define_tmp_method(action[:if]) if action[:if].is_a?(Proc)
+      action[:unless] = define_tmp_method(action[:unless]) if action[:unless].is_a?(Proc)
+
+      action
+    end
+  end # class << self
 
   # @private
   def initialize(env, params)
     @__env = env
     @__params = params
-    @__status, @__headers, @__body = 204, DEFAULT_HEADERS, []
+    @__status, @__headers, @__body = 204, { "content-type" => "application/json; charset=utf-8" }, []
     @__rendered = false
   end
 
   # Get the request object. See {Rage::Request}.
+  # @return [Rage::Request]
   def request
     @request ||= Rage::Request.new(@__env)
   end
 
+  # Get the response object. See {Rage::Response}.
+  # @return [Rage::Response]
+  def response
+    @response ||= Rage::Response.new(@__headers, @__body)
+  end
+
   # Send a response to the client.
   #
   # @param json [String, Object] send a json response to the client; objects like arrays will be serialized automatically
@@ -281,11 +379,10 @@ class RageController::API
 
   # Set response headers.
   #
+  # @return [Hash]
   # @example
   #   headers["Content-Type"] = "application/pdf"
   def headers
-    # copy-on-write implementation for the headers object
-    @__headers = {}.merge!(@__headers) if DEFAULT_HEADERS.equal?(@__headers)
     @__headers
   end
 
@@ -299,11 +396,24 @@ class RageController::API
   def authenticate_with_http_token
     auth_header = @__env["HTTP_AUTHORIZATION"]
 
-    if auth_header&.start_with?("Bearer")
-      yield auth_header[7..]
+    payload = if auth_header&.start_with?("Bearer")
+      auth_header[7..]
     elsif auth_header&.start_with?("Token")
-      yield auth_header[6..]
+      auth_header[6..]
+    end
+
+    return unless payload
+
+    token = if payload.start_with?("token=")
+      payload[6..]
+    else
+      payload
     end
+
+    token.delete_prefix!('"')
+    token.delete_suffix!('"')
+
+    yield token
   end
 
   if !defined?(::ActionController::Parameters)
@@ -331,4 +441,40 @@ class RageController::API
       @params ||= ActionController::Parameters.new(@__params)
     end
   end
+
+  # Checks if the request is stale to decide if the action has to be rendered or the cached version is still valid. Use this method to implement conditional GET.
+  #
+  # @param etag [String] The etag of the requested resource.
+  # @param last_modified [Time] The last modified time of the requested resource.
+  # @return [Boolean] True if the response is stale, false otherwise.
+  # @example
+  #  stale?(etag: "123", last_modified: Time.utc(2023, 12, 15))
+  #  stale?(last_modified: Time.utc(2023, 12, 15))
+  #  stale?(etag: "123")
+  # @note `stale?` will set the response status to 304 if the request is fresh. This side effect will cause a double render error, if `render` gets called after this method. Make sure to implement a proper conditional in your action to prevent this from happening:
+  #  ```ruby
+  #  if stale?(etag: "123")
+  #    render json: { hello: "world" }
+  #  end
+  #  ```
+  def stale?(etag: nil, last_modified: nil)
+    still_fresh = request.fresh?(etag:, last_modified:)
+
+    head :not_modified if still_fresh
+    !still_fresh
+  end
+
+  # @private
+  # for comatibility with `Rails.application.routes.recognize_path`
+  def self.binary_params_for?(_)
+    false
+  end
+
+  # @!method append_info_to_payload(payload)
+  #   Define this method to add more information to request logs.
+  #   @param [Hash] payload the payload to add additional information to
+  #   @example
+  #     def append_info_to_payload(payload)
+  #       payload[:response] = response.body
+  #     end
 end

data/lib/rage/errors.rb

@@ -1,4 +1,7 @@
 module Rage::Errors
   class BadRequest < StandardError
   end
+
+  class RouterError < StandardError
+  end
 end

data/lib/rage/fiber.rb

@@ -33,6 +33,14 @@ class Fiber
     !@__rage_id.nil?
   end
 
+  # @private
+  def __block_channel(force = false)
+    @__block_channel_i ||= 0
+    @__block_channel_i += 1 if force
+
+    "block:#{object_id}:#{@__block_channel_i}"
+  end
+
   # @private
   # pause a fiber and resume in the next iteration of the event loop
   def self.pause

data/lib/rage/fiber_scheduler.rb

@@ -81,7 +81,7 @@ class Rage::FiberScheduler
   end
 
   def block(_blocker, timeout = nil)
-    f, fulfilled, channel = Fiber.current, false, "unblock:#{Fiber.current.object_id}"
+    f, fulfilled, channel = Fiber.current, false, Fiber.current.__block_channel(true)
 
     resume_fiber_block = proc do
       unless fulfilled
@@ -100,7 +100,7 @@ class Rage::FiberScheduler
   end
 
   def unblock(_blocker, fiber)
-    ::Iodine.publish("unblock:#{fiber.object_id}", "")
+    ::Iodine.publish(fiber.__block_channel, "")
   end
 
   def fiber(&block)

data/lib/rage/logger/json_formatter.rb

@@ -0,0 +1,44 @@
+class Rage::JSONFormatter
+  def initialize
+    @pid = Process.pid.to_s
+    Iodine.on_state(:on_start) do
+      @pid = Process.pid.to_s
+    end
+  end
+
+  def call(severity, timestamp, _, message)
+    logger = Thread.current[:rage_logger]
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "\"#{k}\":#{v.to_json}," }
+    end
+
+    if final = logger[:final]
+      params, env = final[:params], final[:env]
+      if params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{params[:controller]}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      else
+        # no controller/action keys are written if there are no params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      end
+    end
+
+    if tags.length == 1
+      tags_msg = "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    elsif tags.length == 2
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    else
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
+      i = 2
+      while i < tags.length
+        tags_msg << ",\"#{tags[i]}\""
+        i += 1
+      end
+      tags_msg << "],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    end
+
+    "#{tags_msg},#{context_msg}\"message\":\"#{message}\"}\n"
+  end
+end

data/lib/rage/logger/logger.rb

@@ -56,8 +56,8 @@ class Rage::Logger
   # @param shift_period_suffix [String] the log file suffix format for daily, weekly or monthly rotation
   # @param binmode sets whether the logger writes in binary mode
   def initialize(log, level: Logger::DEBUG, formatter: Rage::TextFormatter.new, shift_age: 0, shift_size: 104857600, shift_period_suffix: "%Y%m%d", binmode: false)
-    if log && log != File::NULL
-      @logdev = Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
+    @logdev = if log && log != File::NULL
+      Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
     end
 
     @formatter = formatter
@@ -128,8 +128,8 @@ class Rage::Logger
             false
           end
         RUBY
-      elsif defined?(IRB)
-        # the call was made from IRB - don't use the formatter
+      elsif (Rage.config.internal.rails_mode ? Rage.config.internal.rails_console : defined?(IRB))
+        # the call was made from the console - don't use the formatter
         <<-RUBY
           def #{level_name}(msg = nil)
             @logdev.write((msg || yield) + "\n")

data/lib/rage/logger/text_formatter.rb

@@ -8,15 +8,20 @@ class Rage::TextFormatter
 
   def call(severity, timestamp, _, message)
     logger = Thread.current[:rage_logger]
-    tags = logger[:tags]
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "#{k}=#{v} " }
+    end
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
       if params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       else
         # no controller/action keys are written if there are no params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       end
     end
 
@@ -34,13 +39,6 @@ class Rage::TextFormatter
       tags_msg << " timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     end
 
-    context = logger[:context]
-
-    if !context.empty?
-      context_msg = ""
-      context.each { |k, v| context_msg << "#{k}=#{v} " }
-    end
-
     "#{tags_msg} #{context_msg}message=#{message}\n"
   end
 end

data/lib/rage/middleware/cors.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class Rage::Cors
+  # @private
+  def initialize(app, *, &)
+    @app = app
+    instance_eval(&)
+  end
+
+  # @private
+  def call(env)
+    if env["REQUEST_METHOD"] == "OPTIONS"
+      return (response = @cors_response)
+    end
+
+    response = @app.call(env)
+    response[1]["Access-Control-Allow-Credentials"] = @allow_credentials if @allow_credentials
+    response[1]["Access-Control-Expose-Headers"] = @expose_headers if @expose_headers
+
+    response
+  ensure
+    if !$! && origin = @cors_check.call(env)
+      headers = response[1]
+      headers["Access-Control-Allow-Origin"] = origin
+      if @origins != "*"
+        vary = headers["Vary"]
+        if vary.nil?
+          headers["Vary"] = "Origin"
+        elsif vary != "Origin"
+          headers["Vary"] += ", Origin"
+        end
+      end
+    end
+  end
+
+  # Set CORS rules for the application.
+  #
+  # @param origins [String, Regexp, "*"] origins allowed to access the application
+  # @param methods [Array<Symbol>, "*"] allowed methods when accessing the application
+  # @param allow_headers [Array<String>, "*"] indicate which HTTP headers can be used when making the actual request
+  # @param expose_headers [Array<String>, "*"] adds the specified headers to the allowlist that JavaScript in browsers is allowed to access
+  # @param max_age [Integer] indicate how long the results of a preflight request can be cached
+  # @param allow_credentials [Boolean] indicate whether or not the response to the request can be exposed when the `credentials` flag is `true`
+  # @example
+  #   config.middleware.use Rage::Cors do
+  #     allow "localhost:5173", "myhost.com"
+  #   end
+  # @example
+  #   config.middleware.use Rage::Cors do
+  #     allow "*",
+  #       methods: [:get, :post, :put],
+  #       allow_headers: ["x-domain-token"],
+  #       expose: ["Some-Custom-Response-Header"],
+  #       max_age: 600
+  #   end
+  # @note The middleware only supports the basic case of allowing one or several origins for the whole application. Use {https://github.com/cyu/rack-cors Rack::Cors} if you are looking to specify more advanced rules.
+  def allow(*origins, methods: "*", allow_headers: "*", expose_headers: nil, max_age: nil, allow_credentials: false)
+    @allow_headers = Array(allow_headers).join(", ") if allow_headers
+    @expose_headers = Array(expose_headers).join(", ") if expose_headers
+    @max_age = max_age.to_s if max_age
+    @allow_credentials = "true" if allow_credentials
+
+    @default_methods = %w(GET POST PUT PATCH DELETE HEAD OPTIONS)
+    @methods = if methods != "*"
+      methods.map! { |method| method.to_s.upcase }.tap { |m|
+        if (invalid_methods = m - @default_methods).any?
+          raise "Unsupported method passed to Rage::Cors: #{invalid_methods[0]}"
+        end
+      }.join(", ")
+    elsif @allow_credentials
+      @default_methods.join(", ")
+    else
+      "*"
+    end
+
+    if @allow_credentials
+      raise "Rage::Cors requires you to explicitly list allowed headers when using `allow_credentials: true`" if @allow_headers == "*"
+      raise "Rage::Cors requires you to explicitly list exposed headers when using `allow_credentials: true`" if @expose_headers == "*"
+    end
+
+    @origins = []
+    origins.each do |origin|
+      if origin == "*"
+        @origins = "*"
+        break
+      elsif origin.is_a?(Regexp) || origin =~ /^\S+:\/\//
+        @origins << origin
+      else
+        @origins << "https://#{origin}" << "http://#{origin}"
+      end
+    end
+
+    @cors_check = create_cors_proc
+    @cors_response = [204, create_headers, []]
+  end
+
+  private
+
+  def create_headers
+    headers = {
+      "Access-Control-Allow-Origin" => "",
+      "Access-Control-Allow-Methods" => @methods,
+    }
+
+    if @allow_headers
+      headers["Access-Control-Allow-Headers"] = @allow_headers
+    end
+    if @expose_headers
+      headers["Access-Control-Expose-Headers"] = @expose_headers
+    end
+    if @max_age
+      headers["Access-Control-Max-Age"] = @max_age
+    end
+    if @allow_credentials
+      headers["Access-Control-Allow-Credentials"] = @allow_credentials
+    end
+
+    headers
+  end
+
+  def create_cors_proc
+    if @origins == "*"
+      ->(env) { env["HTTP_ORIGIN"] }
+    else
+      origins_eval = @origins.map { |origin|
+        origin.is_a?(Regexp) ?
+          "origin =~ /#{origin.source}/.freeze" :
+          "origin == '#{origin}'.freeze"
+      }.join(" || ")
+
+      eval <<-RUBY
+        ->(env) do
+          origin = env["HTTP_ORIGIN".freeze]
+          origin if #{origins_eval}
+        end
+      RUBY
+    end
+  end
+end

data/lib/rage/{fiber_wrapper.rb → middleware/fiber_wrapper.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 ##
-# The middleware wraps every request in a Fiber and implements the custom defer protocol with Iodine.
-# Scheduling fibers in a middleware allows the framework to be compatibe with custom Rack middlewares.
+# The middleware wraps every request in a separate Fiber. It should always be on the top of the middleware stack,
+# as it implements a custom defer protocol, which may break middlewares located above.
 #
 class Rage::FiberWrapper
   def initialize(app)
@@ -16,9 +16,11 @@ class Rage::FiberWrapper
     fiber = Fiber.schedule do
       @app.call(env)
     ensure
+      # notify Iodine the request can now be resumed
       Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS) if Fiber.current.__yielded?
     end
 
+    # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request
     if fiber.alive?
       [:__http_defer__, fiber]
     else

data/lib/rage/middleware/reloader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Rage::Reloader
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    Rage.code_loader.reload
+    @app.call(env)
+rescue Exception => e
+    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+    puts(exception_str)
+    [500, {}, [exception_str]]
+  end
+end