jsonrpc-rails 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 145a4a20db9c6d49fa01ca8b9eb0c1a853288195a78c099b4ecc9eefc4f551d8
-  data.tar.gz: c5ac9e090225a393917f0cda10c6d8a4d0593b428659d596539c1999edc3edcb
+  metadata.gz: 439108bab45d71dabc7ca40fa35042cdaecd7f3dc6988bc3a13fb0d825ef38ac
+  data.tar.gz: 34142d82edff4b8099610d44ca19bc039571fbcc0651a44c24588047a141838a
 SHA512:
-  metadata.gz: a5d77db449217fddce82825a2daac7019d9c2133759dfd23cf01c1eb10fb4ec9d91b24ceca98fadb244b011a6becb15fe40256ab5d318cc4e65a5d23b2842247
-  data.tar.gz: fdcf40b192d2f132d577c47195b007e67172e574f99936c3d74f2c30d31e7cc956a6dabba74ef8362777deaec2fb3f4a974736aa14991fd9e33ccba2bd28faf3
+  metadata.gz: a9b228edf10da4b05019c87643079e3ebe673fb98913dfba6567877293c28e8d2fd3a6507174d2aec8010d8254bab551631b38ac20e3784281773b4546bafb16
+  data.tar.gz: 3a4cbec99a1dd380a32263d6db57b4550f030aa50c67f29af3b8b25f827dc7d8a5c2be600e282426f36b826a82d393d2a61adda782040aeb0a44f76a455d96ba

data/README.md

@@ -78,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
@@ -101,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,194 +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"
+      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
-
+        @app   = app
         @paths = Array(paths || Rails.configuration.jsonrpc_rails.validated_paths)
       end
 
+      # Rack entry point
       def call(env)
         return @app.call(env) unless validate_path?(env["PATH_INFO"])
-
-        # Only process POST requests with the correct Content-Type
         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)
-
-        # 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
+        env[ENV_PAYLOAD_KEY] = convert_to_objects(raw_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
 
       def validate_path?(path)
         return false if @paths.empty?
 
-        @paths.any? do |m|
-          case m
-          when String then path == m
-          when Regexp then m.match?(path)
-          when Proc   then m.call(path)
+        @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
 
-      # 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.
+      # -------------------- 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,70 +1,106 @@
+# frozen_string_literal: true
+
+# lib/jsonrpc_rails/railtie.rb
 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.
+    config.jsonrpc_rails.validated_paths = []
+
     initializer "jsonrpc-rails.add_validator_middleware" do |app|
       app.middleware.use JSONRPC_Rails::Middleware::Validator
     end
 
+    # -----------------------------------------------------------------------
+    # Renderer
+    # -----------------------------------------------------------------------
     initializer "jsonrpc-rails.add_renderers" do
       ActiveSupport.on_load(:action_controller) do
         ActionController::Renderers.add :jsonrpc do |obj, options|
-          # Use the Response class to build the payload
-          response_id = options[:id] # ID is required for Response
-          error_input = options[:error] # Can be nil, Symbol, Hash, or JsonRpcError
-          payload_obj = obj # The main object passed to render
+          response_id = options[:id]
+          error_opt = options[:error]
 
           begin
-            response_obj = case error_input
-            when Symbol
-                             # 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)
-                             JSON_RPC::Response.new(id: response_id, error: error_hash)
-            when Integer
-                             # Build error from numeric code, allowing overrides from payload_obj
-                             error_code = error_input
-                             default_details = JSON_RPC::JsonRpcError.find_by_code(error_code)
-                             message_override = payload_obj.is_a?(Hash) ? payload_obj[:message] : nil
-                             data_override = payload_obj.is_a?(Hash) ? payload_obj[:data] : nil
-                             error_hash = {
-                               code: error_code,
-                               message: message_override || default_details&.fetch(:message, "Unknown error") # Use override, default, or generic
-                             }
-                             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}"
-            # # Original logic (removed): Treat payload_obj as the error hash
-            # JSON_RPC::Response.new(id: response_id, error: payload_obj)
-            else # Falsy (nil, false)
-                             # Treat payload_obj as the result
-                             JSON_RPC::Response.new(id: response_id, result: payload_obj)
-            end
-            response_payload = response_obj.to_h
+            payload =
+              case obj
+                # ─── Already JSON-RPC objects ───────────────────────────────
+              when JSON_RPC::Response,
+                JSON_RPC::Request,
+                JSON_RPC::Notification
+                obj.to_h
+
+                # ─── Batch of objects ──────────────────────────────────────
+              when Array
+                unless obj.all? { |o| o.is_a?(JSON_RPC::Response) ||
+                  o.is_a?(JSON_RPC::Request) ||
+                  o.is_a?(JSON_RPC::Notification) }
+                  raise ArgumentError, "Batch contains non-JSON-RPC objects"
+                end
+                obj.map(&:to_h)
+
+                # ─── Legacy “result + :error” path ─────────────────────────
+              else
+                case error_opt
+                when nil, false
+                  JSON_RPC::Response.new(id: response_id,
+                                         result: obj).to_h
+
+                when Symbol
+                  msg = obj.is_a?(Hash) ? obj[:message] : nil
+                  dat = obj.is_a?(Hash) ? obj[:data] : nil
+                  err = JSON_RPC::JsonRpcError.build(error_opt,
+                                                     message: msg,
+                                                     data: dat)
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: err).to_h
+
+                when Integer
+                  defaults = JSON_RPC::JsonRpcError.find_by_code(error_opt)
+                  msg = obj.is_a?(Hash) ? obj[:message] : nil
+                  msg ||= defaults&.fetch(:message, "Unknown error")
+
+                  dat = obj.is_a?(Hash) ? obj[:data] : nil
+                  hash = { code: error_opt, message: msg }
+                  hash[:data] = dat if dat
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: hash).to_h
+
+                when JSON_RPC::JsonRpcError
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: error_opt.to_h).to_h
+
+                when Hash
+                  JSON_RPC::Response.new(id: response_id,
+                                         error: error_opt).to_h
+
+                else
+                  raise ArgumentError,
+                        ":error must be Symbol, Integer, Hash, or JSON_RPC::JsonRpcError " \
+                          "(got #{error_opt.class})"
+                end
+              end
+
           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}")
-            response_payload = { jsonrpc: "2.0", error: internal_error.to_h, id: response_id }
-            # Consider logging the error e.message
+            internal = JSON_RPC::JsonRpcError.new(:internal_error,
+                                                  message: "Server error: #{e.message}")
+            payload = { jsonrpc: "2.0", error: internal.to_h, id: response_id }
+
           rescue JSON_RPC::JsonRpcError => e
-            # Handle specific JsonRpcError during Response processing (e.g., invalid error symbol)
-            response_payload = { jsonrpc: "2.0", error: e.to_h, id: response_id }
-            # Consider logging the error e.message
+            payload = { jsonrpc: "2.0", error: e.to_h, id: response_id }
           end
 
-
-          # Set the proper MIME type and convert the hash to JSON.
           self.content_type ||= Mime[:json]
-          self.response_body = response_payload.to_json
+          self.response_body = 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.3.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonrpc-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.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