easyhooks 1.0.3

data/lib/easyhooks/concerns/validators.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Easyhooks
+  module Validators
+    extend ActiveSupport::Concern
+
+    ALLOWED_ON_VALUES = %i[create update destroy].freeze
+    ALLOWED_METHODS = %i[get post put patch delete].freeze
+    ALLOWED_TYPES = %i[default stored].freeze
+
+    included do
+      def validate_type(type)
+        return :default if type.nil?
+        raise TypeError, "Invalid #{self.class} type: #{type}" unless ALLOWED_TYPES.include?(type)
+        type
+      end
+
+      def validate_method(method)
+        return nil if method.nil? && @type == :stored # this will be loaded by the processor
+        return :post unless method.present?
+        method = method.downcase if method.is_a?(String)
+        raise TypeError, "Invalid method '#{method}' for #{self.class} '#{@name}'. Allowed values are: #{ALLOWED_METHODS}" unless ALLOWED_METHODS.include?(method.to_sym)
+        method.to_sym
+      end
+
+      def valid_url?(url)
+        URI.parse(url) rescue false
+      end
+
+      def validate_endpoint(endpoint)
+        return nil if endpoint.nil? && @type == :stored # this will be loaded by the processor
+        raise TypeError, "#{self.class} endpoint can't be nil" unless endpoint.present?
+        raise TypeError, "#{self.class} endpoint is not a valid URL: #{endpoint}" unless valid_url?(endpoint)
+        endpoint
+      end
+
+      def validate_name(name)
+        raise TypeError, "#{self.class} name can't be nil" unless name.present?
+        raise TypeError, "Invalid #{self.class} name '#{name}'. Name can only have alphanumeric characters and underscore" unless name =~ /\A[a-zA-Z0-9_]+\z/
+        name
+      end
+
+      def validate_on(on)
+        return ALLOWED_ON_VALUES if on.nil?
+        on = [on] unless on.is_a?(Array)
+        on.map do |value|
+          raise TypeError, "Invalid attribute 'on' for #{self.class} #{@name}: #{on}. Allowed values are: #{ALLOWED_ON_VALUES}" unless ALLOWED_ON_VALUES.include?(value.to_sym)
+          value
+        end
+      end
+
+      def validate_only(only)
+        return [] if only.nil?
+        only = [only] unless only.is_a?(Array)
+        only.map(&:to_sym) # convert only array into symbols array
+      end
+
+      def validate_callback(callback, attribute)
+        if callback.nil? || callback.is_a?(Symbol) || callback.respond_to?(:call)
+          callback
+        else
+          raise TypeError, "Invalid attribute '#{attribute}' for #{self.class} #{@name}: #{attribute} must be nil, an instance method name symbol or a callable (eg. a proc or lambda)"
+        end
+      end
+
+      def validate_auth(auth)
+        return nil if auth.nil?
+        # validate if auth header is a string and it must be a Bearer token or a Basic auth to include into a HTTP request
+        raise TypeError, "Invalid attribute 'auth_header' for #{self.class} #{@name}: #{auth} must be nil or a string" unless auth.is_a?(String)
+        raise TypeError, "Invalid attribute 'auth_header' for #{self.class} #{@name}: #{auth} must be a Bearer token or a Basic auth" unless auth =~ /\ABearer\s/ || auth =~ /\ABasic\s/
+        auth
+      end
+
+      def validate_headers(headers)
+        return {} if headers.nil?
+        headers = JSON.parse(headers.gsub(':', '').gsub('=>', ':')) if headers.is_a?(String)
+        raise TypeError, "Invalid attribute 'headers' for #{self.class} #{@name}: #{headers} must be nil or a hash" unless headers.is_a?(Hash)
+        headers
+      end
+
+      def validate_hook(hook)
+        return hook if hook.nil? && @type == :stored
+        hook.method = validate_method(hook.method)
+        hook.endpoint = validate_endpoint(hook.endpoint)
+        hook.auth = validate_auth(hook.auth)
+        hook.headers = validate_headers(hook.headers)
+        hook
+      end
+    end
+  end
+end

data/lib/easyhooks/hook.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Easyhooks
+  class Hook
+    ATTRIBUTES = [:method, :endpoint, :auth, :headers]
+    attr_accessor(*ATTRIBUTES)
+  end
+end

data/lib/easyhooks/migration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../generators/easyhooks/migration/templates/migration'
+
+module Easyhooks
+  class Migration
+
+    def self.up
+      EasyhooksMigration.migrate(:up)
+    end
+  end
+end

data/lib/easyhooks/post_processor.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require 'net/http'
+
+module Easyhooks
+  class PostProcessor < ActiveJob::Base
+    queue_as :easyhooks
+
+    def perform(klass_name, object_id, payload, action_name, action_trigger)
+      init_data(klass_name, object_id, payload, action_name, action_trigger)
+      begin
+        request = create_http_request
+        make_request(request)
+        trigger_event
+      rescue => e
+        if @action.on_fail.present? && @object.respond_to?(@action.on_fail_callable)
+          @object.send(@action.on_fail_callable, e)
+        else
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def init_data(klass_name, object_id, payload, action_name, action_trigger)
+      @klass_name = klass_name
+      @object = find_object(object_id)
+      @action_trigger = action_trigger
+      @action_name = action_name
+      load_action_and_payload(payload)
+    end
+
+    def find_object(object_id)
+      @klass = @klass_name.constantize
+      @klass.find_by(id: object_id)
+    end
+
+    def json?(value)
+      # check if value is a json string
+      JSON.parse(value)
+      true
+    rescue JSON::ParserError
+      false
+    end
+
+    def enrich_data(data)
+      # if data is a hash or array or a json string
+      default = {
+        object: @klass_name,
+        action: @action.name,
+        trigger: {
+          name: @action.trigger_name,
+          event: @action_trigger.to_s.upcase
+        }
+      }
+      if json?(data)
+        default.merge({ data: JSON.parse(data) }).to_json
+      else
+        default.merge({ data: { id: data }}).to_json
+      end
+    end
+
+    def load_action_and_payload(payload)
+      @action = @klass.easyhooks_actions[@action_name]
+      @action.load!(@klass_name)
+      @payload = enrich_data(payload)
+    end
+
+    def create_http_request
+      parsed_url = URI.parse(@action.hook.endpoint)
+      host = parsed_url.host
+      port = parsed_url.port
+      raise "Unable to load endpoint: #{@action.hook.endpoint}" unless host.present? && port.present?
+
+      @http = Net::HTTP.new(host, port)
+      @http.use_ssl = true if parsed_url.scheme == 'https'
+
+      Net::HTTP.const_get(@action.hook.method.to_s.capitalize).new(parsed_url.request_uri)
+    end
+
+    def make_request(request)
+      request.body = @payload
+      request.add_field('Content-Type', 'application/json')
+
+      # add headers
+      @action.hook.headers.each do |key, value|
+        request.add_field(key, value)
+      end
+
+      # adds auth (bearer or basic)
+      request.add_field('Authorization', @action.hook.auth) if @action.hook.auth.present?
+
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Rails.env.test? # disable SSL verification for test env
+      @response = @http.request(request)
+    end
+
+    def trigger_event
+      @object.send(@action.event_callable, @response) if @object.respond_to?(@action.event_callable)
+    end
+  end
+end

data/lib/easyhooks/specification.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'easyhooks/action'
+require 'easyhooks/trigger'
+require 'easyhooks/hook'
+require 'easyhooks/concerns/helpers'
+require 'easyhooks/concerns/validators'
+
+module Easyhooks
+  class Specification
+    include Easyhooks::Helpers
+    include Easyhooks::Validators
+
+    attr_accessor :name, :type, :global_args, :actions, :triggers, :scoped_action, :scoped_trigger
+
+    def initialize(name, type, args = {}, &specification)
+      @name = name
+      @type = type
+      @global_args = args.merge({ type: type })
+      @triggers = {}
+      @actions = {}
+      instance_eval(&specification)
+    end
+
+    private
+
+    def trigger(name, args = {}, &actions)
+      # merge args with global args keeping args as the priority
+      args = @global_args.merge(args)
+
+      type = args[:type]
+
+      hook_definition = find_trigger_hook(name, type, args)
+
+      # create the trigger
+      new_trigger = Easyhooks::Trigger.new(name, hook_definition, args)
+      @triggers[name] = new_trigger
+      @scoped_trigger = new_trigger
+      instance_eval(&actions) if actions
+    end
+
+    def action(name, args = {}, &event)
+      args = @scoped_trigger.args.merge(args)
+      type = args[:type]
+
+      hook_definition = find_action_hook(name, type, args)
+
+      # create the action
+      new_action = Easyhooks::Action.new(name, @scoped_trigger.name, hook_definition, args, &event)
+      @actions[name] = new_action
+      @scoped_action = new_action
+      @scoped_trigger.add_action(new_action)
+    end
+
+    def find_trigger_hook(name, type, args)
+      hook_definition = Hook.new
+      Hook::ATTRIBUTES.each do |field|
+        value = hook_lookup(:triggers, name, type, args, field) || hook_lookup(:classes, @name, type, args, field)
+        hook_definition.send("#{field}=".to_sym, value)
+      end
+      hook_definition
+    end
+
+    def find_action_hook(name, type, args)
+      hook_definition = Hook.new
+      Hook::ATTRIBUTES.each do |field|
+        value = hook_lookup(:actions, name, type, args, field) || @scoped_trigger.hook.send(field)
+        hook_definition.send("#{field}=".to_sym, value)
+      end
+      hook_definition
+    end
+
+    def hook_lookup(attr_type, attr_name, type, args, field)
+      # stored triggers will load at post processor time
+      return nil if type == :stored
+
+      if args.present?
+        value = args[field]&.to_s
+        return value if value.present?
+      end
+
+      if config_file_exists? && [:method, :endpoint, :auth].include?(field)
+        value = config.dig(Rails.env, attr_type.to_s, attr_name.to_s, field.to_s)&.to_s
+        return value if value.present?
+      end
+
+      if config_file_exists? && field == :headers
+        value = config.dig(Rails.env, attr_type.to_s, attr_name.to_s, field.to_s)&.to_h
+        return value if value.present?
+      end
+    end
+
+    def config_file_exists?
+      @config_file_exists ||= File.exist?(config_file)
+    end
+
+    def config_file
+      args = 'config', 'easyhooks.yml'
+      args.unshift('test') if Rails.env.test?
+
+      @config_file ||= File.join(Rails.root, args)
+    end
+
+    def config
+      @config ||= YAML.load_file(config_file)
+    end
+  end
+end

data/lib/easyhooks/store.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative './store_values'
+
+module Easyhooks
+  class Store < ActiveRecord::Base
+    self.table_name = 'easyhooks_store'
+
+    has_many :values, class_name: 'Easyhooks::StoreValues', dependent: :destroy
+
+    validates_presence_of :name, :method, :endpoint, :context
+
+    def add_headers(headers)
+      headers.each do |key, value|
+        values.create(context: 'headers', key: key, value: value)
+      end
+    end
+
+    def add_auth(type, auth)
+      values.create(context: 'auth', key: type, value: auth)
+    end
+
+    def headers
+      values.where(context: 'headers').map { |v| [v.key, v.value] }.to_h
+    end
+
+    def auth
+      auth = values.where(context: 'auth').first
+      return nil unless auth.present?
+
+      "#{auth.key} #{auth.value}"
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: easyhooks_store
+#
+#  id             :integer          not null, primary key
+#  context        :string           not null
+#  name           :string           not null
+#  method         :string           not null
+#  endpoint       :string           not null
+#  created_at     :datetime
+#  updated_at     :datetime
+#
+# Indexes
+#
+#  index_easyhooks_store_on_name_and_context (name, context) UNIQUE
+#

data/lib/easyhooks/store_values.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative './store'
+
+module Easyhooks
+  class StoreValues < ActiveRecord::Base
+    self.table_name = 'easyhooks_store_values'
+
+    belongs_to :store, class_name: 'Easyhooks::Store'
+
+    validates_presence_of :key, :value, :context
+  end
+end
+
+# == Schema Information
+#
+# Table name: easyhooks_store_values
+#
+#  id                       :integer          not null, primary key
+#  context                  :string           not null
+#  key                      :string           not null
+#  value                    :string           not null
+#  easyhooks_store_id       :integer          not null
+#  created_at               :datetime
+#  updated_at               :datetime
+#
+# Indexes
+#
+#  index_easyhooks_store_values_on_key_and_context (key, context)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (easyhooks_store_id => easyhooks_store.id)
+#

data/lib/easyhooks/trigger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'easyhooks/base'
+
+module Easyhooks
+  class Trigger < Easyhooks::Base
+
+    attr_accessor :args, :on, :only, :actions
+
+    def initialize(name, hook, args = {})
+      super(name, args[:type], hook, args[:if], args[:payload], args[:on_fail])
+      @args = args
+      @on = validate_on(args[:on])
+      @only = validate_only(args[:only])
+      @actions = []
+    end
+
+    def add_action(action)
+      @actions.push(action)
+    end
+  end
+end

data/lib/easyhooks/version.rb

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

data/lib/easyhooks.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'rails'
+require 'active_support'
+require 'active_record'
+require 'active_job'
+require 'easyhooks/specification'
+require 'easyhooks/post_processor'
+
+module Easyhooks
+
+  module ClassMethods
+    attr_reader :easyhooks_spec
+
+    def easyhooks(type = :default, args = {}, &specification)
+      if type.is_a?(Hash)
+        args = type
+        type = :default
+      end
+      # get self.class replacing :: from the module::class name with _
+      # e.g. MyModule::MyClass becomes MyModule_MyClass
+      klass_name = self.name.to_s.gsub('::', '_')
+      assign_easyhooks Specification.new(klass_name, type, args, &specification)
+    end
+
+    def easyhooks_actions
+      @easyhooks_spec.actions
+    end
+
+    private
+
+    def assign_easyhooks(specification_object)
+      @easyhooks_spec = specification_object
+
+      @easyhooks_spec.actions.each do |_, action|
+        module_eval do
+          define_method action.event_callable do |response_data|
+            instance_exec(response_data, &action.event) if action.event.present?
+          end
+
+          define_method action.on_fail_callable do |error|
+            send(action.on_fail, error)
+          end
+        end
+      end
+    end
+  end
+
+  module InstanceMethods
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :dispatch_triggers
+    end
+
+    private
+
+    def triggered_by
+      return :create if self.transaction_include_any_action?([:create])
+
+      return :update if self.transaction_include_any_action?([:update])
+
+      return :destroy if self.transaction_include_any_action?([:destroy])
+
+      :none
+    end
+
+    def perform_trigger_actions(trigger)
+      trigger.actions.each do |action|
+        next unless action.condition_applicable?(self)
+        payload = action.request_payload(self).to_json
+        PostProcessor.perform_later(self.class.name, self.id, payload, action.name, triggered_by)
+      end
+    end
+
+    def execute_trigger(trigger)
+      return unless trigger.condition_applicable?(self)
+      if trigger.only.empty? || triggered_by == :destroy
+        perform_trigger_actions(trigger)
+      else
+        trigger.only.each do |field|
+          perform_trigger_actions(trigger) if self.previous_changes.has_key?(field)
+        end
+      end
+    end
+
+    def dispatch_triggers
+      return unless self.class.easyhooks_spec
+
+      self.class.easyhooks_spec.triggers.each do |_, trigger|
+        execute_trigger(trigger) if self.transaction_include_any_action?(trigger.on)
+      end
+    end
+  end
+
+  def self.included(klass)
+    # check if the klass extends from ActiveRecord::Base, if not raise an error
+    unless klass.ancestors.include?(ActiveRecord::Base)
+      raise "Easyhooks can only be included in classes that extend from ActiveRecord::Base"
+    end
+
+    klass.send :include, InstanceMethods
+
+    klass.extend ClassMethods
+  end
+end
+
+ActiveRecord::Base.send(:include, Easyhooks)

data/lib/generators/easyhooks/migration/migration_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Easyhooks
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc 'Generates migration for easyhooks'
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'migration.rb','db/migrate/easyhooks_migration.rb'
+    end
+
+    def self.next_migration_number(dirname)
+      if timestamped_migrations?
+        Time.now.utc.strftime('%Y%m%d%H%M%S')
+      else
+        '%.3d' % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def self.timestamped_migrations?
+      (ActiveRecord::Base.respond_to?(:timestamped_migrations) && ActiveRecord::Base.timestamped_migrations) ||
+        (ActiveRecord.respond_to?(:timestamped_migrations) && ActiveRecord.timestamped_migrations)
+    end
+  end
+end

data/lib/generators/easyhooks/migration/templates/migration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class EasyhooksMigration < ActiveRecord::Migration[6.0]
+  def self.up
+    create_table :easyhooks_store do |t|
+      t.string :context, null: false
+      t.string :name, null: false
+      t.string :method, null: false
+      t.string :endpoint, null: false
+      t.timestamps null: true
+    end
+    add_index :easyhooks_store, %i[name context], unique: true
+
+    create_table :easyhooks_store_values do |t|
+      t.string :context, null: false
+      t.string :key, null: false
+      t.string :value, null: false
+      t.integer :store_id, null: false, references: :easyhooks_store
+      t.timestamps null: true
+    end
+    add_index :easyhooks_store_values, %i[context key]
+  end
+
+  def self.down
+    drop_table :easyhooks_store_values
+    drop_table :easyhooks_store
+  end
+end