hasura_handler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95be3b9811df02080b282112b53e0b0a6aacd4520cd98de9de851af3349028a8
+  data.tar.gz: 41a54a270f42447b21ae308b79e23bd1ad24851cbc00d1c5101d8ca478342ef5
+SHA512:
+  metadata.gz: f03c0e96d4c8f4e06de84c7ed087fb79a3c86d0fe8be6a29fd8d465d581c1a0735e81bf7cb3015eb1c7ac4bc2e25416ceef712716aa805a9163c6940d83aaa59
+  data.tar.gz: b3c696453cd65e2c16b9d0e2888d0681456d7bba76d1e78d93b5cbcf510096c5618ecd58e5d81c5c7bdbfdffe8d68a651963e8737e293b93476fd9d6d7c8c720

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Kaz Walker
+
+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,28 @@
+# HasuraHandler
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hasura_handler'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install hasura_handler
+```
+
+## Contributing
+Contribution directions go here.
+
+## 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,29 @@
+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    = 'HasuraHandler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+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/hasura_handler/actions_controller.rb

@@ -0,0 +1,30 @@
+require_dependency 'hasura_handler/application_controller'
+
+module HasuraHandler
+  class ActionsController < ApplicationController
+    def process
+      unless HasuraHandler::Action.hasura_actions.keys.include?(action_params[:action][:name])
+        render json: { error: true, message: 'action name not registered' }, status: 404
+        return
+      end
+
+      klass = HasuraHandler::Action.hasura_actions[action_params[:action][:name]]
+      action = klass.new(action_params[:session_variables], action_params[:input])
+      action.run
+
+      if action.error_message.present?
+        render json: { error: true, message: action.error_message }, status: 400
+      else
+        render json: action.output
+      end
+    end
+
+    def action_params
+      params.permit(
+        action: [:name],
+        input: {},
+        session_variables: {}
+      )
+    end
+  end
+end

data/app/controllers/hasura_handler/application_controller.rb

@@ -0,0 +1,13 @@
+module HasuraHandler
+  class ApplicationController < ActionController::API
+    before_action :check_header
+
+    private
+
+    def check_header
+      unless request.headers[HasuraHandler.auth_header] == HasuraHandler.auth_key
+        render json: { error: true, message: 'unable to authenticate request' }, status: 401
+      end
+    end
+  end
+end

data/app/controllers/hasura_handler/events_controller.rb

@@ -0,0 +1,58 @@
+require_dependency 'hasura_handler/application_controller'
+
+module HasuraHandler
+  class EventsController < ApplicationController
+    def process
+      processor = HasuraHandler::EventHandler.new(event_params)
+
+      unless processor.event.valid?
+        error_response(processor.event.errors)
+        return
+      end
+
+      if HasuraHandler.async_events
+        processor.process_later
+        render json: { queued: true }, status: 202
+        return
+      end
+
+      processor.process
+      if processor.success?
+        render json: { success: true }
+      else
+        error_response(processor.errors)
+      end
+    end
+
+    private
+
+    def error_response(errors)
+      response.set_header('Retry-After', HasuraHandler.retry_after)
+      render json: { success: false, errors: errors }, status: 400
+    end
+
+    def event_params
+      params.permit(
+        :id,
+        :created_at,
+        table: [
+          :schema,
+          :name
+        ],
+        trigger: [
+          :name
+        ],
+        event: [
+          :op,
+          {
+            session_variables: {},
+            data: {
+              new: {},
+              old: {}
+            }
+          }
+        ]
+      )
+    end
+  end
+end

data/app/jobs/hasura_handler/application_job.rb

@@ -0,0 +1,4 @@
+module HasuraHandler
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/hasura_handler/event_handler_job.rb

@@ -0,0 +1,11 @@
+module HasuraHandler
+  class EventHandlerJob < ApplicationJob
+    queue_as HasuraHandler.event_handler_job_queue
+
+    def perform(handler_class, event)
+      klass = handler_class.constantize
+      handler = klass.new(event)
+      handler.run
+    end
+  end
+end

data/app/jobs/hasura_handler/event_job.rb

@@ -0,0 +1,9 @@
+module HasuraHandler
+  class EventJob < ApplicationJob
+    queue_as HasuraHandler.event_job_queue
+
+    def perform(event)
+      HasuraHandler::EventHandler.new(event).process
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,9 @@
+HasuraHandler::Engine.routes.draw do
+  if HasuraHandler.events_enabled
+    post '/events', to: 'events#process'
+  end
+
+  if HasuraHandler.actions_enabled
+    post '/actions', to: 'actions#process'
+  end
+end

data/lib/hasura_handler.rb

@@ -0,0 +1,34 @@
+require 'hasura_handler/engine'
+require 'hasura_handler/event_handler'
+require 'hasura_handler/event'
+require 'hasura_handler/action'
+
+module HasuraHandler
+  class << self
+    mattr_accessor :auth_header,
+                   :auth_key,
+                   :events_enabled,
+                   :actions_enabled,
+                   :event_job_queue,
+                   :event_handler_job_queue,
+                   :async_events,
+                   :fanout_events,
+                   :retry_after
+
+    self.auth_header = 'X-Hasura-Service-Key'
+    self.events_enabled = true
+    self.async_events = true
+    self.fanout_events = true
+    self.actions_enabled = true
+    self.event_job_queue = :hasura_event
+    self.event_handler_job_queue = :hasura_event
+    self.retry_after = 5
+  end
+
+  def self.setup(&block)
+    yield self
+    [:auth_key].each do |key|
+      raise "HasuraHandler requires the #{key} to be configured." if self.send(key).blank?
+    end
+  end
+end

data/lib/hasura_handler/action.rb

@@ -0,0 +1,32 @@
+module HasuraHandler
+  class Action
+    @@hasura_actions = {}
+    class << self
+      attr_reader :hasura_action_name
+
+      def action_name(action_name)
+        raise 'run method not defined' unless new(nil, nil).respond_to?(:run)
+        raise 'action_name must be a symbol or string' unless action_name.is_a?(Symbol) || action_name.is_a?(String)
+        raise 'action_name already used' if @@hasura_actions.keys.include?(action_name.to_s)
+
+        @@hasura_actions[action_name.to_s] = self
+        @hasura_action_name = action_name.to_s
+      end
+
+      def hasura_actions
+        @@hasura_actions
+      end
+    end
+
+    attr_reader :session_variables,
+                :input,
+                :output,
+                :error_message
+
+    def initialize(session_variables, input)
+      @session_variables = session_variables
+      @input = input
+      @output = {}
+    end
+  end
+end

data/lib/hasura_handler/engine.rb

@@ -0,0 +1,6 @@
+module HasuraHandler
+  class Engine < ::Rails::Engine
+    isolate_namespace HasuraHandler
+    config.generators.api_only = true
+  end
+end

data/lib/hasura_handler/event.rb

@@ -0,0 +1,86 @@
+module HasuraHandler
+  class Event
+    attr_reader :id,
+                :table,
+                :trigger,
+                :event,
+                :created_at,
+                :raw_event,
+                :errors,
+                :valid
+
+    def initialize(event)
+      @id = event[:id]
+      @table = event[:table]
+      @trigger = event[:trigger]
+      @event = event[:event]
+      @created_at = event[:created_at]
+      @raw_event = event
+      @errors = {}
+
+      [
+        :validate_simple_fields,
+        :validate_table,
+        :validate_trigger,
+        :validate_event
+      ].each{ |check| self.send(check) }
+    end
+
+    def valid?
+      @errors.blank?
+    end
+
+    private
+
+    def validate_simple_fields
+      [
+        :id,
+        :created_at
+      ].each do |field|
+        @errors[field.to_s] = 'missing' unless self.send(field).present?
+      end
+    end
+
+    def validate_table
+      unless @table.is_a?(Hash)
+        @errors['table'] = 'not a hash'
+        return
+      end
+
+      string_fields?(@table, 'table', [:schema, :name])
+    end
+
+    def validate_trigger
+      unless @trigger.is_a?(Hash)
+        @errors['trigger'] = 'not a hash'
+        return
+      end
+
+      string_fields?(@trigger, 'trigger', [:name])
+    end
+
+    def validate_event
+      unless @event.is_a?(Hash)
+        @errors['event'] = 'not a hash'
+        return
+      end
+
+      @errors['event.session_variables'] = 'not a hash' unless @event[:session_variables].is_a?(Hash)
+      string_fields?(@event, 'event', [:op])
+
+      [:new, :old].each do |field|
+        unless @event[field].nil? || @event[field].is_a?(Hash)
+          @errors["event.data.#{field}"] = 'not a hash'
+        end
+      end
+    end
+
+    def string_fields?(field, error_key, subfields)
+      subfields.each do |subfield|
+        unless field[subfield].present? && field[subfield].is_a?(String)
+          errors["#{error_key}.#{subfield}"] = 'missing'
+        end
+      end
+    end
+  end
+end

data/lib/hasura_handler/event_handler.rb

@@ -0,0 +1,25 @@
+module HasuraHandler
+  class EventHandler
+    class << self
+      attr_reader :hasura_matchers
+
+      def match_by(matchers)
+        raise 'matcher must be a hash' unless matchers.is_a?(Hash)
+        allowed_matchers = [:table, :trigger, :op]
+
+        matchers.keys.each do |matcher|
+          raise 'invalid matcher' unless allowed_matchers.include?(matcher)
+          raise 'invalid matcher value' unless matchers[matcher].is_a?(String)
+        end
+
+        raise 'run method not defined' unless new(nil).respond_to?(:run)
+
+        @hasura_matchers = matchers
+      end
+    end
+
+    def initialize(event)
+      @event = event
+    end
+  end
+end

data/lib/hasura_handler/event_processor.rb

@@ -0,0 +1,43 @@
+module HasuraHandler
+  class EventProcessor
+    attr_accessor :event
+
+    def initialize(event)
+      @event = HasuraHandler::Event.new(event)
+    end
+
+    def process_later
+      HasuraHandler::EventJob.perform_later(@event.raw_event)
+    end
+
+    def process
+      event_handlers.each do |handler_class|
+        if HasuraHandler.fanout_events
+          HasuraHandler::EventHandlerJob.perform_later(handler_class.to_s, @event.raw_event)
+        else
+          handler = handler_class.new(@event)
+          handler.run
+        end
+      end
+    end
+
+    private
+
+    def event_handlers
+      HasuraHandler::EventHandler.
+      descendants.
+      map{ |klass| [klass, klass.hasura_matchers] }.
+      to_h.
+      map{ |klass,matchers| [klass, check_matchers(matchers)] }.
+      to_h.
+      select{ |klass,match| match }.
+      keys
+    end
+
+    def check_matchers(matchers)
+      matchers.all? do |matcher|
+        @event.send(matcher.first) == matcher.last
+      end
+    end
+  end
+end

data/lib/hasura_handler/version.rb

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

data/lib/tasks/hasura_handler_tasks.rake

@@ -0,0 +1,4 @@
+# desc 'Explaining what the task does'
+# task :hasura_handler do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: hasura_handler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kaz Walker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+- !ruby/object:Gem::Dependency
+  name: graphql-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+description: Provides an easy way to build custom backends for Hasura.
+email:
+- me@kaz.codes
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/hasura_handler/actions_controller.rb
+- app/controllers/hasura_handler/application_controller.rb
+- app/controllers/hasura_handler/events_controller.rb
+- app/jobs/hasura_handler/application_job.rb
+- app/jobs/hasura_handler/event_handler_job.rb
+- app/jobs/hasura_handler/event_job.rb
+- config/routes.rb
+- lib/hasura_handler.rb
+- lib/hasura_handler/action.rb
+- lib/hasura_handler/engine.rb
+- lib/hasura_handler/event.rb
+- lib/hasura_handler/event_handler.rb
+- lib/hasura_handler/event_processor.rb
+- lib/hasura_handler/version.rb
+- lib/tasks/hasura_handler_tasks.rake
+homepage: https://github.com/KazW/HasuraHandler
+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: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Integrates Hasura with Rails
+test_files: []