jsonrpc-rails 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7eaabe38b79dd41bac2752a456d5278e6cc780c3d2ebbe0493c349ff24ee10
-  data.tar.gz: 51797ce9c50cd5e51b248f8a4376880f7ffcf19245daa8ae2ef1a4b9d5d17cdf
+  metadata.gz: 5ca6d0bdf5ffc4f71a7be0e4669bad7bd1a215a647d9e5604be69b40caa86acd
+  data.tar.gz: 27359e3bc0eeaab09c659fd618f20eb15448293180d4f437fd0cd1deff1584ef
 SHA512:
-  metadata.gz: 3a55b1b369ff4d277b3351c6632a858bd00244cd0799108fbeaf4e64ba2e5b39c4687be0f1855e96df90343541e8ac0ab137684cad4f7af7394a75612b367395
-  data.tar.gz: 9883f5c131ab3437cde5410f82a21f072824a045e1680ad27d81ef1f4d10d471149a7db639c18d8e2d194586979919224c4e921bae263236023d71934d2a6cc5
+  metadata.gz: fc155ba77be68184eaeefc330a0f1829e5c0854da1cce49b7abddc870cbc158eccac3881d0bf4d00af932609aae4b84abd99868761d2ccb074840456c9d6e0b8
+  data.tar.gz: 866302ed5d32d518fbd3fc6be6cfd34c7a0e7d3f4e4466cd96cb99a102ab5795b9f29a14501e3ed96332e22472892d764087fc0668898e11dbe2fb90b9ff16ab

data/README.md

@@ -38,6 +38,22 @@ gem install jsonrpc-rails
 ### Rendering Responses
 
 Once installed, **jsonrpc-rails** registers a custom renderer with Rails. 
+
+Enable validation where you need it
+
+Add this to config/application.rb (or an environment file):
+```ruby
+# Validate only the JSON‑RPC endpoints you expose
+config.jsonrpc_rails.validated_paths = [
+"/rpc",                    # exact string
+%r{\A/api/v\d+/rpc\z},     # regexp
+->(p) { p.start_with? "/rpc/private" } # lambda / proc
+]
+```
+
+Leave the array empty (default) and the middleware is effectively off.
+Use [/.*\z/] if you really want it on everywhere.
+
 In your controllers, you can render JSON-RPC responses like so:
 
 ```ruby
@@ -62,7 +78,7 @@ end
 The renderer wraps your data in the JSON-RPC 2.0 envelope:
 - **Success Response:**
   ```json
-  { "jsonrpc": "2.0", "result": { ... }, "id": 1 }
+  { "jsonrpc": "2.0", "result": { }, "id": 1 }
   ```
 - **Error Response (using numeric code):**
   ```json
@@ -85,59 +101,84 @@ The gem automatically inserts `JSONRPC_Rails::Middleware::Validator` into your a
 
 1.  **Parses** the JSON body. Returns a JSON-RPC `Parse error (-32700)` if parsing fails.
 2.  **Validates** the structure against the JSON-RPC 2.0 specification (single or batch). It performs strict validation, ensuring `jsonrpc: "2.0"`, a string `method`, optional `params` (array/object), optional `id` (string/number/null), and **no extraneous keys**. Returns a JSON-RPC `Invalid Request (-32600)` error if validation fails. **Note:** For batch requests, if *any* individual request within the batch is structurally invalid, the entire batch is rejected with a single `Invalid Request (-32600)` error.
-3.  **Stores** the validated, parsed payload (the original Ruby Hash or Array) in `request.env['jsonrpc.payload']` if validation succeeds.
+3.  **Stores** the validated, parsed payload (the original Ruby Hash or Array) in `request.env[:jsonrpc]` if validation succeeds.
 4.  **Passes** the request to the next middleware or your controller action.
 
 In your controller action, you can access the validated payload like this:
 
 ```ruby
+# app/controllers/my_api_controller.rb
 class MyApiController < ApplicationController
+  # POST /rpc
   def process
-    jsonrpc_payload = request.env['jsonrpc.payload']
-
-    if jsonrpc_payload.is_a?(Array)
-      # Handle batch request
-      responses = jsonrpc_payload.map do |request_object|
-        handle_single_request(request_object)
-      end.compact # Remove nil responses from notifications
-      render json: responses, status: (responses.empty? ? :no_content : :ok)
-    else
-      # Handle single request
-      response = handle_single_request(jsonrpc_payload)
-      if response # Check if it was a notification
-        # Use the gem's renderer for consistency
-        render jsonrpc: response[:result], id: response[:id], error: response.key?(:error) ? response[:error] : nil
+    if jsonrpc_batch?
+      # ── batch ───────────────────────────────────────────────────────────────
+      responses = jsonrpc.filter_map { |req| handle_single_request(req) } # strip nil (notifications)
+
+      if responses.empty?
+        head :no_content
       else
-        head :no_content # No response for notification
+        # respond with an array of hashes; to_h keeps the structs internal
+        render json: responses.map(&:to_h), status: :ok
+      end
+    else
+      # ── single ──────────────────────────────────────────────────────────────
+      response = handle_single_request(jsonrpc)
+
+      if response # request (has id)
+        render jsonrpc:  response.result,
+               id:       response.id,
+               error:    response.error
+      else        # notification
+        head :no_content
       end
     end
   end
 
   private
 
+  # Map one JSON_RPC::Request|Notification → Response|nil
   def handle_single_request(req)
-    method = req['method']
-    params = req['params']
-    id = req['id'] # Will be nil for notifications
-
-    result = case method
-             when 'add'
-               params.is_a?(Array) ? params.sum : { code: -32602, message: "Invalid params" }
-             when 'subtract'
-               params.is_a?(Array) && params.size == 2 ? params[0] - params[1] : { code: -32602, message: "Invalid params" }
-             else
-               { code: -32601, message: "Method not found" }
-             end
-
-    # Only return a response structure if it's a request (has an id)
-    if id
-      if result.is_a?(Hash) && result[:code] # Check if result is an error hash
-        { id: id, error: result }
-      else
-        { id: id, result: result }
-      end
+    # Notifications have id == nil.  Return nil = no response.
+    return nil if req.id.nil?
+
+    result_or_error =
+            case req.method
+            when "add"
+              add(*Array(req.params))
+            when "subtract"
+              subtract(*Array(req.params))
+            else
+              method_not_found
+            end
+
+    build_response(req.id, result_or_error)
+  end
+
+  # ───────────────── helper methods ──────────────────────────────────────────
+  def add(*nums)
+    return invalid_params unless nums.all? { |n| n.is_a?(Numeric) }
+    nums.sum
+  end
+
+  def subtract(a = nil, b = nil)
+    return invalid_params unless a.is_a?(Numeric) && b.is_a?(Numeric)
+    a - b
+  end
+
+  def invalid_params
+    JSON_RPC::JsonRpcError.build(:invalid_params)
+  end
+
+  def method_not_found
+    JSON_RPC::JsonRpcError.build(:method_not_found)
+  end
+
+  def build_response(id, outcome)
+    if outcome.is_a?(JSON_RPC::JsonRpcError)
+      JSON_RPC::Response.new(id: id, error: outcome)
     else
-      nil # No response for notifications
+      JSON_RPC::Response.new(id: id, result: outcome)
     end
   end
 end

data/Rakefile

@@ -1,20 +1,22 @@
-require "bundler/setup"
-require "rake/testtask"
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'rake/testtask'
 
 # Configure the default test task
 Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.pattern = "test/**/*_test.rb" # Find tests recursively
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb' # Find tests recursively
   t.verbose = true # Show test output
 end
 
 # Load engine tasks (might define other test tasks, but the default is now configured)
-APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load "rails/tasks/engine.rake"
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
 
 # Load other tasks
-load "rails/tasks/statistics.rake"
-require "bundler/gem_tasks"
+load 'rails/tasks/statistics.rake'
+require 'bundler/gem_tasks'
 
 # Ensure the default task runs our configured test task
 task default: :test

data/lib/json_rpc/json_rpc_error.rb

@@ -86,5 +86,8 @@ module JSON_RPC
       hash[:data] = data if data
       hash
     end
+
+    # For ActiveSupport::JSON
+    def as_json(*) = to_h
   end
 end

data/lib/json_rpc/notification.rb

@@ -12,6 +12,10 @@ module JSON_RPC
       super
     end
 
+    def self.from_h(h)
+      new(method: h["method"], params: h["params"])
+    end
+
     # Returns a hash representation of the notification, ready for JSON serialization.
     #
     # @return [Hash] The hash representation.
@@ -24,5 +28,7 @@ module JSON_RPC
       hash[:params] = params unless params.nil?
       hash
     end
+
+    def as_json(*) = to_h
   end
 end

data/lib/json_rpc/parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JSON_RPC
+  module Parser
+    # Convert one JSON-RPC hash into a typed object.
+    def self.object_from_hash(h)
+      # Order matters: responses have id *plus* result/error,
+      # so check for those keys first.
+      if h.key?("result") || h.key?("error")
+        Response.from_h(h)
+      elsif h.key?("id")
+        Request.from_h(h)          # request (id may be nil)
+      else
+        Notification.from_h(h)     # no id ⇒ notification
+      end
+    end
+
+    # Convert raw JSON string into typed object(s).
+    def self.array_from_json(json)
+      raw = ActiveSupport::JSON.decode(json)
+      case raw
+      when Hash  then object_from_hash(raw)
+      when Array then raw.map { |h| object_from_hash(h) }
+      else            raw # let validator scream later
+      end
+    end
+  end
+end

data/lib/json_rpc/request.rb

@@ -16,6 +16,10 @@ module JSON_RPC
       super
     end
 
+    def self.from_h(h)
+      new(id: h["id"], method: h["method"], params: h["params"])
+    end
+
     # Returns a hash representation of the request, ready for JSON serialization.
     #
     # @return [Hash] The hash representation.
@@ -30,6 +34,8 @@ module JSON_RPC
       hash
     end
 
+    def as_json(*) = to_h
+
     private
 
     # Validates the ID type according to JSON-RPC 2.0 spec.
@@ -38,11 +44,11 @@ module JSON_RPC
     # @param id [Object] The ID to validate.
     # @raise [JSON_RPC::JsonRpcError] if the ID type is invalid.
     def validate_id_type(id)
-      unless id.is_a?(String) || id.is_a?(Numeric) || id.nil?
-        # Using :invalid_request as the error type seems more appropriate for a malformed ID type.
-        raise JSON_RPC::JsonRpcError.new(:invalid_request,
-                                                       message: "ID must be a string, number, or null")
-      end
+      return if id.is_a?(String) || id.is_a?(Numeric) || id.nil?
+
+      # Using :invalid_request as the error type seems more appropriate for a malformed ID type.
+      raise JSON_RPC::JsonRpcError.new(:invalid_request,
+                                       message: "ID must be a string, number, or null")
     end
   end
 end

data/lib/json_rpc/response.rb

@@ -15,6 +15,10 @@ module JSON_RPC
       super(id: id, result: result, error: error_obj)
     end
 
+    def self.from_h(h)
+      new(id: h["id"], result: h["result"], error: h["error"])
+    end
+
     # Returns a hash representation of the response, ready for JSON serialization.
     #
     # @return [Hash] The hash representation.
@@ -29,6 +33,8 @@ module JSON_RPC
       hash
     end
 
+    def as_json(*) = to_h
+
     private
 
     # Validates the response structure according to JSON-RPC 2.0 spec.
@@ -40,18 +46,16 @@ module JSON_RPC
     def validate_response(id, result, error_input)
       # ID must be present (can be null) in a response matching a request.
 
-      if !error_input.nil? && !result.nil?
-        raise ArgumentError, "Response cannot contain both 'result' and 'error'"
-      end
+      raise ArgumentError, "Response cannot contain both 'result' and 'error'" if !error_input.nil? && !result.nil?
 
       # If id is not null, either result or error MUST be present.
-      if !id.nil? && error_input.nil? && result.nil?
-        # This check assumes if both are nil, it's invalid for non-null id.
-        # `result: nil` is a valid success response. The check should ideally know
-        # if `result` was explicitly passed as nil vs not passed at all.
-        # Data.define might make this tricky. Let's keep the original logic for now.
-        raise ArgumentError, "Response with non-null ID must contain either 'result' or 'error'"
-      end
+      return unless !id.nil? && error_input.nil? && result.nil?
+
+      # This check assumes if both are nil, it's invalid for non-null id.
+      # `result: nil` is a valid success response. The check should ideally know
+      # if `result` was explicitly passed as nil vs not passed at all.
+      # Data.define might make this tricky. Let's keep the original logic for now.
+      raise ArgumentError, "Response with non-null ID must contain either 'result' or 'error'"
     end
 
     # Processes the error input into a standard error hash.

data/lib/jsonrpc-rails.rb

@@ -6,6 +6,7 @@ require_relative "json_rpc/json_rpc_error"
 require_relative "json_rpc/request"
 require_relative "json_rpc/response"
 require_relative "json_rpc/notification"
+require_relative "json_rpc/parser"
 
 module JSONRPC_Rails
 end

data/lib/jsonrpc_rails/controller_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSONRPC_Rails
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      # Returns a JSON_RPC::Request / Notification / Response
+      # or an Array of them for batch calls.
+      def jsonrpc
+        request.env[:jsonrpc]
+      end
+
+      # Convenience boolean
+      def jsonrpc_batch?
+        jsonrpc.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/jsonrpc_rails/middleware/validator.rb

@@ -5,177 +5,126 @@ require "active_support/json"
 
 module JSONRPC_Rails
   module Middleware
-    # Rack middleware to strictly validate incoming JSON-RPC 2.0 requests.
-    # It checks for correct Content-Type, parses JSON, and validates the structure
-    # of Hashes and non-empty Arrays according to JSON-RPC 2.0 spec.
+    # Rack middleware that **validates** incoming JSON-RPC 2.0 payloads
+    # and injects fully-typed Ruby objects (Request / Notification /
+    # Response) into `env[:jsonrpc]` for easy downstream use.
     #
-    # If validation passes, it stores the parsed payload in `request.env['jsonrpc.payload']`
-    # and passes the request down the stack.
-    #
-    # If JSON parsing fails, or if the payload is a Hash/Array and fails JSON-RPC validation,
-    # it immediately returns the appropriate JSON-RPC 2.0 error response.
-    #
-    # Other valid JSON payloads (e.g., strings, numbers, booleans, null) are passed through.
+    # Validation always runs on the raw Hash/Array first; objects are only
+    # instantiated **after** the structure has been deemed valid, so malformed
+    # IDs or empty batches no longer raise before we can return a proper
+    # -32600 “Invalid Request”.
     class Validator
-      CONTENT_TYPE = "application/json"
-      ENV_PAYLOAD_KEY = :"jsonrpc.payload"
-
-      def initialize(app)
-        @app = app
+      CONTENT_TYPE     = "application/json"
+      ENV_PAYLOAD_KEY  = :jsonrpc
+
+      # @param app [#call]
+      # @param paths [Array<String, Regexp, Proc>] paths to validate
+      def initialize(app, paths = nil)
+        @app   = app
+        @paths = Array(paths || Rails.configuration.jsonrpc_rails.validated_paths)
       end
 
+      # Rack entry point
       def call(env)
-        # Only process POST requests with the correct Content-Type
+        return @app.call(env) unless validate_path?(env["PATH_INFO"])
         return @app.call(env) unless env["REQUEST_METHOD"] == "POST" &&
                                      env["CONTENT_TYPE"]&.start_with?(CONTENT_TYPE)
 
-        # Read and parse the request body
-        # Safely read and rewind
         body = env["rack.input"].read
         env["rack.input"].rewind
-        payload = parse_json(body)
 
-        # Handle JSON parsing errors
-        # If parsing fails (returns nil), pass through
-        return @app.call(env) unless payload
+        raw_payload = parse_json(body)
 
-        # Determine if we should proceed with strict validation based on payload type and content
-        should_validate = false
-        is_batch = false
+        return jsonrpc_error_response(:invalid_request) unless raw_payload.is_a?(Hash) || raw_payload.is_a?(Array)
 
-        case payload
-        when Hash
-          # Validate single Hash only if 'jsonrpc' key is present
-          should_validate = payload.key?("jsonrpc")
-          is_batch = false
-        when Array
-          # Validate Array only if ALL elements are Hashes AND at least one has 'jsonrpc' key
-          all_hashes = payload.all? { |el| el.is_a?(Hash) }
-          any_jsonrpc = payload.any? { |el| el.is_a?(Hash) && el.key?("jsonrpc") }
-          if all_hashes && any_jsonrpc
-            should_validate = true
-            is_batch = true
-          end
-          # Note: Empty arrays or arrays not meeting the criteria will pass through
+        validity, = if raw_payload.is_a?(Array)
+                      validate_batch(raw_payload)
+        else
+                      validate_single(raw_payload)
         end
+        return validity unless validity == :valid
 
-        # If conditions for validation are not met, pass through
-        return @app.call(env) unless should_validate
-
-        # --- Proceed with strict validation ---
-        validation_result, _ = is_batch ? validate_batch(payload) : validate_single(payload)
+        env[ENV_PAYLOAD_KEY] = convert_to_objects(raw_payload)
 
-        # If strict validation failed (e.g., wrong version, missing method, invalid batch element), return the error
-        return validation_result unless validation_result == :valid
-
-        # Store the validated payload (original structure) in env for the controller
-        env[ENV_PAYLOAD_KEY] = payload
-
-        # Proceed to the next middleware/app
         @app.call(env)
       end
 
       private
 
-      # Parses the JSON body string using ActiveSupport::JSON. Returns parsed data or nil on failure.
       def parse_json(body)
         return nil if body.nil? || body.strip.empty?
 
         ActiveSupport::JSON.decode(body)
       rescue ActiveSupport::JSON.parse_error
-        # Return nil if parsing fails, allowing the request to pass through
         nil
       end
 
-      # Performs strict validation on a single object to ensure it conforms
-      # to the JSON-RPC 2.0 structure (jsonrpc, method, params, id) and
-      # has no extraneous keys.
-      # Returns true if valid, false otherwise.
+      def validate_path?(path)
+        return false if @paths.empty?
+
+        @paths.any? do |matcher|
+          case matcher
+          when String then path == matcher
+          when Regexp then matcher.match?(path)
+          when Proc   then matcher.call(path)
+          else             false
+          end
+        end
+      end
+
+      # -------------------- structure validation --------------------------------
+
       def validate_single_structure(obj)
-        # Must be a Hash
         return false unless obj.is_a?(Hash)
-
-        # Must have 'jsonrpc' key with value '2.0'
         return false unless obj["jsonrpc"] == "2.0"
-
-        # Must have 'method' key with a String value
         return false unless obj["method"].is_a?(String)
 
-        # Optional 'params' must be an Array or Hash if present
-        if obj.key?("params") && !obj["params"].is_a?(Array) && !obj["params"].is_a?(Hash)
-          return false
-        end
-
-        # Optional 'id' must be a String, Number (Integer), or Null if present
-        if obj.key?("id") && ![ String, Integer, NilClass ].include?(obj["id"].class)
-          return false
-        end
+        return false if obj.key?("params") && !obj["params"].is_a?(Array) && !obj["params"].is_a?(Hash)
 
-        # Check for extraneous keys
-        allowed_keys = %w[jsonrpc method params id]
-        return false unless (obj.keys - allowed_keys).empty?
+        return false if obj.key?("id") && ![ String, Integer, NilClass ].include?(obj["id"].class)
 
-        true # Structure is valid
+        allowed = %w[jsonrpc method params id]
+        (obj.keys - allowed).empty?
       end
 
-
-      # Validates a single JSON-RPC request object (must be a Hash).
-      # Returns [:valid, nil] on success.
-      # Returns [error_response_tuple, nil] on failure.
       def validate_single(obj)
-        # Assumes obj is a Hash due to check in `call`
         if validate_single_structure(obj)
           [ :valid, nil ]
         else
-          # Generate error response if structure is invalid (e.g., missing 'jsonrpc')
           [ jsonrpc_error_response(:invalid_request), nil ]
         end
       end
 
-      # Validates a batch JSON-RPC request (must be an Array).
-      # Returns [:valid, nil] if the batch structure is valid.
-      # Returns [error_response_tuple, nil] if the batch is empty or any element is invalid.
       def validate_batch(batch)
-        # Assumes batch is an Array due to check in `call`
-        # Batch request must be a non-empty array according to spec
-        unless batch.is_a?(Array) && !batch.empty?
-          return [ jsonrpc_error_response(:invalid_request), nil ]
-        end
-
-        # Find first invalid element - stops processing as soon as it finds one
-        invalid_element = batch.find { |element| !validate_single_structure(element) }
+        return [ jsonrpc_error_response(:invalid_request), nil ] unless batch.is_a?(Array) && !batch.empty?
 
-        # If an invalid element was found, return an error response immediately
-        if invalid_element
-          return [ jsonrpc_error_response(:invalid_request), nil ]
-        end
-
-        # All elements passed structural validation
-        [ :valid, nil ]
+        invalid = batch.find { |el| !validate_single_structure(el) }
+        invalid ? [ jsonrpc_error_response(:invalid_request), nil ] : [ :valid, nil ]
       end
 
-      # Generates a Rack response tuple for a given JSON-RPC error.
-      # Middleware-level errors always have id: nil.
-      # @param error_type [Symbol, JSON_RPC::JsonRpcError] The error symbol or object.
-      # @param status [Integer] The HTTP status code.
-      # @return [Array] Rack response tuple.
-      def jsonrpc_error_response(error_type, status: 400)
-        error_obj = if error_type.is_a?(JSON_RPC::JsonRpcError)
-                      error_type
+      # ------------------ conversion to typed objects ---------------------------
+
+      def convert_to_objects(raw)
+        case raw
+        when Hash
+          JSON_RPC::Parser.object_from_hash(raw)
+        when Array
+          raw.map { |h| JSON_RPC::Parser.object_from_hash(h) }
         else
-                      JSON_RPC::JsonRpcError.new(error_type)
+          raw # should never get here after validation
         end
+      end
+
+      # ------------------ error response helper ---------------------------------
 
-        response_body = JSON_RPC::Response.new(
-          id: nil, # Middleware errors have null id
-          error: error_obj.to_h,
-        ).to_json
+      # @param error_sym [Symbol]
+      # @param status    [Integer]
+      # @return [Array] Rack triplet
+      def jsonrpc_error_response(error_sym, status: 400)
+        error_obj = JSON_RPC::JsonRpcError.build(error_sym)
+        payload   = JSON_RPC::Response.new(id: nil, error: error_obj).to_json
 
-        [
-          status,
-          { "Content-Type" => CONTENT_TYPE },
-          [ response_body ]
-        ]
+        [ status, { "Content-Type" => CONTENT_TYPE }, [ payload ] ]
       end
     end
   end

data/lib/jsonrpc_rails/railtie.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require_relative "middleware/validator"
 
 module JSONRPC_Rails
   # Use Rails::Railtie to integrate with the Rails application
   class Railtie < Rails::Railtie
+    config.jsonrpc_rails = ActiveSupport::OrderedOptions.new
+    config.jsonrpc_rails.validated_paths = [] # By default, we inject it into the void.
     # Insert the JSON-RPC Validator middleware early in the stack.
-    # Inserting before Rack::Sendfile, which is typically present early in the stack.
     initializer "jsonrpc-rails.add_validator_middleware" do |app|
       app.middleware.use JSONRPC_Rails::Middleware::Validator
     end
@@ -23,7 +26,8 @@ module JSONRPC_Rails
                              # Build error from symbol, allowing overrides from payload_obj
                              message_override = payload_obj.is_a?(Hash) ? payload_obj[:message] : nil
                              data_override = payload_obj.is_a?(Hash) ? payload_obj[:data] : nil
-                             error_hash = JSON_RPC::JsonRpcError.build(error_input, message: message_override, data: data_override)
+                             error_hash = JSON_RPC::JsonRpcError.build(error_input, message: message_override,
+                                                                                    data: data_override)
                              JSON_RPC::Response.new(id: response_id, error: error_hash)
             when Integer
                              # Build error from numeric code, allowing overrides from payload_obj
@@ -38,7 +42,8 @@ module JSONRPC_Rails
                              error_hash[:data] = data_override if data_override
                              JSON_RPC::Response.new(id: response_id, error: error_hash)
             when ->(ei) { ei } # Catch any other truthy value
-                             raise ArgumentError, "The :error option for render :jsonrpc must be a Symbol or an Integer, got: #{error_input.inspect}"
+                             raise ArgumentError,
+                                   "The :error option for render :jsonrpc must be a Symbol or an Integer, got: #{error_input.inspect}"
             # # Original logic (removed): Treat payload_obj as the error hash
             # JSON_RPC::Response.new(id: response_id, error: payload_obj)
             else # Falsy (nil, false)
@@ -49,7 +54,8 @@ module JSONRPC_Rails
           rescue ArgumentError => e
             # Handle cases where Response initialization fails (e.g., invalid id/result/error combo)
             # Respond with an Internal Error according to JSON-RPC spec
-            internal_error = JSON_RPC::JsonRpcError.new(:internal_error, message: "Server error generating response: #{e.message}")
+            internal_error = JSON_RPC::JsonRpcError.new(:internal_error,
+                                                        message: "Server error generating response: #{e.message}")
             response_payload = { jsonrpc: "2.0", error: internal_error.to_h, id: response_id }
             # Consider logging the error e.message
           rescue JSON_RPC::JsonRpcError => e
@@ -58,12 +64,18 @@ module JSONRPC_Rails
             # Consider logging the error e.message
           end
 
-
           # Set the proper MIME type and convert the hash to JSON.
           self.content_type ||= Mime[:json]
           self.response_body = response_payload.to_json
         end
       end
     end
+
+    initializer "jsonrpc-rails.controller_helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        require_relative "controller_helpers"
+        include JSONRPC_Rails::ControllerHelpers
+      end
+    end
   end
 end

data/lib/jsonrpc_rails/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONRPC_Rails
-    VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonrpc-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -38,9 +38,11 @@ files:
 - Rakefile
 - lib/json_rpc/json_rpc_error.rb
 - lib/json_rpc/notification.rb
+- lib/json_rpc/parser.rb
 - lib/json_rpc/request.rb
 - lib/json_rpc/response.rb
 - lib/jsonrpc-rails.rb
+- lib/jsonrpc_rails/controller_helpers.rb
 - lib/jsonrpc_rails/middleware/validator.rb
 - lib/jsonrpc_rails/railtie.rb
 - lib/jsonrpc_rails/version.rb