activerpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10ba3417ba62f8c6113543c46d4fc9f869a85c18a7fdc91160fc9a918043dc64
+  data.tar.gz: d59077929216fca8f7ab8067cfe643d7c72fdeca5f0aa359db955bd932a098d6
+SHA512:
+  metadata.gz: 2abecebe8eea82db866c8e51789956fde73c34af67a51355e7c919b66259bd3e8eb036b920b4749f8e30c857f057aaad646d72956db9b2c1f987293c15204d51
+  data.tar.gz: 1a77d1a284b54598eab87f67c2bca9007946b059edbd47a94362c0691b2586a7769b74b6283ef5007541454d5269b8a2e644d52d6f6ebc6dfab75cbcb4b6e1a1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 John Maxwell
+
+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,95 @@
+# ActiveRpc
+Rails-native JSONRPC 2.0 Server Library
+
+## Usage
+ActiveRpc is a simple mechanism to service JSONRPC requests from within
+a Rails installation without sacrificing your existing Rails workflow.
+It supports custom before/after/around actions on the RPC controller,
+and insists upon validation of payloads for inbound method invocations,
+using standard Rails tools and toolchains.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerpc'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install activerpc
+```
+
+Once you've installed the gem, you can add an initializer to configure things
+such as controller lifecycle actions.
+
+```ruby
+ActiveRpc.configure do |config|
+  config.before_action = MyBeforeAction # something that responds to `.before`
+end
+```
+
+## Usage
+The JSONRPC spec supports two kinds of parameters being passed to a method. We
+feel strongly that only the Hash/Object form should be used rather than the
+Array/positional form. The reason for this is that it is significantly less
+brittle as changes happen over time, and much easier to reason about what the job
+is whilst in flight.
+
+Further than that, we also believe that all invocations should be subject to
+suitable validation before processing. So...
+
+```ruby
+class MyRpcMethod < ActiveRpc::Operation
+  operation_name 'rpc.method.name'
+  fields :name, :age
+
+  validates :name, presence: true
+  validates :age, presence: true, numericality: true, only_integer: true, greater_than: 18
+
+  def call
+    "Hello #{name}, you are #{age} years old."
+  end
+end
+```
+
+ActiveRpc will instantiate your method class, and if it passes validation
+it will then call `#call` on it, returning the outcome of that method as the
+JSONRPC result field.
+
+JSONRPC supports returning application-semantic errors, to trigger one of those
+you should raise an error in your `#call` method.
+
+```ruby
+def call
+  raise OperationFailure.new(code: my_code, message: 'no thanks') if name == 'Nigel'
+
+  "Hello #{name}, you are #{age} years old."
+end
+```
+
+Please note, in development mode you might have issues with the operation classes
+being autoloaded. The new bootloader in Rails 6 will solve this, but until then you
+can add something similar to the below to an initialiser.
+
+```ruby
+# Require all operatons in app/operations as dependencies for autoloading
+Rails.application.config.to_prepare do
+  Dir[Rails.root.join('app', 'operations', '*.rb')].each do |file|
+    require_dependency(file)
+  end
+end
+```
+
+## Contributing
+Fork the project, make some changes and open a PR! For major changes of direction
+please talk to us first, we can't guarantee to merge PRs that don't reflect the
+usage we have of this project.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Activerpc'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/active_rpc/rpc_controller.rb

@@ -0,0 +1,56 @@
+module ActiveRpc
+  class RpcController < ActionController::Base
+    after_action ActiveRpc.config.after_action
+    around_action ActiveRpc.config.around_action
+    before_action ActiveRpc.config.before_action
+
+    def create
+      res = nil
+      begin
+        res = case body
+              when Array then body.map(&method(:process_item)).map(&:to_hash)
+              when Hash then process_item(body).to_hash
+              end
+      rescue JSON::ParserError => ex
+        res = ActiveRpc::Response.new do |r|
+          r.error = Errors::ParseError.new(message: ex.to_s)
+        end.to_hash
+      end
+
+      render status: :ok, json: res
+    end
+
+    private def process_item(item)
+      req = ActiveRpc::Request.new(id: item['id'], method: item['method'], params: item['params'])
+      res = ActiveRpc::Response.from_request(req)
+
+      begin
+        raise TypeError, 'invalid JSON-RPC request' unless req.valid?
+
+        executor = ActiveRpc.get_executor(req.method)
+        raise NoMethodError, "undefined operation `#{req.method}'" unless executor
+
+        ex = executor.new(req.params)
+        raise ArgumentError, 'invalid payload' unless ex.valid?
+        res.result = ex.call
+      rescue TypeError => ex
+        res.error = Errors::ClientError.new(message: ex.to_s)
+      rescue NoMethodError => ex
+        res.error = Errors::NoMethodError.new(message: ex.to_s)
+      rescue ArgumentError => ex
+        res.error = Errors::ArgumentError.new(message: ex.to_s)
+      rescue OperationFailure => ex
+        res.error = ex.rpc_error
+      # todo: handle rpc-level errors
+      rescue => ex
+        res.error = Errors::InternalError.new(message: ex.to_s)
+      end
+
+      res
+    end
+
+    private def body
+      @body ||= JSON.load(request.body.read)
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+ActiveRpc::Engine.routes.draw do
+  post '/', to: 'rpc#create'
+end

data/lib/active_rpc/configuration.rb

@@ -0,0 +1,5 @@
+module ActiveRpc
+  class Configuration
+    attr_accessor :before_action, :after_action, :around_action
+  end
+end

data/lib/active_rpc/engine.rb

@@ -0,0 +1,5 @@
+module ActiveRpc
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveRpc
+  end
+end

data/lib/active_rpc/errors.rb

@@ -0,0 +1,77 @@
+module ActiveRpc
+  class OperationFailure < RuntimeError
+    attr_reader :code, :message, :data
+
+    def initialize(code:, message: nil, data: nil)
+      @code = code
+      @message = message
+      @data = data
+    end
+
+    def rpc_error
+      Errors::OperationFailure.new(code: code, message: message, data: data)
+    end
+  end
+
+  class Error
+    attr_accessor :message, :data
+    attr_reader :code
+    def initialize(code:, data: nil, message: nil)
+      @message = message
+      @code = code
+      @data = data
+    end
+
+    def to_hash
+      {
+        'code' => code,
+        'data' => data,
+        'message' => message
+      }.compact
+    end
+  end
+
+  module Errors
+    class ClientError < Error
+      def initialize(message:)
+        super(message: message, code: -32600)
+      end
+    end
+
+    class NoMethodError < Error
+      def initialize(message:)
+        super(message: message, code: -32601)
+      end
+    end
+
+    class ParseError < Error
+      def initialize(message:)
+        super(message: message, code: -32700)
+      end
+    end
+
+    class ArgumentError < Error
+      def initialize(message:)
+        super(message: message, code: -32602)
+      end
+    end
+
+    class InternalError < Error
+      def initialize(message:)
+        super(message: message, code: -32603)
+      end
+    end
+
+    class ServerError < Error
+      def initialize(message:)
+        super(message: message, code: -32000)
+      end
+    end
+
+    class OperationFailure < Error
+      def initialize(code:, message:, data: nil)
+        super(message: message, code: code, data: data)
+      end
+    end
+  end
+end

data/lib/active_rpc/operation.rb

@@ -0,0 +1,21 @@
+module ActiveRpc
+  class Operation
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+
+    class << self
+      def fields(*names)
+        attr_accessor(*names)
+      end
+
+      def operation_name(value)
+        ActiveRpc.operation_map[value] = self
+      end
+    end
+
+    def call
+      raise 'Must Implement'
+    end
+  end
+end

data/lib/active_rpc/request.rb

@@ -0,0 +1,19 @@
+module ActiveRpc
+  class Request
+    attr_reader :id, :method, :params
+
+    def initialize(id:, method:, params:)
+      @id, @method, @params = id, method, params
+    end
+
+    def valid?
+      [
+        id.present?,
+        id.is_a?(String) || id.is_a?(Integer),
+        method.present?,
+        method.is_a?(String),
+        params.nil? || params.is_a?(Array) || params.is_a?(Hash),
+      ].all?
+    end
+  end
+end

data/lib/active_rpc/response.rb

@@ -0,0 +1,27 @@
+module ActiveRpc
+  class Response
+    attr_accessor :error, :result
+    attr_reader :id
+
+    def initialize(id:)
+      @id = id
+    end
+
+    def to_hash
+      {
+       'jsonrpc' => '2.0',
+        'id' => id
+      }.tap do |h|
+        if error
+          h['error'] = error.to_hash
+        else
+          h['result'] = result
+        end
+      end
+    end
+
+    def self.from_request(req)
+      new(id: req.id)
+    end
+  end
+end

data/lib/active_rpc/version.rb

@@ -0,0 +1,3 @@
+module ActiveRpc
+  VERSION = '0.1.0'
+end

data/lib/active_rpc.rb

@@ -0,0 +1,24 @@
+require 'active_rpc/engine'
+require 'active_rpc/errors'
+require 'active_rpc/configuration'
+require 'active_rpc/operation'
+require 'active_rpc/request'
+require 'active_rpc/response'
+
+module ActiveRpc
+  cattr_accessor :config
+
+  def self.configure
+    self.config ||= Configuration.new
+    yield(config)
+  end
+
+
+  def self.get_executor(method)
+    operation_map[method]
+  end
+
+  def self.operation_map
+    @operation_map ||= {}
+  end
+end

data/lib/activerpc.rb

@@ -0,0 +1 @@
+require "active_rpc"

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: activerpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Maxwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+description: Simple, dependable JSONRpc 2.0 Server library for Rails
+email:
+- john@musicglue.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/active_rpc/rpc_controller.rb
+- config/routes.rb
+- lib/active_rpc.rb
+- lib/active_rpc/configuration.rb
+- lib/active_rpc/engine.rb
+- lib/active_rpc/errors.rb
+- lib/active_rpc/operation.rb
+- lib/active_rpc/request.rb
+- lib/active_rpc/response.rb
+- lib/active_rpc/version.rb
+- lib/activerpc.rb
+homepage: https://github.com/musicglue/activerpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: JSONRpc 2.0 Server library for Rails
+test_files: []