active_record_streams 0.1.0

data/lib/active_record_streams.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_record_streams/version'
+require 'active_record_streams/config'
+require 'active_record_streams/message'
+require 'active_record_streams/credentials'
+
+require 'active_record_streams/publishers/kinesis_client'
+require 'active_record_streams/publishers/kinesis_stream'
+require 'active_record_streams/publishers/sns_client'
+require 'active_record_streams/publishers/sns_stream'
+require 'active_record_streams/publishers/http_stream'
+
+require 'active_record_streams/extensions/active_record/persistence'
+require 'active_record_streams/extensions/active_record/relation'
+require 'active_record_streams/extensions/active_record/base'
+
+module ActiveRecordStreams
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+end

data/lib/active_record_streams/config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecordStreams
+  class Config
+    attr_accessor :aws_region, :aws_access_key_id, :aws_secret_access_key,
+                  :streams
+
+    def initialize
+      @aws_region = nil
+      @aws_access_key_id = nil
+      @aws_secret_access_key = nil
+      @streams = []
+    end
+  end
+end

data/lib/active_record_streams/config_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+
+RSpec.describe ActiveRecordStreams::Config do
+  describe 'attr accessors' do
+    context 'initial values' do
+      it 'returns correct initial values' do
+        expect(subject.aws_region).to eq(nil)
+        expect(subject.aws_access_key_id).to eq(nil)
+        expect(subject.aws_secret_access_key).to eq(nil)
+        expect(subject.streams).to eq([])
+      end
+    end
+
+    context 'attr setters' do
+      it 'sets and returns proper values' do
+        subject.aws_region = 'test-region'
+        expect(subject.aws_region).to eq('test-region')
+
+        subject.aws_access_key_id = 'test-access-key-id'
+        expect(subject.aws_access_key_id).to eq('test-access-key-id')
+
+        subject.aws_secret_access_key = 'test-secret-access-key'
+        expect(subject.aws_secret_access_key).to eq('test-secret-access-key')
+
+        subject.streams << 'test-stream'
+        expect(subject.streams).to eq(['test-stream'])
+      end
+    end
+  end
+end

data/lib/active_record_streams/credentials.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecordStreams
+  class Credentials
+    def build_credentials
+      region_config
+        .merge(access_key_id_config)
+        .merge(secret_access_key_config)
+    end
+
+    private
+
+    def region_config
+      return {} unless ActiveRecordStreams.config.aws_region
+
+      { region: ActiveRecordStreams.config.aws_region }
+    end
+
+    def access_key_id_config
+      return {} unless ActiveRecordStreams.config.aws_access_key_id
+
+      { access_key_id: ActiveRecordStreams.config.aws_access_key_id }
+    end
+
+    def secret_access_key_config
+      return {} unless ActiveRecordStreams.config.aws_secret_access_key
+
+      { secret_access_key: ActiveRecordStreams.config.aws_secret_access_key }
+    end
+  end
+end

data/lib/active_record_streams/credentials_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'credentials'
+
+RSpec.describe ActiveRecordStreams::Credentials do
+  describe '#build_credentials' do
+    let(:config) do
+      double(
+        aws_region: nil,
+        aws_access_key_id: nil,
+        aws_secret_access_key: nil
+      )
+    end
+
+    before do
+      allow(ActiveRecordStreams).to receive(:config).and_return(config)
+    end
+
+    subject { described_class.new.build_credentials }
+
+    context 'has region config' do
+      before do
+        allow(config).to receive(:aws_region).and_return('eu-central-1')
+      end
+
+      it 'returns a proper config' do
+        expect(subject).to eq(region: 'eu-central-1')
+      end
+    end
+
+    context 'has no region config' do
+      it 'returns a proper config' do
+        expect(subject).to eq({})
+      end
+    end
+
+    context 'has access keys config' do
+      before do
+        allow(config).to receive(:aws_access_key_id).and_return('access-key-id')
+        allow(config).to receive(:aws_secret_access_key).and_return('secret')
+      end
+
+      it 'returns a proper config' do
+        expect(subject).to eq(
+          access_key_id: 'access-key-id',
+          secret_access_key: 'secret'
+        )
+      end
+    end
+
+    context 'has no access keys config' do
+      it 'returns a proper config' do
+        expect(subject).to eq({})
+      end
+    end
+
+    context 'has region and access key config' do
+      before do
+        allow(config).to receive(:aws_region).and_return('eu-central-1')
+        allow(config).to receive(:aws_access_key_id).and_return('access-key-id')
+        allow(config).to receive(:aws_secret_access_key).and_return('secret')
+      end
+
+      it 'returns a proper config' do
+        expect(subject).to eq(
+          region: 'eu-central-1',
+          access_key_id: 'access-key-id',
+          secret_access_key: 'secret'
+        )
+      end
+    end
+
+    context 'has no any config' do
+      it 'returns a proper config' do
+        expect(subject).to eq({})
+      end
+    end
+  end
+end

data/lib/active_record_streams/extensions/active_record/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  Base.prepend(
+    Module.new do
+      def self.prepended(object)
+        object.class_exec do
+          before_save :capture_old_image
+          after_commit :publish_event_to_streams
+        end
+      end
+
+      private
+
+      def capture_old_image
+        @old_image = attributes.keys.map do |attribute|
+          [attribute, attribute_was(attribute)]
+        end.to_h
+      end
+
+      def publish_event_to_streams
+        ActiveRecordStreams.config.streams.each do |stream|
+          stream.publish(self.class.table_name, stream_message)
+        end
+      end
+
+      def stream_message
+        ::ActiveRecordStreams::Message.new(
+          self.class.table_name, stream_action_type, @old_image, attributes
+        )
+      end
+
+      def stream_action_type
+        return :create if transaction_include_any_action?([:create])
+        return :destroy if transaction_include_any_action?([:destroy])
+
+        :update
+      end
+    end
+  )
+end

data/lib/active_record_streams/extensions/active_record/base_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../../spec/mocks/active_record/base'
+require_relative 'base'
+
+RSpec.describe ActiveRecord::Base do
+  let(:message) { double(new: nil) }
+  let(:stream) { double(publish: nil) }
+  let(:streams_config) { double(streams: [stream]) }
+
+  before do
+    allow(ActiveRecordStreams).to receive(:config).and_return(streams_config)
+  end
+
+  describe 'persistence' do
+    let(:old_image) do
+      {
+        'hello' => 'old world',
+        'world' => 'old hello'
+      }
+    end
+
+    let(:new_image) do
+      {
+        'hello' => 'world',
+        'world' => 'hello'
+      }
+    end
+
+    before do
+      allow(ActiveRecordStreams::Message)
+        .to receive(:new)
+        .with(described_class.table_name, :create, old_image, new_image)
+        .and_return(message)
+    end
+
+    it 'publishes event to streams with proper data' do
+      expect(stream)
+        .to receive(:publish)
+        .with(described_class.table_name, message)
+
+      subject._invoke_persistent_callbacks
+    end
+  end
+end

data/lib/active_record_streams/extensions/active_record/persistence.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  Persistence.prepend(
+    Module.new do
+      private
+
+      ##
+      # destroy/destroy! methods should still call `delete_all` without
+      # callbacks, since they already serve their own callbacks
+
+      def destroy_row
+        relation_for_destroy.delete_all_without_callbacks
+      end
+    end
+  )
+end

data/lib/active_record_streams/extensions/active_record/persistence_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../../spec/mocks/active_record/persistence'
+require_relative 'persistence'
+
+RSpec.describe ActiveRecord::Persistence do
+  let(:relation_for_destroy) { double }
+
+  before do
+    allow(subject)
+      .to receive(:relation_for_destroy)
+      .and_return(relation_for_destroy)
+  end
+
+  subject do
+    Class.new do
+      include ActiveRecord::Persistence
+    end.new
+  end
+
+  describe 'destroy!' do
+    it 'calls original delete_all' do
+      expect(relation_for_destroy).to receive(:delete_all_without_callbacks)
+
+      subject.destroy!
+    end
+  end
+
+  describe 'destroy' do
+    it 'calls original delete_all' do
+      expect(relation_for_destroy).to receive(:delete_all_without_callbacks)
+
+      subject.destroy
+    end
+  end
+end

data/lib/active_record_streams/extensions/active_record/relation.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  Relation.prepend(
+    Module.new do
+      def self.prepended(object)
+        object.class_eval do
+          alias_method :delete_all_without_callbacks, :delete_all
+          alias_method :delete_all, :delete_all_with_callbacks
+        end
+      end
+
+      def update_all(updates)
+        find_each.inject(0) do |counter, record|
+          record.assign_attributes(updates)
+          counter += 1 if record.save(validate: false)
+
+          counter
+        end
+      end
+
+      ##
+      # Override `delete_all` method to serve callbacks.
+      # Change to this method also affects `delete` method.
+
+      # rubocop:disable Metrics/MethodLength
+      def delete_all_with_callbacks(conditions = nil)
+        return where(conditions).delete_all if conditions
+
+        find_each.inject(0) do |count, record|
+          wrap_delete_with_callbacks(record) do
+            deleted_count = where(
+              primary_key => record.attributes[primary_key]
+            ).delete_all_without_callbacks
+
+            if deleted_count == 1
+              record.instance_variable_set('@destroyed', true)
+              count += 1
+            end
+
+            count
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def wrap_delete_with_callbacks(record)
+        record.run_callbacks(:commit) do
+          record.run_callbacks(:destroy) do
+            ActiveRecord::Base.transaction do
+              yield
+            end
+          end
+        end
+      end
+    end
+  )
+end

data/lib/active_record_streams/extensions/active_record/relation_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../../spec/mocks/active_record/relation'
+require_relative 'relation'
+
+RSpec.describe ActiveRecord::Relation do
+  let(:record) { double(assign_attributes: nil, save: nil, run_callbacks: nil, attributes: { 'id' => 1 }) }
+
+  before do
+    allow(subject).to receive(:where).and_return(subject)
+    allow(subject).to receive(:find_each).and_return([record])
+  end
+
+  describe '#update_all' do
+    it 'invokes save for each record' do
+      expect(record).to receive(:assign_attributes).with(a: 'b')
+      expect(record).to receive(:save).with(validate: false)
+
+      subject.update_all(a: 'b')
+    end
+  end
+
+  describe '#delete_all' do
+    before do
+      allow(subject).to receive(:primary_key).and_return('id')
+    end
+
+    it 'performs deletion invoking the callbacks' do
+      expect(record).to receive(:run_callbacks).with(:commit).and_yield
+      expect(record).to receive(:run_callbacks).with(:destroy).and_yield
+      expect(ActiveRecord::Base).to receive(:transaction).and_yield
+
+      expect(subject).to receive(:where).with('id' => 1).and_return(subject)
+      expect(subject).to receive(:delete_all_without_callbacks).and_return(1)
+
+      expect(record).to receive(:instance_variable_set).with('@destroyed', true)
+
+      subject.delete_all
+    end
+  end
+end

data/lib/active_record_streams/message.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecordStreams
+  class Message
+    def initialize(table_name, action_type, old_image, new_image)
+      @table_name = table_name
+      @action_type = action_type
+      @old_image = old_image || new_image
+      @new_image = new_image
+    end
+
+    def json
+      {
+        TableName: @table_name,
+        ActionType: @action_type,
+        OldImage: @old_image,
+        NewImage: @new_image
+      }.to_json
+    end
+  end
+end