webhooks-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d3794a579ac593913cc2806f60b0173e2570a42c06e72982f73466418ae08e7
+  data.tar.gz: 324a2208aa9a8550e9ce2dc40325e3b3d97d0339abf109ec618d507c0913ff3b
+SHA512:
+  metadata.gz: 784fea97e8b17c1362028554cbfede6490560d9b0369587ba4000f80c7abbd02e89f5669e65915ff49956e81cafee21e56e3c3e9219cdbdcbfef4b65d3203f91
+  data.tar.gz: de690423a67371ab04df5eca3709d6a5a888b21018a1d938909fda84a344ae431659a73bc9b93a2f662119bc7eadc1aa3731507b805a2fde5d2f203c59fd2677

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Garrett Bjerkhoel
+
+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 @@
+# Webhooks
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webhooks'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install webhooks
+```
+
+## 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,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+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/assets/config/webhooks_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/webhooks .css

data/app/assets/stylesheets/webhooks/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/webhooks/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/webhooks/attempts_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_dependency 'webhooks/application_controller'
+
+module Webhooks
+  class AttemptsController < ApplicationController
+    def show
+      @attempt = Webhooks::Attempt.find(params[:id])
+    end
+
+    def reattempt
+      @attempt = Webhooks::Attempt.find(params[:id])
+
+      if @attempt.reattempt(manual_reattempt: true)
+        redirect_back fallback_location: attempt_path(@attempt), flash: {
+          success: 'Will attempt to deliver event again',
+        }
+      else
+        redirect_back fallback_location: attempt_path(@attempt), flash: {
+          error: 'Could not attempt delivering event again',
+        }
+      end
+    end
+  end
+end

data/app/controllers/webhooks/endpoints_controller.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_dependency 'webhooks/application_controller'
+
+module Webhooks
+  class EndpointsController < ApplicationController
+    def index
+      @endpoints = Webhooks::Endpoint.order(created_at: :asc)
+    end
+
+    def show
+      @endpoint = Webhooks::Endpoint.find(params[:id])
+    end
+
+    def new
+      @endpoint = Webhooks::Endpoint.new
+    end
+
+    def create
+      @endpoint = Webhooks::Endpoint.new(endpoint_params)
+
+      if @endpoint.save
+        redirect_to endpoint_path(@endpoint), flash: {
+          success: 'Successfully created new webhook endpoint.',
+        }
+      else
+        render :new
+      end
+    end
+
+    def edit
+      @endpoint = Webhooks::Endpoint.find(params[:id])
+    end
+
+    def update
+      @endpoint = Webhooks::Endpoint.find(params[:id])
+
+      if @endpoint.update(endpoint_params)
+        redirect_to edit_endpoint_path(@endpoint), flash: {
+          success: 'Changes saved.',
+        }
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @endpoint = Webhooks::Endpoint.find(params[:id])
+
+      if @endpoint.destroy
+        redirect_to endpoints_path, flash: {
+          success: 'Deleted endpoint.',
+        }
+      else
+        redirect_back fallback_location: @endpoint
+      end
+    end
+
+    private
+
+    def endpoint_params
+      params.require(:endpoint).permit(:url, event_types: [])
+    end
+  end
+end

data/app/controllers/webhooks/events_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_dependency 'webhooks/application_controller'
+
+module Webhooks
+  class EventsController < ApplicationController
+    def index
+      @events = Webhooks::Event.order(created_at: :desc)
+    end
+
+    def show
+      @event = Webhooks::Event.find(params[:id])
+    end
+
+    def new
+      @event = Webhooks::Event.new
+    end
+
+    def create
+      @event = Webhooks::Event.new(event_params)
+
+      if @event.save
+        redirect_to event_path(@event), flash: {
+          success: 'Successfully created new webhook event.',
+        }
+      else
+        render :new
+      end
+    end
+
+    private
+
+    def event_params
+      params.require(:event).permit(:event_type, :event)
+    end
+  end
+end

data/app/helpers/webhooks/application_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Webhooks
+  module ApplicationHelper
+  end
+end

data/app/jobs/webhooks/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/webhooks/deliver_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class DeliverJob < ApplicationJob
+    queue_as :webhook_delivery
+
+    def perform(attempt)
+      attempt.deliver
+    end
+  end
+end

data/app/mailers/webhooks/application_mailer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/webhooks/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/webhooks/attempt.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class Attempt < ApplicationRecord
+    belongs_to :endpoint, class_name: 'Webhooks::Endpoint', foreign_key: :webhooks_endpoint_id, inverse_of: :attempts
+    belongs_to :event, class_name: 'Webhooks::Event', foreign_key: :webhooks_event_id, inverse_of: :attempts
+
+    has_one :request, class_name: 'Webhooks::Request', foreign_key: :webhooks_attempt_id, dependent: :destroy, inverse_of: :attempt
+    has_one :response, through: :request
+
+    enum state: {
+      queued: 0,
+      success: 1,
+      error: 2,
+    }
+
+    validates :attempt,
+      numericality: {
+        greater_than: 0,
+        less_than_or_equal_to: Rails.application.config.webhooks.attempts.limit,
+      }
+
+    before_validation :set_retry_at, on: :update, if: %i[state_changed? error?]
+    after_commit :enqueue_webhook_delivery, on: :create
+    after_commit :enqueue_webhook_redelivery, on: :update, if: %i[retry_at_previously_changed? retry_at?]
+
+    def deliver
+      request || create_request!
+    end
+
+    def max_attempts?
+      error? && attempt >= Rails.application.config.webhooks.attempts.limit
+    end
+
+    def reattempt(manual_reattempt: false)
+      return if !manual_reattempt && max_attempts?
+
+      # If it's a manual reattempt we need to set the counter to 1 otherwise
+      # we risk hitting the configured limit.
+      next_attempt = if manual_reattempt
+        1
+      else
+        attempt + 1
+      end
+
+      Webhooks::Attempt.create!(
+        endpoint: endpoint,
+        event: event,
+        attempt: next_attempt,
+        manual: manual_reattempt,
+      )
+    end
+
+    private
+
+    def set_retry_at
+      return if manual?
+      return unless attempt < Rails.application.config.webhooks.attempts.limit
+
+      self.retry_at = (60**attempt).seconds.from_now
+    end
+
+    def enqueue_webhook_redelivery
+      Webhooks::DeliverJob.set(wait_until: retry_at).perform_later(self)
+    end
+
+    def enqueue_webhook_delivery
+      Webhooks::DeliverJob.perform_later(self)
+    end
+  end
+end

data/app/models/webhooks/endpoint.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class Endpoint < ApplicationRecord
+    URL_REGEX = URI::DEFAULT_PARSER.make_regexp(Rails.application.config.webhooks.endpoints.valid_schemas)
+
+    validates :url, presence: true, format: { with: URL_REGEX }, uniqueness: true
+    validates :secret, presence: true, uniqueness: true
+    validates :state, presence: true
+
+    validates :event_types,
+      inclusion: {
+        in: Rails.application.config.webhooks.events.types,
+        allow_blank: true,
+      }
+
+    enum state: {
+      enabled: 0,
+      disabled: 1,
+      error: 2,
+    }
+
+    has_secure_token :secret, length: 36
+
+    before_validation :normalize_url
+    before_validation :generate_secret, on: :create
+
+    has_many :attempts,
+      foreign_key: :webhooks_endpoint_id,
+      inverse_of: :endpoint,
+      dependent: :destroy
+
+    has_many :events, through: :attempts
+
+    scope :subscribed, -> (event_type) {
+      lhs = Arel::Nodes.build_quoted(event_type)
+      any_event_type = Arel::Nodes::NamedFunction.new('ANY', [arel_table[:event_types]])
+
+      enabled.where(Arel::Nodes::Equality.new(lhs, any_event_type).or(arel_table[:event_types].eq(nil)))
+    }
+
+    def event_types=(new_event_types)
+      prepared_endpoint_types = Array.wrap(new_event_types).reject(&:blank?)
+
+      if prepared_endpoint_types.any?
+        super(prepared_endpoint_types)
+      else
+        super(nil)
+      end
+    end
+
+    def to_s
+      url
+    end
+
+    private
+
+    def normalize_url
+      self.url = url&.chomp('/')
+    end
+
+    def generate_secret
+      return if secret?
+
+      loop do
+        secret = self.class.generate_unique_secure_token(length: 36)
+        unless self.class.exists?(secret: secret)
+          self.secret = secret
+          break
+        end
+      end
+    end
+  end
+end

data/app/models/webhooks/event.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Webhooks
+  class Event < ApplicationRecord
+    validates :event_type,
+      presence: true,
+      inclusion: {
+        in: Rails.application.config.webhooks.events.types,
+      }
+
+    validates :event,
+      presence: true,
+      length: {
+        minimum: 1,
+      }
+
+    has_many :attempts,
+      foreign_key: :webhooks_event_id,
+      inverse_of: :event,
+      dependent: :destroy
+
+    has_many :endpoints, through: :attempts
+    before_validation :enforce_create_without_subscribed_endpoint_setting
+
+    after_create :create_attempts
+
+    def to_s
+      event_type
+    end
+
+    private
+
+    def subscribed_endpoint_scope
+      Endpoint.subscribed(event_type)
+    end
+
+    def enforce_create_without_subscribed_endpoint_setting
+      return if Rails.application.config.webhooks.events.create_without_subscribed_endpoint
+      return if subscribed_endpoint_scope.any?
+
+      errors.add(:base, :no_endpoints_subscribed)
+    end
+
+    def create_attempts
+      subscribed_endpoint_scope.find_each do |endpoint|
+        attempts.create!(endpoint: endpoint)
+      end
+    end
+  end
+end