jsonrpc_interface 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4a8bb604718da7dc4c8a9277737d334e61ce4cac8854102b863679e1c78d5f6
-  data.tar.gz: 9a3865cd9a55bf84528d8c3a3155a949d5c75c1a46a8df26fa56fa6c63dc5aab
+  metadata.gz: 25256ea9e6e7e75cb545b1d76c443678e06a4a7e94f055c0288abd3a368dde63
+  data.tar.gz: 3984365f41a8f2629011e9144df1c3f2ec421fa02f9e582517db74a5bb95f404
 SHA512:
-  metadata.gz: 9af958fa2a646589d9503b23d50c787366b6a40717ebe61cabbc6334cbf96d03f28deb8c9ab9c3ac4c883f6072f3ba4a61c28576adf9fa8b125040104950ddf0
-  data.tar.gz: 7cb788b359de7b8433172db8f9f2d8ea9f7f4a47cf640f05446ceda363d50cbbbb01d0c861eb1910a10e3cf1854c5ad4d07bd5279763caefa553d48e5dd66028
+  metadata.gz: eb0dde16f67f210bd10fe6c226c8cf9e421d5a12a5b5c894ac8e2687d8aa8f26375c675dfd000b7df12304e762c6e04f534dd8cc6b9ad547a3ee6b7787c18d28
+  data.tar.gz: a92f486f02ac219400b4b6aa083fd7c7e09ec4057645b8f0eaa98bb60bbab63d4172f2c71d7c1b369106459332053772b311ed7a7d6e1ddeb743d8077130e70b

data/.gitignore

@@ -9,3 +9,4 @@
 .rspec_status
 .ruby-version
 *.gem
+/.gem_rbs_collection/

data/.rubocop.yml

@@ -12,5 +12,10 @@ AllCops:
     - spec/**/*.rb
     - Gemfile
     - Rakefile
+    - Steepfile
     - jsonrpc_interface.gemspec
     - bin/console
+
+Rake/Desc:
+  Exclude:
+    - Rakefile

data/CHANGELOG.md

@@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
-## [0.0.1] - 2023-05-028
+## [0.1.0] - 2023-06-25
+
+- Release;
+
+## [0.0.1] - 2023-05-28
 
 - Placement of the gem on RubyGems.org;

data/Gemfile.lock

@@ -2,6 +2,9 @@ PATH
   remote: .
   specs:
     jsonrpc_interface (0.1.0)
+      smart_schema (~> 0.11)
+      smart_types (~> 0.8)
+      smart_value-object (~> 0.2)
 
 GEM
   remote: https://rubygems.org/
@@ -22,23 +25,38 @@ GEM
     ast (2.4.2)
     coderay (1.1.3)
     concurrent-ruby (1.2.2)
+    csv (3.2.6)
     diff-lcs (1.5.0)
     docile (1.4.0)
-    i18n (1.13.0)
+    ffi (1.15.5)
+    fileutils (1.7.1)
+    i18n (1.14.1)
       concurrent-ruby (~> 1.0)
     json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    listen (3.8.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.3)
     method_source (1.0.0)
     minitest (5.18.0)
     parallel (1.23.0)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
+      racc
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    qonfig (0.28.0)
+    racc (1.7.0)
     rack (3.0.7)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.8.0)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rbs (3.1.0)
+    regexp_parser (2.8.1)
     rexml (3.2.5)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -63,7 +81,7 @@ GEM
       rubocop-ast (>= 1.28.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.28.1)
+    rubocop-ast (1.29.0)
       parser (>= 3.2.1.0)
     rubocop-capybara (2.18.0)
       rubocop (~> 1.41)
@@ -83,12 +101,43 @@ GEM
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
     ruby-progressbar (1.13.0)
+    securerandom (0.2.2)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    smart_engine (0.17.0)
+    smart_initializer (0.11.1)
+      qonfig (~> 0.24)
+      smart_engine (~> 0.16)
+      smart_types (~> 0.8)
+    smart_schema (0.11.0)
+      smart_engine (~> 0.17)
+      smart_types (~> 0.8)
+    smart_types (0.8.0)
+      smart_engine (~> 0.11)
+    smart_value-object (0.2.0)
+      smart_initializer (~> 0.5)
+    steep (1.4.0)
+      activesupport (>= 5.1)
+      concurrent-ruby (>= 1.2.2)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      logger (>= 1.3.0)
+      parser (>= 3.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 2.8.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
+      terminal-table (>= 2, < 4)
+    strscan (3.0.6)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.4.2)
@@ -102,8 +151,10 @@ DEPENDENCIES
   jsonrpc_interface!
   pry (~> 0.14)
   rake (~> 13.0)
+  rbs (~> 3.1)
   rspec (~> 3.12)
   simplecov (~> 0.22)
+  steep (~> 1.4)
 
 BUNDLED WITH
    2.4.13

data/README.md

@@ -1 +1,328 @@
 # JSONRPC Interface
+
+JRPC Request, JRPC Notification, JRPC Response, JRPC Error Response, JRPC Object Builder and JRPC Error Codes in Object Oriented Way.
+
+---
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Development](#development)
+- [License](#license)
+- [Authors](#authors)
+
+## Installation
+
+```ruby
+gem 'jsonrpc_interface'
+```
+
+```shell
+bundle install
+# --- or ---
+gem install jsonrpc_interface
+```
+
+```ruby
+require 'jsonrpc_interface'
+```
+
+## Usage
+
+- [JSONRPC::ERRORS](#jsonrpcerrors)
+- [JSONRPC::Request](#jsonrpcrequest)
+  - [Schema](#jsonrpcrequestschema)
+- [JSONRPC::Notification](#jsonrpcnotification)
+  - [Schema](#jsonrpcnotificationschema)
+- [JSONRPC::Response](#jsonrpcresponse)
+- [JSONRPC::ErrorResponse](#jsonrpcerrorresponse)
+  - [Schema](#jsonrpcerrorresponseschema)
+- [JSONRPC::RPCObject](#jsonrpcrpcobject)
+  - [.response](#response)
+  - [.request](#request)
+  - [.notification](#notification)
+  - [.invalid_request_error](#invalid_request_error)
+  - [.parse_error](#parse_error)
+  - [.jsonrpc_specification_violation_error](#jsonrpc_specification_violation_error)
+  - [.method_not_found_error](#method_not_found_error)
+  - [.invalid_params_error](#invalid_params_error)
+  - [.internal_error](#internal_error)
+  - [.detailed_internal_error](#detailed_internal_error)
+
+---
+
+### JSONRPC::ERRORS
+
+```ruby
+JSONRPC::ERRORS
+# =>
+{
+  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' },
+  unauthorized: { code: -33_001, message: 'Unauthorized' },
+  application_error: { code: -33_002, message: 'Application Error' },
+  jsonrpc_specification_violation: { code: -33_003, message: 'JSONRPC Specification Violation' }
+}
+```
+
+---
+
+### JSONRPC::Request
+
+```ruby
+JSONRPC::Request
+JSONRPC::Request.new(jsonrpc: '2.0', method: 'some.method', params: { some: 'params' }, id: 'sOmEiD')
+JSONRPC::Request#jsonrpc (String)
+JSONRPC::Request#method (String)
+JSONRPC::Request#params (Hash)
+JSONRPC::Request#id (String)
+```
+
+### JSONRPC::Request::Schema
+
+```ruby
+schema do
+  required(:jsonrpc).type(:string).filled
+  required(:method).type(:string).filled
+  required(:params).type(:hash).filled
+  required(:id).type(:string).filled
+end
+```
+
+---
+
+### JSONRPC::Notification
+
+```ruby
+JSONRPC::Notification
+JSONRPC::Notification.new(jsonrpc: '2.0', method: 'some.method', params: { some: 'params' })
+JSONRPC::Notification#jsonrpc (String)
+JSONRPC::Notification#method (String)
+JSONRPC::Notification#params (Hash)
+```
+
+### JSONRPC::Notification::Schema
+
+```ruby
+schema do
+  required(:jsonrpc).type(:string).filled
+  required(:method).type(:string).filled
+  required(:params).type(:hash).filled
+end
+```
+
+---
+
+### JSONRPC::Response
+
+```ruby
+JSONRPC::Response
+JSONRPC::Response.new(jsonrpc: '2.0', result: { some: 'result' }, id: 'sOmEiD')
+JSONRPC::Response#jsonrpc (String)
+JSONRPC::Response#result (Hash)
+JSONRPC::Response#id (String)
+```
+
+---
+
+### JSONRPC::ErrorResponse
+
+```ruby
+JSONRPC::ErrorResponse
+JSONRPC::ErrorResponse.new(jsonrpc: '2.0', method: 'some.method', params: { some: 'params' }, id: nil)
+JSONRPC::ErrorResponse.new(jsonrpc: '2.0', method: 'some.method', params: { some: 'params' }, id: 'sOmEiD')
+JSONRPC::ErrorResponse#jsonrpc (String)
+JSONRPC::ErrorResponse#error (Hash)
+JSONRPC::ErrorResponse#id (String, NilClass)
+
+JSONRPC::ErrorResponse#error
+# signature =>
+{ code: Integer, message: String, data: Hash }
+```
+
+### JSONRPC::ErrorResponse::Schema
+
+```ruby
+schema do
+  required(:code).type(:integer).filled
+  required(:message).type(:string).filled
+  required(:data).type(:hash).filled
+end
+```
+
+---
+
+### JSONRPC::RPCObject
+
+- [.response](#response)
+- [.request](#request)
+- [.notification](#notification)
+- [.invalid_request_error](#invalid_request_error)
+- [.parse_error](#parse_error)
+- [.jsonrpc_specification_violation_error](#jsonrpc_specification_violation_error)
+- [.method_not_found_error](#method_not_found_error)
+- [.invalid_params_error](#invalid_params_error)
+- [.internal_error](#internal_error)
+- [.detailed_internal_error](#detailed_internal_error)
+
+### .response
+
+```ruby
+JSONRPC::RPCObject.response(
+  { some: 'data' },
+  request_id: SecureRandom.uuid
+) # => JSONRPC::Response
+```
+
+### .request
+
+
+```ruby
+JSONRPC::RPCObject.request(
+  method: 'some.method',
+  params: { some: 'params' },
+  request_id: SecureRandom.uuid
+) # => JSONRPC::Request
+```
+
+### .notification
+
+```ruby
+JSONRPC::RPCObject.notification(
+  method: 'some.method',
+  params: { some: 'params' }
+) # => JSONRPC::Notification
+```
+
+### .invalid_request_error
+
+```ruby
+JSONRPC::RPCObject.invalid_request_error({ some: 'data' })
+JSONRPC::RPCObject.invalid_request_error({ some: 'data' }, request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{ code: -32_600, message: 'Invalid Request', data: { some: 'data' } }
+```
+
+### .parse_error
+
+```ruby
+JSONRPC::RPCObject.parse_error
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{ code: -32_700, message: 'Parse Error', data: {} }
+```
+
+### .jsonrpc_specification_violation_error
+
+```ruby
+JSONRPC::RPCObject.jsonrpc_specification_violation_error
+JSONRPC::RPCObject.jsonrpc_specification_violation_error(request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{ code: -33_003, message: 'JSONRPC Specification Violation', data: {} }
+```
+
+### .method_not_found_error
+
+```ruby
+JSONRPC::RPCObject.method_not_found_error
+JSONRPC::RPCObject.method_not_found_error(request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{ code: -32_601, message: 'Method Not Found', data: {} }
+```
+
+### .invalid_params_error
+
+```ruby
+JSONRPC::RPCObject.invalid_params_error
+JSONRPC::RPCObject.invalid_params_error(request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{ code: -32_602, message: 'Invalid Params', data: {} }
+```
+
+### .internal_error
+
+```ruby
+JSONRPC::RPCObject.internal_error('some', 'error', 'code', error_context: { some: 'context' })
+JSONRPC::RPCObject.internal_error('some', 'error', 'code', error_context: { some: 'context' }, request_id: SecureRandom.uuid)
+JSONRPC::RPCObject.internal_error
+JSONRPC::RPCObject.internal_error(request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# error hash signature =>
+{
+  code: -32_603,
+  message: 'Internal Error',
+  data: {
+    error_codes: ['some', 'error', 'code'],
+    error_cotnext: { some: 'context' }
+  }
+}
+```
+
+### .detailed_internal_error
+
+```ruby
+JSONRPC::RPCObject.detailed_internal_error(exception)
+JSONRPC::RPCObject.detailed_internal_error(exception, request_id: SecureRandom.uuid)
+
+JSONRPC::ErrorResponse#error
+# signature =>
+{
+  code: -32_603,
+  message: 'Internal Error',
+  data: {
+    error_codes: [],
+    error_cotnext: {
+      error_class: # => exception.class,
+      error_message: # => exception.message,
+      error_backtrace: # => exception.backtrace,
+      error_object: # => exception
+    }
+  }
+}
+```
+
+## Development
+
+- full build (`steep` => `rubocop` => `rspec`)
+
+```shell
+bundle exec rake
+```
+
+- code style check (`rubocop`):
+
+```shell
+bundle exec rake rubocop
+```
+
+- type validation check (`steep`):
+
+```shell
+bundle exec rake steep
+```
+
+- tests (`rspec`):
+
+```shell
+bundle exec rake rspec
+```
+
+## License
+
+Released under MIT License.
+
+## Authors
+
+[Rustam Ibragimov](https://github.com/0exp)

data/Rakefile

@@ -7,6 +7,8 @@ require 'rubocop/rake_task'
 require 'rubocop-performance'
 require 'rubocop-rspec'
 require 'rubocop-rake'
+require 'steep'
+require 'steep/cli'
 
 RuboCop::RakeTask.new(:rubocop) do |t|
   config_path = File.expand_path(File.join('.rubocop.yml'), __dir__)
@@ -18,4 +20,8 @@ end
 
 RSpec::Core::RakeTask.new(:rspec)
 
-task default: :rspec
+task :steep do
+  Steep::CLI.new(argv: ['check'], stdout: STDOUT, stderr: STDERR, stdin: STDIN).run
+end
+
+task default: %w[steep rubocop rspec]

data/Steepfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature 'sig'
+  check 'lib'
+  configure_code_diagnostics(Steep::Diagnostic::Ruby.strict)
+end

data/jsonrpc_interface.gemspec

@@ -11,7 +11,10 @@ Gem::Specification.new do |spec|
   spec.email   = ['iamdaiver@gmail.com']
 
   spec.summary     = 'JSONRPC Interface for Ruby projects.'
-  spec.description = 'JSONRPC Interface for Ruby projects realised in object oriented way.'
+  spec.description = 'JSONRPC Interface for Ruby projects realised in object oriented way. ' \
+                     'JRPC Request, JRPC Notification, JRPC Response, JRPC Error Response, ' \
+                     'JRPC Object Builder and JRPC Error Codes.'
+
   spec.homepage    = 'https://github.com/0exp/jsonrpc_interface'
   spec.license     = 'MIT'
 
@@ -27,10 +30,16 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'smart_schema',       '~> 0.11'
+  spec.add_dependency 'smart_types',        '~> 0.8'
+  spec.add_dependency 'smart_value-object', '~> 0.2'
+
   spec.add_development_dependency 'bundler',          '~> 2.4'
   spec.add_development_dependency 'rake',             '~> 13.0'
   spec.add_development_dependency 'rspec',            '~> 3.12'
   spec.add_development_dependency 'armitage-rubocop', '~> 1.51'
   spec.add_development_dependency 'simplecov',        '~> 0.22'
   spec.add_development_dependency 'pry',              '~> 0.14'
+  spec.add_development_dependency 'steep',            '~> 1.4'
+  spec.add_development_dependency 'rbs',              '~> 3.1'
 end

data/lib/jsonrpc/error_response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+class JSONRPC::ErrorResponse < SmartCore::ValueObject
+  # @return [SmartCore::Schema]
+  #
+  # @api public
+  # @since 0.1.0
+  ErrorSchema = Class.new(SmartCore::Schema) do
+    schema do
+      required(:code).type(:integer).filled
+      required(:message).type(:string).filled
+      required(:data).type(:hash).filled
+    end
+  end.new
+
+  # @api public
+  # @since 0.1.0
+  SmartCore::Types::Value.define_type(:JSONRPCErrorSchema) do |type|
+    type.define_checker { |value| ErrorSchema.valid?(value) }
+  end
+
+  # @api public
+  # @since 0.1.0
+  property :jsonrpc, SmartCore::Types::Variadic::Enum('2.0')
+
+  # @api public
+  # @since 0.1.0
+  property :error, SmartCore::Types::Value::JSONRPCErrorSchema
+
+  # @api public
+  # @since 0.1.0
+  property :id, SmartCore::Types::Value::String.nilable
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def error? = true
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def success? = false
+end

data/lib/jsonrpc/notification.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+class JSONRPC::Notification < SmartCore::ValueObject
+  # @return [SmartCore::Schema]
+  #
+  # @api public
+  # @since 0.1.0
+  Schema = Class.new(SmartCore::Schema) do
+    schema do
+      required(:jsonrpc).type(:string).filled
+      required(:method).type(:string).filled
+      required(:params).type(:hash).filled
+    end
+  end.new
+
+  # @api public
+  # @since 0.1.0
+  property :jsonrpc, SmartCore::Types::Variadic::Enum('2.0')
+
+  # @api public
+  # @since 0.1.0
+  property :method, SmartCore::Types::Value::String
+
+  # @api public
+  # @since 0.1.0
+  property :params, SmartCore::Types::Value::Hash
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def notification? = true
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def request? = false
+end

data/lib/jsonrpc/request.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+class JSONRPC::Request < SmartCore::ValueObject
+  # @return [SmartCore::Schema]
+  #
+  # @api public
+  # @since 0.1.0
+  Schema = Class.new(SmartCore::Schema) do
+    schema do
+      required(:jsonrpc).type(:string).filled
+      required(:method).type(:string).filled
+      required(:params).type(:hash).filled
+      required(:id).type(:string).filled
+    end
+  end.new
+
+  # @api public
+  # @since 0.1.0
+  property :jsonrpc, SmartCore::Types::Variadic::Enum('2.0')
+
+  # @api public
+  # @since 0.1.0
+  property :method, SmartCore::Types::Value::String
+
+  # @api public
+  # @since 0.1.0
+  property :params, SmartCore::Types::Value::Hash
+
+  # @api public
+  # @since 0.1.0
+  property :id, SmartCore::Types::Value::String
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def notification? = false
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def request? = true
+end

data/lib/jsonrpc/response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+class JSONRPC::Response < SmartCore::ValueObject
+  # @api public
+  # @since 0.1.0
+  property :jsonrpc, SmartCore::Types::Variadic::Enum('2.0')
+
+  # @api public
+  # @since 0.1.0
+  property :result, SmartCore::Types::Value::Hash
+
+  # @api public
+  # @since 0.1.0
+  property :id, SmartCore::Types::Value::String
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def error? = false
+
+  # @return [Boolean]
+  #
+  # @api public
+  # @since 0.1.0
+  def success? = true
+end

data/lib/jsonrpc/rpc_object.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+module JSONRPC::RPCObject
+  module_function
+
+  # @param result [Hash<String|Symbol,Any>]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::Response, NilClass]
+  #
+  # @api public
+  # @since 0.1.0
+  def response(result = {}, request_id: nil)
+    return if request_id == nil # NOTE: nil is treated as no result
+
+    # @type var request_id: untyped
+    JSONRPC::Response.new(jsonrpc: '2.0', result:, id: request_id)
+  end
+
+  # @param data [Hash<String|Symbol,Any>]
+  # @option code [Integer]
+  # @option message [String]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def error(
+    data = {},
+    code: JSONRPC::ERRORS[:application_error][:code],
+    message: JSONRPC::ERRORS[:application_error][:message],
+    request_id: nil
+  )
+    JSONRPC::ErrorResponse.new(
+      jsonrpc: '2.0',
+      error: { code:, message:, data: },
+      id: request_id
+    )
+  end
+  class << self; alias_method :application_error, :error; end
+
+  # @option jsonrpc [String]
+  # @option method [String]
+  # @option params [Hash<String|Symbol,Any>]
+  # @option id [String]
+  # @return [JSONRPC::Request]
+  #
+  # @api public
+  # @since 0.1.0
+  def request(jsonrpc: '2.0', method:, params:, id:)
+    JSONRPC::Request.new(jsonrpc:, method:, params:, id:)
+  end
+
+  # @option jsonrpc [String]
+  # @option method [String]
+  # @option params [Hash<Symbol,Any>]
+  # @return [JSONRPC::Notification]
+  #
+  # @api public
+  # @since 0.1.0
+  def notification(jsonrpc: '2.0', method:, params:)
+    JSONRPC::Notification.new(jsonrpc:, method:, params:)
+  end
+
+  # @param data [Hash]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def invalid_request_error(data = {}, request_id: nil)
+    error(
+      data,
+      code: JSONRPC::ERRORS[:invalid_request][:code],
+      message: JSONRPC::ERRORS[:invalid_request][:message],
+      request_id:
+    )
+  end
+
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def parse_error
+    error(
+      code: JSONRPC::ERRORS[:parse_error][:code],
+      message: JSONRPC::ERRORS[:parse_error][:message]
+    )
+  end
+
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def jsonrpc_specification_violation_error(request_id: nil)
+    error(
+      code: JSONRPC::ERRORS[:jsonrpc_specification_violation][:code],
+      message: JSONRPC::ERRORS[:jsonrpc_specification_violation][:message],
+      request_id:
+    )
+  end
+
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def method_not_found_error(request_id: nil)
+    error(
+      code: JSONRPC::ERRORS[:method_not_found][:code],
+      message: JSONRPC::ERRORS[:method_not_found][:message],
+      request_id:
+    )
+  end
+
+  # @param data [Hash<String|Symbol,Any>]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def invalid_params_error(data = {}, request_id: nil)
+    error(
+      data,
+      code: JSONRPC::ERRORS[:invalid_params][:code],
+      message: JSONRPC::ERRORS[:invalid_params][:message],
+      request_id:
+    )
+  end
+
+  # @param error_codes [*Array<String,Symbol>]
+  # @option error_context [Hash<String|Symbol,Any>]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def internal_error(*error_codes, error_context: {}, request_id: nil)
+    error(
+      { error_codes:, error_context: },
+      code: JSONRPC::ERRORS[:internal_error][:code],
+      message: JSONRPC::ERRORS[:internal_error][:message],
+      request_id:
+    )
+  end
+
+  # @param exception [Exception]
+  # @option request_id [String, NilClass]
+  # @return [JSONRPC::ErrorResponse]
+  #
+  # @api public
+  # @since 0.1.0
+  def detailed_internal_error(exception, request_id: nil)
+    internal_error(
+      error_context: {
+        error_class: exception.class,
+        error_message: exception.message,
+        error_backtrace: exception.backtrace,
+        error_object: exception
+      },
+      request_id:
+    )
+  end
+end

data/lib/jsonrpc/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
 module JSONRPC
-  VERSION = '0.0.1'
+  # @return [String]
+  #
+  # @api public
+  # @since 0.1.0
+  VERSION = '0.1.0'
 end

data/lib/jsonrpc.rb

@@ -1,5 +1,55 @@
 # frozen_string_literal: true
 
+require 'smart_core/types'
+require 'smart_core/schema'
+require 'smart_core/value-object'
+
+# @api public
+# @since 0.1.0
 module JSONRPC
   require_relative 'jsonrpc/version'
+  require_relative 'jsonrpc/request'
+  require_relative 'jsonrpc/notification'
+  require_relative 'jsonrpc/response'
+  require_relative 'jsonrpc/error_response'
+  require_relative 'jsonrpc/rpc_object'
+
+  # @return [Hash<Symbol,Hash<Symbol,String|Integer>>]
+  #
+  # @api public
+  # @since 0.1.0
+  ERRORS = {
+    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'
+    },
+    unauthorized: {
+      code: -33_001,
+      message: 'Unauthorized'
+    },
+    application_error: {
+      code: -33_002,
+      message: 'Application Error'
+    },
+    jsonrpc_specification_violation: {
+      code: -33_003,
+      message: 'JSONRPC Specification Violation'
+    }
+  }.freeze
 end

data/sig/jsonrpc_interface.rbs

@@ -1,3 +1,139 @@
-module JsonrpcInterface
+module JSONRPC
   VERSION: String
+
+  # TODO:
+  #  - try to return the record sub-hash value:
+  #    -> before: Hash[Symbol, Hash[Symbol,untyped]]
+  #    -> after (does not work): Hash[Symbol, { code: Integer, message: String }]
+  ERRORS: Hash[Symbol, Hash[Symbol,untyped]]
+
+  interface _RPCRequest
+    def notification?: () -> bool
+    def request?: () -> bool
+  end
+
+  interface _RPCResponse
+    def error?: () -> bool
+    def success?: () -> bool
+  end
+
+  class Request
+    include _RPCRequest
+
+    attr_reader jsonrpc: String
+    attr_reader method: String
+    attr_reader params: Hash[String|Symbol,untyped]
+    attr_reader id: String|nil
+
+    def initialize: (
+      jsonrpc: String,
+      method: String,
+      params: Hash[String|Symbol,untyped],
+      id: String
+    ) -> void
+  end
+
+  class Notification
+    include _RPCRequest
+
+    attr_reader jsonrpc: String
+    attr_reader method: String
+    attr_reader params: Hash[String|Symbol,untyped]
+
+    def initialize: (
+      jsonrpc: String,
+      method: String,
+      params: Hash[String|Symbol,untyped]
+    ) -> void
+  end
+
+  class Response
+    include _RPCResponse
+
+    attr_reader jsonrpc: String
+    attr_reader result: Hash[String|Symbol,untyped]
+    attr_reader id: String|nil
+
+    def initialize: (
+      jsonrpc: String,
+      result: Hash[String|Symbol,untyped],
+      id: String
+    ) -> void
+  end
+
+  class ErrorResponse
+    include _RPCResponse
+
+    attr_reader jsonrpc: String
+    attr_reader error: { code: Integer, message: String, data: Hash[String|Symbol,untyped] }
+    attr_reader id: String|nil
+
+    def initialize: (
+      jsonrpc: String,
+      error: {
+        code: Integer,
+        message: String,
+        data: Hash[String|Symbol,untyped]
+      },
+      id: String|nil
+    ) -> void
+  end
+
+  module RPCObject
+    def self?.response: (
+      ?Hash[String|Symbol,untyped],
+      ?request_id: String|nil
+    ) -> (Response|nil)
+
+    def self?.error: (
+      ?Hash[String|Symbol,untyped],
+      ?code: Integer,
+      ?message:  String,
+      ?request_id: String|nil,
+    ) -> ErrorResponse
+
+    def self?.request: (
+      ?jsonrpc: String,
+      method: String,
+      params: Hash[String|Symbol,untyped],
+      id: String
+    ) -> Request
+
+    def self?.notification: (
+      ?jsonrpc: String,
+      method: String,
+      params: Hash[String|Symbol,untyped]
+    ) -> Notification
+
+    def self?.invalid_request_error: (
+      ?Hash[String|Symbol,untyped],
+      ?request_id: String|nil
+    ) -> ErrorResponse
+
+    def self?.parse_error: () -> ErrorResponse
+
+    def self?.jsonrpc_specification_violation_error: (
+      ?request_id: String|nil
+    ) -> ErrorResponse
+
+    def self?.method_not_found_error: (
+      ?request_id: String|nil
+    ) -> ErrorResponse
+
+    def self?.invalid_params_error: (
+      ?Hash[String|Symbol,untyped],
+      ?request_id: String|nil
+    ) -> ErrorResponse
+
+    def self?.internal_error: (
+      *String|Symbol,
+      ?error_context: Hash[String|Symbol,untyped],
+      ?request_id: String|nil
+    ) -> ErrorResponse
+
+    def self?.detailed_internal_error: (
+      Exception,
+      ?request_id: String|nil
+    ) -> ErrorResponse
+  end
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: jsonrpc_interface
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-28 00:00:00.000000000 Z
+date: 2023-06-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: smart_schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: smart_types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: smart_value-object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +136,37 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: JSONRPC Interface for Ruby projects realised in object oriented way.
+  JRPC Request, JRPC Notification, JRPC Response, JRPC Error Response, JRPC Object
+  Builder and JRPC Error Codes.
 email:
 - iamdaiver@gmail.com
 executables: []
@@ -111,10 +183,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - bin/console
 - bin/setup
 - jsonrpc_interface.gemspec
 - lib/jsonrpc.rb
+- lib/jsonrpc/error_response.rb
+- lib/jsonrpc/notification.rb
+- lib/jsonrpc/request.rb
+- lib/jsonrpc/response.rb
+- lib/jsonrpc/rpc_object.rb
 - lib/jsonrpc/version.rb
 - lib/jsonrpc_interface.rb
 - sig/jsonrpc_interface.rbs