jsonrpc-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a329937c7fecde34677567a8df15dab630b5062b30c01f1fcb825b25789e590
+  data.tar.gz: e7d7de880e9adc77839bb29feafdff54a35f56de555a68aa7e9d62413bf2d3fa
+SHA512:
+  metadata.gz: e98d92b3ea32b21fc6b1fafa766a0a9b3a60f9cd0475424753c486e62c872945dd105c0e64f91c9d0eba291918ec5bab6f5d3310d4039ed2b807c9c53d3f6291
+  data.tar.gz: b724be97e378604ede9244d90b76d93f07c0070a1e142ed0d3787c5d81e4df1dd8f1848a3d84fdd28096d6ae6cb7102e86780fe6c2b2fbabbf8a8e1fc8f0615b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+# jsonrpc-rails
+
+[![Gem Version](https://badge.fury.io/rb/jsonrpc-rails.svg)](https://badge.fury.io/rb/jsonrpc-rails)
+
+**jsonrpc-rails** is a Railtie-based gem that brings JSON-RPC 2.0 support to your Rails application.
+It integrates into Rails, allowing you to render JSON-RPC responses and validate incoming requests.
+
+## Features
+
+- **Rails Integration:** Easily integrate JSON-RPC 2.0 support via a Rails Railtie.
+- **Custom Renderer:** Render responses with `render jsonrpc:`, automatically wrapping data in the JSON-RPC 2.0 envelope.
+- **Error Handling:** Built-in support for both success and error responses according to the JSON-RPC 2.0 specification.
+- **Request Validation:** Includes middleware (`JSON_RPC_Rails::Middleware::Validator`) to strictly validate incoming JSON-RPC 2.0 requests (single and batch) against the specification structure.
+- **Rails 8+ Compatibility:** Designed specifically for Rails 8 and later versions.
+
+## Installation
+
+Add the following line to your application's Gemfile:
+
+```ruby
+gem 'jsonrpc-rails'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install it directly via:
+
+```bash
+gem install jsonrpc-rails
+```
+
+## Usage
+
+### Rendering Responses
+
+Once installed, **jsonrpc-rails** registers a custom renderer with Rails. 
+In your controllers, you can render JSON-RPC responses like so:
+
+```ruby
+class TestController < ApplicationController
+  def index
+    # Render a successful JSON-RPC response
+    render jsonrpc: { message: "Hello from JSON-RPC!" }, id: 1
+  end
+
+  def error_code
+    # Render an error using a numeric code (uses default message for standard codes)
+    render jsonrpc: {}, error: -32600, id: 5 # Invalid Request
+  end
+
+  def error_code_override
+    # Render an error using a numeric code, overriding the message and adding data
+    render jsonrpc: { message: "Specific invalid request", data: { field: "xyz" } }, error: -32600, id: 6
+  end
+end
+```
+
+The renderer wraps your data in the JSON-RPC 2.0 envelope:
+- **Success Response:**
+  ```json
+  { "jsonrpc": "2.0", "result": { ... }, "id": 1 }
+  ```
+- **Error Response (using numeric code):**
+  ```json
+  { "jsonrpc": "2.0", "error": { "code": -32600, "message": "Invalid Request" }, "id": 5 }
+  ```
+- **Error Response (using numeric code with override):**
+  ```json
+  { "jsonrpc": "2.0", "error": { "code": -32600, "message": "Specific invalid request", "data": { "field": "xyz" } }, "id": 6 }
+  ```
+
+To render an error response, pass a numeric error code or a predefined Symbol to the `error:` option:
+- **Numeric Code:** Pass the integer code directly (e.g., `error: -32600`). If the code is a standard JSON-RPC error code (`-32700`, `-32600` to `-32603`, `-32000`), a default message will be used (as shown in the `error_code` example).
+- **Symbol:** Pass a symbol corresponding to a standard error (e.g., `error: :invalid_request`). The gem will look up the code and default message. (See `lib/json_rpc/json_rpc_error.rb` for available symbols).
+
+You can override the default `message` or add `data` for either method by providing them in the main hash passed to `render jsonrpc:`, as demonstrated in the `error_code_override` example.
+
+### Handling Requests
+
+The gem automatically inserts `JSON_RPC_Rails::Middleware::Validator` into your application's middleware stack. This middleware performs the following actions for incoming **POST** requests with `Content-Type: application/json`:
+
+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.
+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
+class MyApiController < ApplicationController
+  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
+      else
+        head :no_content # No response for notification
+      end
+    end
+  end
+
+  private
+
+  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
+    else
+      nil # No response for notifications
+    end
+  end
+end
+```
+
+## Testing
+
+A dummy Rails application is included within the gem (located in `test/dummy`) to facilitate testing. You can run the tests from the **project root directory** by executing:
+
+```bash
+bundle exec rake test
+```
+
+The provided tests ensure that the renderer, middleware, and basic integration function correctly.
+
+## Contributing
+
+Contributions are very welcome! Feel free to fork the repository, make improvements, and submit pull requests. For bug reports or feature requests, please open an issue on GitHub:
+
+[https://github.com/seuros/jsonrpc-rails](https://github.com/seuros/jsonrpc-rails)
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+Happy coding with JSON-RPC in Rails!

data/Rakefile

@@ -0,0 +1,20 @@
+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.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"
+
+# Load other 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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module JSON_RPC
+  # Custom exception class for JSON-RPC errors, based on the JSON-RPC 2.0 specification.
+  class JsonRpcError < StandardError
+    # Define the standard JSON-RPC 2.0 error codes
+    ERROR_CODES = {
+      parse_error: {
+        code: -32_700,
+        message: "Parse error"
+      },
+      invalid_request: {
+        code: -32_600,
+        message: "Invalid Request"
+      },
+      method_not_found: {
+        code: -32_601,
+        message: "Method not found"
+      },
+      invalid_params: {
+        code: -32_602,
+        message: "Invalid params"
+      },
+      internal_error: {
+        code: -32_603,
+        message: "Internal error"
+      },
+      # Implementation-defined server-errors -32000 to -32099
+      server_error: {
+        code: -32_000,
+        message: "Server error"
+      }
+    }.freeze
+
+    # @return [Integer] The error code.
+    # @return [Object] The error data.
+    attr_reader :code, :data
+
+    # Retrieve error details by symbol.
+    #
+    # @param symbol [Symbol] The error symbol.
+    # @raise [ArgumentError] if the error code is unknown.
+    # @return [Hash] The error details.
+    def self.[](symbol)
+      ERROR_CODES[symbol] or raise ArgumentError, "Unknown error symbol: #{symbol}"
+    end
+
+    # Retrieve error details by code.
+    #
+    # @param code [Integer] The error code.
+    # @return [Hash, nil] The error details hash if found, otherwise nil.
+    def self.find_by_code(code)
+      ERROR_CODES.values.find { |details| details[:code] == code }
+    end
+
+    # Build an error hash, allowing custom message or data to override defaults.
+    #
+    # @param symbol [Symbol] The error symbol.
+    # @param message [String, nil] Optional custom message.
+    # @param data [Object, nil] Optional custom data.
+    # @return [Hash] The error hash.
+    def self.build(symbol, message: nil, data: nil)
+      error = self[symbol].dup
+      error[:message] = message if message
+      error[:data] = data if data
+      error
+    end
+
+    # Initialize the error using a symbol key, with optional custom message and data.
+    #
+    # @param symbol [Symbol] The error symbol.
+    # @param message [String, nil] Optional custom message.
+    # @param data [Object, nil] Optional custom data.
+    def initialize(symbol, message: nil, data: nil)
+      error_details = self.class.build(symbol, message: message, data: data)
+      @code = error_details[:code]
+      @data = error_details[:data]
+      super(error_details[:message])
+    end
+
+    # Returns a hash formatted for a JSON-RPC error response object (the value of the 'error' key).
+    #
+    # @return [Hash] The error hash.
+    def to_h
+      hash = { code: code, message: message }
+      hash[:data] = data if data
+      hash
+    end
+  end
+end

data/lib/json_rpc/notification.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JSON_RPC
+  # Represents a JSON-RPC notification.
+  Notification = Data.define(:method, :params) do
+    # Initializes a new Notification.
+    #
+    # @param method [String] The method name.
+    # @param params [Hash, Array, nil] The parameters (optional). Structured value.
+    def initialize(method:, params: nil)
+      # Basic validation could be added here if needed, e.g., method is a non-empty string.
+      super
+    end
+
+    # Returns a hash representation of the notification, ready for JSON serialization.
+    #
+    # @return [Hash] The hash representation.
+    def to_h
+      hash = {
+        "jsonrpc" => "2.0",
+        method: method
+      }
+      # Include params only if it's not nil, as per JSON-RPC spec
+      hash[:params] = params unless params.nil?
+      hash
+    end
+  end
+end

data/lib/json_rpc/request.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module JSON_RPC
+  # Represents a JSON-RPC request object.
+  Request = Data.define(:id, :method, :params) do
+    # Initializes a new Request.
+    #
+    # @param id [String, Numeric, nil] The request identifier. Should be String or Numeric according to spec for requests needing a response. Can be nil.
+    # @param method [String] The method name.
+    # @param params [Hash, Array, nil] The parameters (optional). Structured value.
+    # @raise [JSON_RPC::JsonRpcError] if the ID type is invalid.
+    def initialize(id:, method:, params: nil)
+      # Basic validation for ID type (String, Numeric, or null allowed by spec)
+      validate_id_type(id)
+      # Basic validation for method (e.g., non-empty string) could be added.
+      super
+    end
+
+    # Returns a hash representation of the request, ready for JSON serialization.
+    #
+    # @return [Hash] The hash representation.
+    def to_h
+      hash = {
+        "jsonrpc" => "2.0",
+        id: id, # Include id even if null, spec allows null id
+        method: method
+      }
+      # Include params only if it's not nil
+      hash[:params] = params unless params.nil?
+      hash
+    end
+
+    private
+
+    # Validates the ID type according to JSON-RPC 2.0 spec.
+    # Allows String, Numeric, or null.
+    #
+    # @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
+    end
+  end
+end

data/lib/json_rpc/response.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module JSON_RPC
+  # Represents a JSON-RPC response object.
+  Response = Data.define(:id, :result, :error) do
+    # Initializes a new Response.
+    #
+    # @param id [String, Numeric, nil] The request identifier. Must match the request ID.
+    # @param result [Object, nil] The result data (if successful).
+    # @param error [Hash, JSON_RPC::JsonRpcError, Symbol, nil] The error object/symbol (if failed).
+    # @raise [ArgumentError] if both result and error are provided, or neither is provided for non-null id.
+    def initialize(id:, result: nil, error: nil)
+      validate_response(id, result, error)
+      error_obj = process_error(error)
+      super(id: id, result: result, error: error_obj)
+    end
+
+    # Returns a hash representation of the response, ready for JSON serialization.
+    #
+    # @return [Hash] The hash representation.
+    def to_h
+      hash = { "jsonrpc" => "2.0", id: id }
+      if error
+        hash[:error] = error # error is already a hash here
+      else
+        # Result must be included, even if null, for successful responses
+        hash[:result] = result
+      end
+      hash
+    end
+
+    private
+
+    # Validates the response structure according to JSON-RPC 2.0 spec.
+    #
+    # @param id [Object] The request ID.
+    # @param result [Object] The result data.
+    # @param error_input [Object] The error data/object/symbol.
+    # @raise [ArgumentError] for invalid combinations.
+    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
+
+      # 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
+    end
+
+    # Processes the error input into a standard error hash.
+    #
+    # @param error_input [Hash, JSON_RPC::JsonRpcError, Symbol, nil] The error information.
+    # @return [Hash, nil] The formatted error hash or nil.
+    def process_error(error_input)
+      case error_input
+      when nil
+        nil
+      when JSON_RPC::JsonRpcError
+        error_input.to_h
+      when Hash
+        # Assume it's already a valid JSON-RPC error object hash
+        error_input
+      when Symbol
+        # Build from a standard error symbol
+        JSON_RPC::JsonRpcError.build(error_input)
+      else
+        # Fallback to internal error if the format is unexpected
+        JSON_RPC::JsonRpcError.build(:internal_error, message: "Invalid error format provided").to_h
+      end
+    end
+  end
+end

data/lib/jsonrpc-rails.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "jsonrpc_rails/railtie"
+
+require_relative "json_rpc/json_rpc_error"
+require_relative "json_rpc/request"
+require_relative "json_rpc/response"
+require_relative "json_rpc/notification"
+
+# Define the top-level module for the gem (optional, but good practice)
+module JSON_RPC_Rails
+  # You might add gem-level configuration or methods here if needed later.
+end

data/lib/jsonrpc_rails/middleware/validator.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "json"
+
+module JSON_RPC_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.
+    #
+    # 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.
+    class Validator
+      CONTENT_TYPE = "application/json"
+      ENV_PAYLOAD_KEY = "jsonrpc.payload"
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Only process POST requests with the correct Content-Type
+        unless request.post? && request.content_type&.start_with?(CONTENT_TYPE)
+          return @app.call(env)
+        end
+
+        # Read and parse the request body
+        body = request.body.read
+        request.body.rewind # Rewind body for potential downstream middleware/apps
+        payload = parse_json(body)
+
+        # Handle JSON parsing errors
+        return jsonrpc_error_response(:parse_error) unless payload
+
+        # Only attempt JSON-RPC validation if payload is a Hash or Array
+        unless payload.is_a?(Hash) || payload.is_a?(Array)
+          # Pass through other valid JSON types (string, number, boolean, null)
+          return @app.call(env)
+        end
+
+        # Payload is Hash or Array, proceed with JSON-RPC validation
+        is_batch = payload.is_a?(Array)
+        # validate_batch handles the empty array case internally now
+        validation_result, _ = is_batch ? validate_batch(payload) : validate_single(payload)
+
+        # If validation failed, return the generated error response
+        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
+
+      # Removed jsonrpc_payload? method
+
+      # Parses the JSON body string. Returns parsed data or nil on failure.
+      def parse_json(body)
+        return nil if body.nil? || body.strip.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        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_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/Float), or Null if present
+        if obj.key?("id") && ![ String, Integer, Float, NilClass ].include?(obj["id"].class)
+          return false
+        end
+
+        # Check for extraneous keys
+        allowed_keys = %w[jsonrpc method params id]
+        return false unless (obj.keys - allowed_keys).empty?
+
+        true # Structure is valid
+      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) }
+
+        # 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 ]
+      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
+        else
+                      JSON_RPC::JsonRpcError.new(error_type)
+        end
+
+        response_body = {
+          jsonrpc: "2.0",
+          error: error_obj.to_h,
+          id: nil # Middleware errors have null id
+        }.to_json
+
+        [
+          status,
+          { "Content-Type" => CONTENT_TYPE },
+          [ response_body ]
+        ]
+      end
+    end
+  end
+end

data/lib/jsonrpc_rails/railtie.rb

@@ -0,0 +1,69 @@
+require_relative "middleware/validator"
+
+module JSON_RPC_Rails
+  # Use Rails::Railtie to integrate with the Rails application
+  class Railtie < Rails::Railtie
+    # 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 JSON_RPC_Rails::Middleware::Validator
+    end
+
+    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
+
+          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
+          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
+          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
+          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
+  end
+end

data/lib/jsonrpc_rails/version.rb

@@ -0,0 +1,3 @@
+module JSON_RPC_Rails
+    VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: jsonrpc-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+bindir: bin
+cert_chain: []
+date: 2025-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+description: Integrates into Rails, allowing you to render JSON-RPC responses and
+  validate incoming requests according to the JSON-RPC 2.0 specification. Includes
+  middleware for strict request validation and a custom renderer. Designed for Rails
+  8+.
+email:
+- terminale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/json_rpc/json_rpc_error.rb
+- lib/json_rpc/notification.rb
+- lib/json_rpc/request.rb
+- lib/json_rpc/response.rb
+- lib/jsonrpc-rails.rb
+- lib/jsonrpc_rails/middleware/validator.rb
+- lib/jsonrpc_rails/railtie.rb
+- lib/jsonrpc_rails/version.rb
+homepage: https://github.com/seuros/jsonrpc-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seuros/jsonrpc-rails
+  source_code_uri: https://github.com/seuros/jsonrpc-rails
+  changelog_uri: https://github.com/seuros/jsonrpc-rails/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: A Railtie-based gem that brings JSON-RPC 2.0 support to your Rails application.
+test_files: []