active_webhook 1.0.0

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+
+def initialize_rake_environment
+  return unless require_relative "config/environment"
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+task default: :spec
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new do |task|
+  task.requires << "rubocop-performance"
+  task.requires << "rubocop-rspec"
+end

data/active_webhook.gemspec

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "active_webhook/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_webhook"
+  spec.version       = ActiveWebhook::VERSION
+  spec.authors       = ["Jay Crouch"]
+  spec.email         = ["i.jaycrouch@gmail.com"]
+
+  spec.summary       = "Simple, efficient, and extensible webhooks for Ruby."
+  spec.description   = "Simple, efficient, and extensible webhooks for Ruby, including: Rate Limits, Cryptographic " \
+                       "Signatures, Asynchronous Delivery, Buffered Delivery, Versioning."
+  spec.homepage      = "https://github.com/amazing-jay/active_webhook"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/amazing-jay/active_webhook"
+    spec.metadata["changelog_uri"] = "https://github.com/amazing-jay/active_webhook/master/tree/CHANGELOG.md."
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
+  end
+
+  spec.bindir                      = "exe"
+  spec.executables                 = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths               = ["lib"]
+  spec.required_ruby_version       = ">= 2.5"
+
+  spec.add_dependency "activerecord", ">= 5.0.0"
+  spec.add_dependency "memoist"
+
+  spec.add_development_dependency "awesome_print", "~> 1.9.2"
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "database_cleaner", "~> 2.0.1"
+  spec.add_development_dependency "delayed_job_active_record", "~> 4.1.6"
+  spec.add_development_dependency "dotenv", "~> 2.5"
+  spec.add_development_dependency "factory_bot", "~> 6.2.0"
+  spec.add_development_dependency "faker", "~> 2.18"
+  spec.add_development_dependency "faraday", "~> 1.4.2"
+  spec.add_development_dependency "listen", "~> 3.5.1"
+  spec.add_development_dependency "pry-byebug", "~> 3.9"
+
+  # must come before those below
+  if ENV['TEST_RAILS_VERSION'].nil?
+    spec.add_development_dependency 'rails', '~> 6.1.3.2'
+  else
+    spec.add_development_dependency 'rails', ENV['TEST_RAILS_VERSION'].to_s
+  end
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 5.0.1"
+  spec.add_development_dependency "rubocop", "~> 0.60"
+  spec.add_development_dependency "rubocop-performance", "~> 1.5"
+  spec.add_development_dependency "rubocop-rspec", "~> 1.37"
+  spec.add_development_dependency "codecov", "~> 0.5.2"
+  spec.add_development_dependency "simplecov", "~> 0.16"
+  spec.add_development_dependency "sqlite3", "~> 1.4.2"
+  spec.add_development_dependency "sidekiq", "~> 6.2.1"
+  spec.add_development_dependency "rspec-sidekiq", "~> 3.1.0"
+  spec.add_development_dependency "webmock", "~> 3.13"
+end

data/config/environment.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+
+ENV["RACK_ENV"] ||= ENV["RAILS_ENV"] ||= "development"
+
+require "bundler/setup"
+
+if RUBY_ENGINE == "jruby"
+  # Workaround for issue in I18n/JRuby combo.
+  # See https://github.com/jruby/jruby/issues/6547 and
+  # https://github.com/ruby-i18n/i18n/issues/555
+  require "i18n/backend"
+  require "i18n/backend/simple"
+end
+
+environments = [ENV["RAILS_ENV"].to_sym]
+environments << :development if environments.last == :test
+
+Bundler.require(*environments)
+
+SimpleCov.start if ENV['RAILS_ENV'].to_s == "test"
+SimpleCov.formatter = SimpleCov::Formatter::Codecov if ENV["CI"] == "true"
+
+require "active_webhook"
+
+db_config = File.read([__dir__.delete_suffix('/config'), "spec/dummy/config/database.yml"].join("/"))
+db_config = ERB.new(db_config).result
+db_config = YAML.safe_load(db_config, [], [], true)
+DB_CONFIG = db_config[ENV["RAILS_ENV"]]
+ActiveRecord::Base.establish_connection(DB_CONFIG)
+
+FactoryBot.find_definitions if %w(test development).include? ENV["RAILS_ENV"]

data/lib/active_webhook.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "memoist"
+
+require "active_webhook/adapter"
+require "active_webhook/delivery/base_adapter"
+require "active_webhook/formatting/base_adapter"
+require "active_webhook/queueing/base_adapter"
+require "active_webhook/verification/base_adapter"
+
+require "active_webhook/models/error_log_additions"
+require "active_webhook/models/subscription_additions"
+require "active_webhook/models/topic_additions"
+
+require "active_webhook/callbacks"
+require "active_webhook/hook"
+require "active_webhook/error_log"
+require "active_webhook/logger"
+require "active_webhook/subscription"
+require "active_webhook/topic"
+require "active_webhook/version"
+
+module ActiveWebhook
+  class InvalidAdapterError < StandardError; end
+
+  IDENTIFIER = "Active Webhook v#{VERSION}"
+
+  # IDENTIFIER must be defined first
+  require "active_webhook/configuration"
+
+  class << self
+    attr_writer :enabled
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+
+      configuration.after_configure
+    end
+
+    def logger
+      defined?(Rails) ? Rails.logger : (@logger ||= Logger.new($stdout))
+    end
+
+    def subscription_model
+      configuration.models.subscription
+    end
+
+    def topic_model
+      configuration.models.topic
+    end
+
+    def origin
+      return @@origin if defined? @@origin
+
+      @@origin = (Rails.application.config.action_mailer.default_url_options[:host] if defined?(Rails))
+    rescue StandardError
+      @@origin = ""
+    end
+
+    # TODO: change the next 4 methods to use memoized thread safe class var rather than configuration.enabled
+    def enabled?
+      configuration.enabled
+    end
+
+    def disabled?
+      !enabled?
+    end
+
+    def enable
+      state = enabled?
+      configuration.enabled = true
+      value = yield
+    ensure
+      configuration.enabled = state
+      value
+    end
+
+    def disable
+      state = enabled?
+      configuration.enabled = false
+      value = yield
+    ensure
+      configuration.enabled = state
+      value
+    end
+
+    Configuration::ADAPTERS.each do |type|
+      define_method "#{type}_adapter" do
+        fetch_adapter type, configuration.send(type).send("adapter")
+      end
+    end
+
+    def trigger(key:, version: nil, **context)
+      queueing_adapter.call(key: key, version: version, **context) if enabled?
+      true
+    end
+
+    protected
+
+    def fetch_adapter(type, adapter)
+      if adapter.is_a?(Symbol) || adapter.is_a?(String)
+        adapter = begin
+          @adapters ||= {}
+          @adapters[type] ||= {}
+          @adapters[type][adapter.to_sym] = begin
+            path = "active_webhook/#{type}/#{adapter}_adapter"
+            require path
+            const_name = path.camelize
+            ["http", "sha", "hmac", "json", "url"].each { |acronym| const_name.gsub!(acronym.camelize, acronym.upcase) }
+            const_name.constantize
+          end
+        end
+      end
+
+      raise InvalidAdapterError unless adapter.respond_to?(:call)
+
+      adapter
+    end
+  end
+end

data/lib/active_webhook/adapter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  class Adapter
+    extend Memoist
+    # TODO: memoize everything in all adapters
+
+    class << self
+      def attributes
+        @attributes ||= if self == ActiveWebhook::Adapter
+                          []
+                        else
+                          ancestors.each_with_object([]) do |ancestor, attrs|
+                            break attrs += ancestor.attributes if ancestor != self && ancestor.respond_to?(:attributes)
+
+                            attrs
+                          end
+                        end
+
+        # # byebug
+        # # puts ['start', self, @attributes].join(', ')
+        # @attributes ||= ancestors.each_with_object([]) do |ancestor, attrs|
+        #   # break attrs if ancestor == ActiveWebhook::Adapter
+
+        #   if ancestor != self
+        #     if ancestor.respond_to?(:attributes)
+        #       break attrs += ancestor.attributes
+        #     end
+        #   end
+        #   attrs
+
+        #   # puts ['searching', ancestor, attrs].join(', ')
+
+        #   # byebug
+        #   # break attrs if ancestor == ActiveWebhook::Adapter
+        #   # break attrs if ancestor != self && ancestor.respond_to?(:attributes))
+        #   # byebug
+        #   # attrs
+        # end
+        # puts ['finished', self, @attributes].join(' ,')
+        # # byebug
+        # # @attributes ||= []
+        # @attributes
+      end
+
+      def attribute(*attrs)
+        # Module.new.tap do |m| # Using anonymous modules so that super can be used to extend accessor methods
+        # include m
+
+        attrs = attrs.map(&:to_sym)
+        (attrs - attributes).each do |attr_name|
+          attributes << attr_name.to_sym
+          # m.attr_accessor attr_name
+          attr_accessor attr_name
+          # end
+        end
+      end
+
+      # def inherited(subclass)
+      #   byebug
+      #   # super
+      #   subclass.instance_variable_set(:@attributes, ancestors.each_with_object([]) do |ancestor, attrs|
+      #                                                  unless ancestor == self || !ancestor.respond_to?(:attributes)
+      #                                                    break attrs += ancestor.attributes
+      #                                                  end
+
+      #                                                  attrs
+      #                                                end)
+      #   # byebug
+      #   # x = 1
+      # end
+
+      def call(*args, **kwargs, &block)
+        new(*args, **kwargs).call(&block)
+      end
+
+      def component_name
+        raise NotImplementedError, ".component_name must be implemented."
+      end
+
+      def configuration
+        ActiveWebhook.configuration
+      end
+
+      def component_configuration
+        configuration.send(component_name)
+      end
+    end
+
+    attribute :context
+
+    def initialize(**kwargs)
+      self.class.attributes.each do |attr_name|
+        send("#{attr_name}=", kwargs[attr_name]) unless attr_name == :context
+      end
+      self.context = kwargs #.symbolize_keys! #with_indifferent_access
+    end
+
+    def call
+      raise NotImplementedError, "#call must be implemented."
+    end
+
+    def attributes
+      self.class.attributes.each_with_object({}) do |attr_name, h|
+        h[attr_name] = send(attr_name)
+      end
+    end
+
+    def configuration
+      self.class.configuration
+    end
+
+    def component_configuration
+      self.class.component_configuration
+    end
+  end
+end

data/lib/active_webhook/callbacks.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  module Callbacks
+    class InvalidCallbackError < StandardError; end
+    extend ActiveSupport::Concern
+
+    SUPPORTED_CALLBACKS = %i(created updated deleted).freeze
+
+    class_methods do
+      def trigger_webhooks(version: nil, only: nil, except: [], **_options)
+        callbacks = if only.nil?
+          SUPPORTED_CALLBACKS
+        else
+          Array.wrap(only).map(&:to_sym)
+        end - Array.wrap(except).map(&:to_sym)
+
+        callbacks.each do |callback|
+          unless SUPPORTED_CALLBACKS.include? callback
+            raise InvalidCallbackError, "Invalid callback: #{callback}. Must be one of #{SUPPORTED_CALLBACKS}."
+          end
+        end
+
+        after_commit :trigger_created_webhook, on: :create if callbacks.include?(:created)
+
+        after_commit :trigger_updated_webhook, on: :update if callbacks.include?(:updated)
+
+        after_commit :trigger_deleted_webhook, on: :destroy if callbacks.include?(:deleted)
+      end
+    end
+
+    def trigger_created_webhook
+      trigger_webhook(:created)
+    end
+
+    def trigger_updated_webhook
+      trigger_webhook(:updated) unless previous_changes.empty?
+    end
+
+    def trigger_deleted_webhook
+      trigger_webhook(:deleted)
+    end
+
+    def trigger_webhook(key, version: nil, type: 'resource', **context)
+      key = [self.class.name.underscore, key].join("/") unless key.is_a?(String)
+      context[:resource_id] ||= id
+      context[:resource_type] ||= self.class.name
+
+      ActiveWebhook.trigger(key: key, version: version, type: type, **context)
+    end
+  end
+  ActiveRecord::Base.include ActiveWebhook::Callbacks
+end

data/lib/active_webhook/configuration.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ActiveWebhook
+  class Configuration
+    class InvalidOptionError < StandardError
+      def initialize(option, value, values)
+        @option = option
+        @values = values
+        msg = "Invalid option for #{option}: #{value}. Must be one of #{values}."
+        super(msg)
+      end
+    end
+
+    module Base
+      extend ActiveSupport::Concern
+
+      def initialize
+        (self.class.instance_variable_get(:@components) || []).each do |component_name|
+          component = "#{self.class.name.deconstantize}::#{component_name.to_s.camelize}::Configuration"
+          component = component.constantize.new
+          instance_variable_set "@#{component_name}", component
+        end
+
+        (self.class.instance_variable_get(:@options) || []).each do |option, option_definition|
+          send "#{option}=", option_definition[:default]
+        end
+      end
+
+      class_methods do
+        protected
+
+        # TODO: consider changing so that all options accept a proc
+        #  q: does the proc run every time the option is asked? seems inefficent
+        def define_option(option, values: [], default: nil, allow_nil: false, allow_proc: false, prefixes: nil)
+          attr_reader option
+
+          default = values&.first if default.nil? && !allow_nil
+          prefixes ||= name.deconstantize.underscore.delete_prefix("active_webhook").split("/")
+          prefixes.shift if prefixes.first.blank?
+
+          @options ||= {}
+          @options[option] = {
+            values: values,
+            default: default,
+            allow_proc: allow_proc,
+            prefixes: prefixes
+          }
+
+          const_set option.to_s.pluralize.upcase, values
+
+          define_method "#{option}=" do |value|
+            unless (allow_proc && value.respond_to?(:call)) ||
+                   (allow_nil && value.nil?) ||
+                   values.empty? ||
+                   values.include?(value)
+              raise Configuration::InvalidOptionError.new (prefixes + [option]).compact.join("."), value,
+                                                          values
+            end
+
+            instance_variable_set "@#{option}", value
+          end
+        end
+
+        def define_component(component_name)
+          @components ||= []
+          @components << component_name
+          require "#{name.deconstantize.to_s.underscore}/#{component_name}/configuration"
+          attr_reader component_name
+        end
+      end
+    end
+
+    include Base
+
+    define_component :models
+    ADAPTERS = %i[delivery formatting queueing verification].freeze
+    ADAPTERS.each { |component| define_component component }
+
+    define_option :origin
+    define_option :enabled, values: [true, false]
+
+    def origin=(value)
+      if (@origin = value).nil?
+        ActiveWebhook.remove_class_variable(:@@origin) if ActiveWebhook.class_variable_defined?(:@@origin)
+      else
+        ActiveWebhook.class_variable_set(:@@origin, value)
+      end
+    end
+
+    def after_configure
+      # reset logger,
+      # ActiveWebhook.class_variable_set(:@logger, nil)
+      # cause all adapter files specified to be loaded
+      ADAPTERS.each { |type| ActiveWebhook.send "#{type}_adapter" }
+
+      # (re)set relationships for all models
+      models.error_log.belongs_to :subscription, class_name: models.subscription.name, foreign_key: :subscription_id
+      models.topic.has_many :subscriptions, class_name: models.subscription.name, foreign_key: :topic_id
+      models.subscription.belongs_to :topic, class_name: models.topic.name, foreign_key: :topic_id
+      models.subscription.has_many :error_logs, class_name: models.error_log.name, foreign_key: :subscription_id
+
+      self
+    end
+  end
+end