jsonrpc-middleware 0.1.0

data/lib/jsonrpc/validator.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module JSONRPC
+  # Validates JSON-RPC 2.0 requests and notifications.
+  class Validator
+    # Validates a single request, notification or a batch of requests and/or notifications.
+    #
+    # @param [JSONRPC::BatchRequest, JSONRPC::Request, JSONRPC::Notification] batch_or_request
+    #
+    # @example Validate a single request
+    #   validator = JSONRPC::Validator.new
+    #   error = validator.validate(request)
+    #
+    # @example Validate a batch of requests
+    #   validator = JSONRPC::Validator.new
+    #   errors = validator.validate(batch)
+    #
+    # @return [JSONRPC::Error, Array<JSONRPC::Error>, nil]
+    #
+    def validate(batch_or_request)
+      case batch_or_request
+      when BatchRequest
+        validate_batch_params(batch_or_request)
+      when Request, Notification
+        validate_request_params(batch_or_request)
+      end
+    end
+
+    private
+
+    def validate_batch_params(batch)
+      errors = batch.map { |req| validate_request_params(req) }
+
+      # Return the array of errors (with nil for successful validations)
+      # If all validations passed, return nil
+      errors.any? ? errors : nil
+    end
+
+    # @param [Request, Notification] request_or_notification
+    def validate_request_params(request_or_notification)
+      config = JSONRPC.configuration
+
+      unless config.procedure?(request_or_notification.method)
+        return MethodNotFoundError.new(
+          request_id: extract_request_id(request_or_notification),
+          data: {
+            method: request_or_notification.method
+          }
+        )
+      end
+
+      procedure = config.get_procedure(request_or_notification.method)
+
+      # Determine params to validate based on procedure configuration
+      params_to_validate = prepare_params_for_validation(request_or_notification, procedure)
+
+      # If params preparation failed, return error
+      return params_to_validate if params_to_validate.is_a?(InvalidParamsError)
+
+      # Validate the parameters
+      validation_result = procedure.contract.call(params_to_validate)
+
+      unless validation_result.success?
+        return InvalidParamsError.new(
+          request_id: extract_request_id(request_or_notification),
+          data: {
+            method: request_or_notification.method,
+            params: validation_result.errors.to_h
+          }
+        )
+      end
+
+      nil
+    rescue StandardError => e
+      if ENV['DEBUG_RACK'] == 'true'
+        puts "Validation error: #{e.message}"
+        puts e.backtrace.join("\n")
+      end
+
+      InternalError.new(request_id: extract_request_id(request_or_notification))
+    end
+
+    def prepare_params_for_validation(request, procedure)
+      if procedure.allow_positional_arguments
+        handle_positional_arguments(request, procedure)
+      else
+        handle_named_arguments(request)
+      end
+    end
+
+    def handle_positional_arguments(request_or_notification, procedure)
+      case request_or_notification.params
+      when Array
+        # Convert positional to named parameters if procedure has a parameter name
+        if procedure.parameter_name
+          { procedure.parameter_name => request_or_notification.params }
+        else
+          {}
+        end
+      when Hash
+        # Named parameters are also allowed when positional arguments are enabled
+        request_or_notification.params
+      when nil
+        # Missing params - let the contract validation handle it
+        {}
+      else
+        # Invalid params type (not Array, Hash, or nil)
+        InvalidParamsError.new(
+          request_id: extract_request_id(request_or_notification),
+          data: { method: request_or_notification.method }
+        )
+      end
+    end
+
+    def handle_named_arguments(request_or_notification)
+      case request_or_notification.params
+      when Hash
+        request_or_notification.params
+      when nil
+        # Missing params - let the contract validation handle it
+        {}
+      else
+        # Invalid params type and positional arguments aren't allowed for this procedure
+        InvalidParamsError.new(
+          request_id: extract_request_id(request_or_notification),
+          data: { method: request_or_notification.method }
+        )
+      end
+    end
+
+    def extract_request_id(request_or_notification)
+      case request_or_notification
+      when Request
+        request_or_notification.id
+      when Notification
+        nil
+      end
+    end
+  end
+end

data/lib/jsonrpc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JSONRPC
+  VERSION = '0.1.0'
+end

data/lib/jsonrpc.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'dry-validation'
+
+Dry::Validation.load_extensions(:predicates_as_macros)
+
+# Encapsulates all the gem's logic
+module JSONRPC
+  def self.configure(&)
+    Configuration.instance.instance_eval(&)
+  end
+
+  def self.configuration
+    Configuration.instance
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.log! if ENV['DEBUG_ZEITWERK'] == 'true'
+loader.enable_reloading
+loader.collapse("#{__dir__}/jsonrpc/errors")
+loader.inflector.inflect('jsonrpc' => 'JSONRPC')
+loader.setup
+loader.eager_load

data/sig/jsonrpc/middleware.rbs

@@ -0,0 +1,6 @@
+module JSONRPC
+  module Middleware
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/sig/jsonrpc/parser.rbs

@@ -0,0 +1,7 @@
+module JSONRPC
+  class Parser
+    private
+
+    def parse_batch: (Array[Request | Notification] data) -> BatchRequest
+  end
+end

data/sig/jsonrpc.rbs

@@ -0,0 +1,164 @@
+module JSONRPC
+  VERSION: String
+
+  # Method definitions that should be available
+  interface _ToJson
+    def to_json: (*untyped) -> String
+  end
+
+  interface _HashLike
+    def []: (Symbol) -> untyped
+    def []=: (Symbol, untyped) -> untyped
+  end
+
+  # Representing JSON-compatible types
+  type json_scalar = String | Integer | Float | bool | nil
+  type json_object = Hash[String, json_value]
+  type json_array = Array[json_value]
+  type json_value = json_scalar | json_object | json_array
+
+  # Common types used across the library
+  type params_type = Hash[untyped, untyped] | Array[untyped] | nil
+  type id_type = String | Integer | nil
+  type data_type = Hash[untyped, untyped] | Array[untyped] | String | Numeric | bool | nil
+
+  # Hash with Symbol keys
+  type symbol_hash = Hash[Symbol, untyped] & _ToJson
+
+  class Error < StandardError
+    attr_reader code: Integer
+    attr_reader message: String
+    attr_reader data: data_type
+    attr_accessor request_id: Integer | String | nil
+
+    def initialize: (code: Integer, message: String, ?data: data_type, ?request_id: id_type) -> void
+    def to_h: -> symbol_hash
+    def to_json: (*untyped) -> String
+
+    private
+
+    def validate_code: (Integer) -> void
+    def validate_message: (String) -> void
+  end
+
+  class ParseError < Error
+    def initialize: (?data: data_type, ?request_id: id_type) -> void
+  end
+
+  class InvalidRequestError < Error
+    def initialize: (?data: data_type, ?request_id: id_type) -> void
+  end
+
+  class MethodNotFoundError < Error
+    def initialize: (?data: data_type, ?request_id: id_type) -> void
+  end
+
+  class InvalidParamsError < Error
+    def initialize: (?data: data_type, ?request_id: id_type) -> void
+  end
+
+  class InternalError < Error
+    def initialize: (?data: data_type, ?request_id: id_type) -> void
+  end
+
+  class Request
+    attr_reader jsonrpc: String
+    attr_reader method: String
+    attr_reader params: params_type
+    attr_reader id: id_type
+
+    def initialize: (method: String, ?params: params_type, id: id_type) -> void
+    def to_h: -> symbol_hash
+    def to_json: (*untyped) -> String
+
+    private
+
+    def validate_method: (String) -> void
+    def validate_params: (params_type) -> void
+    def validate_id: (id_type) -> void
+  end
+
+  class Response
+    attr_reader jsonrpc: String
+    attr_reader result: untyped
+    attr_reader error: Error?
+    attr_reader id: id_type
+
+    def initialize: (?result: untyped, ?error: Error?, id: id_type) -> void
+    def success?: -> bool
+    def error?: -> bool
+    def to_h: -> symbol_hash
+    def to_json: (*untyped) -> String
+
+    private
+
+    def validate_result_and_error: (untyped, Error?) -> void
+    def validate_id: (id_type) -> void
+  end
+
+  class Notification
+    attr_reader jsonrpc: String
+    attr_reader method: String
+    attr_reader params: params_type
+
+    def initialize: (method: String, ?params: params_type) -> void
+    def to_h: -> symbol_hash
+    def to_json: (*untyped) -> String
+
+    private
+    def validate_method: (String) -> void
+    def validate_params: (params_type) -> void
+  end
+
+  class BatchRequest
+    include Enumerable[Request | Notification]
+
+    attr_reader requests: Array[Request | Notification]
+
+    def initialize: (Array[Request | Notification]) -> void
+    def to_h: -> Array[symbol_hash]
+    def to_json: (*untyped) -> String
+    def each: () { (Request | Notification) -> void } -> self
+      | () -> Enumerator[Request | Notification, self]
+
+    private
+
+    def validate_requests: (Array[untyped]) -> void
+  end
+
+  class BatchResponse
+    include Enumerable[Response]
+
+    attr_reader responses: Array[Response]
+
+    def initialize: (Array[Response]) -> void
+    def to_h: -> Array[symbol_hash]
+    def to_json: (*untyped) -> String
+    def each: () { (Response) -> void } -> self
+      | () -> Enumerator[Response, self]
+
+    private
+
+    def validate_responses: (Array[untyped]) -> void
+  end
+
+  module Errors
+    class Error = JSONRPC::Error
+  end
+end
+
+# External library signatures
+module Zeitwerk
+  class Loader
+    def self.for_gem: () -> Loader
+    def enable_reloading: () -> void
+    def collapse: (String) -> void
+    def setup: () -> void
+    def eager_load: () -> void
+  end
+end
+
+module JSON
+  def self.parse: (String, ?untyped) -> untyped
+  def self.generate: (untyped, ?untyped) -> String
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: jsonrpc-middleware
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wilson Silva
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: Implements the JSON-RPC 2.0 protocol, enabling standardized remote procedure
+  calls encoded in JSON.
+email:
+- wilson.dsigns@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/settings.local.json"
+- ".editorconfig"
+- ".overcommit.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- ".yardstick.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- docs/JSON-RPC-2.0-Specification.md
+- examples/procedures.rb
+- examples/rack-echo/Gemfile
+- examples/rack-echo/Gemfile.lock
+- examples/rack-echo/README.md
+- examples/rack-echo/app.rb
+- examples/rack-echo/config.ru
+- examples/rack/Gemfile
+- examples/rack/Gemfile.lock
+- examples/rack/README.md
+- examples/rack/app.rb
+- examples/rack/config.ru
+- lib/jsonrpc.rb
+- lib/jsonrpc/batch_request.rb
+- lib/jsonrpc/batch_response.rb
+- lib/jsonrpc/configuration.rb
+- lib/jsonrpc/error.rb
+- lib/jsonrpc/errors/internal_error.rb
+- lib/jsonrpc/errors/invalid_params_error.rb
+- lib/jsonrpc/errors/invalid_request_error.rb
+- lib/jsonrpc/errors/method_not_found_error.rb
+- lib/jsonrpc/errors/parse_error.rb
+- lib/jsonrpc/helpers.rb
+- lib/jsonrpc/middleware.rb
+- lib/jsonrpc/notification.rb
+- lib/jsonrpc/parser.rb
+- lib/jsonrpc/request.rb
+- lib/jsonrpc/response.rb
+- lib/jsonrpc/validator.rb
+- lib/jsonrpc/version.rb
+- sig/jsonrpc.rbs
+- sig/jsonrpc/middleware.rbs
+- sig/jsonrpc/parser.rbs
+homepage: https://github.com/wilsonsilva/jsonrpc-middleware
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/wilsonsilva/jsonrpc-middleware
+  source_code_uri: https://github.com/wilsonsilva/jsonrpc-middleware
+  changelog_uri: https://github.com/wilsonsilva/jsonrpc-middleware/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Implementation of the JSON-RPC protocol.
+test_files: []