active_record_streams 0.1.0

data/lib/active_record_streams/message_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'message'
+
+RSpec.describe ActiveRecordStreams::Message do
+  let(:table_name) { 'hello_world' }
+  let(:action_type) { :create }
+  let(:old_image) { { 'hello' => 'world' } }
+  let(:new_image) { { 'hello' => 'new world' } }
+
+  subject do
+    described_class.new(table_name, action_type, old_image, new_image)
+  end
+
+  describe '#json' do
+    let(:expected_value) do
+      {
+        TableName: table_name,
+        ActionType: action_type,
+        OldImage: old_image,
+        NewImage: new_image
+      }.to_json
+    end
+
+    it 'represents message in json format' do
+      expect(subject.json).to eq(expected_value)
+    end
+  end
+end

data/lib/active_record_streams/publishers/http_stream.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module ActiveRecordStreams
+  module Publishers
+    class HttpStream
+      ANY_TABLE = '*'
+      DEFAULT_CONTENT_TYPE = 'application/json'
+
+      def initialize(
+        url:,
+        headers: {},
+        table_name: ANY_TABLE,
+        ignored_tables: []
+      )
+        @url = url
+        @headers = headers
+        @table_name = table_name
+        @ignored_tables = ignored_tables
+      end
+
+      def publish(table_name, message)
+        return unless (any_table? && allowed_table?(table_name)) ||
+                      table_name == @table_name
+
+        request.body = message.json
+        http.request(request)
+      end
+
+      private
+
+      def any_table?
+        @table_name == ANY_TABLE
+      end
+
+      def allowed_table?(table_name)
+        !@ignored_tables.include?(table_name)
+      end
+
+      def request
+        @request ||= Net::HTTP::Post.new(uri.request_uri, headers)
+      end
+
+      def http
+        @http ||= Net::HTTP.new(uri.host, uri.port)
+      end
+
+      def uri
+        @uri ||= URI.parse(@url)
+      end
+
+      def headers
+        { 'Content-Type': DEFAULT_CONTENT_TYPE }.merge(@headers)
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/http_stream_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'http_stream'
+
+RSpec.describe ActiveRecordStreams::Publishers::HttpStream do
+  let(:url) { 'http://hello.world' }
+  let(:headers) { { 'Authorization' => 'Bearer hello' } }
+  let(:desired_table_name) { '*' }
+  let(:actual_table_name) { 'lovely_records' }
+  let(:ignored_tables) { [] }
+
+  let(:request) { double('body=': nil, request: nil) }
+  let(:http_client) { double('body=': nil, request: nil) }
+  let(:message) { double(json: '{}') }
+
+  subject do
+    described_class.new(
+      url: url,
+      headers: headers,
+      table_name: desired_table_name,
+      ignored_tables: ignored_tables
+    )
+  end
+
+  before do
+    allow(Net::HTTP::Post).to receive(:new).and_return(request)
+    allow(Net::HTTP).to receive(:new).and_return(http_client)
+  end
+
+  describe '#publish' do
+    context 'any table' do
+      it 'sends event to a http target' do
+        subject.publish(actual_table_name, message)
+
+        expect(request).to have_received(:body=).with(message.json)
+        expect(http_client).to have_received(:request).with(request)
+      end
+    end
+
+    context 'specific table' do
+      let(:desired_table_name) { actual_table_name }
+
+      it 'sends event to a http target' do
+        subject.publish(actual_table_name, message)
+
+        expect(request).to have_received(:body=).with(message.json)
+        expect(http_client).to have_received(:request).with(request)
+      end
+    end
+
+    context 'non-matching table' do
+      let(:desired_table_name) { 'another_table' }
+
+      it 'does not send event to a http target' do
+        subject.publish(actual_table_name, message)
+
+        expect(request).not_to have_received(:body=).with(message.json)
+        expect(http_client).not_to have_received(:request).with(request)
+      end
+    end
+
+    context 'blacklisted table' do
+      let(:ignored_tables) { [actual_table_name] }
+
+      it 'does not send event to a http target' do
+        subject.publish(actual_table_name, message)
+
+        expect(request).not_to have_received(:body=).with(message.json)
+        expect(http_client).not_to have_received(:request).with(request)
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/kinesis_client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+
+module ActiveRecordStreams
+  module Publishers
+    class KinesisClient
+      def publish(stream_name, partition_key, data, overrides = {})
+        client.put_record(
+          stream_name: stream_name,
+          data: data,
+          partition_key: partition_key,
+          **overrides
+        )
+      end
+
+      private
+
+      def client
+        @client ||= Aws::Kinesis::Client.new(
+          ::ActiveRecordStreams::Credentials.new.build_credentials
+        )
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/kinesis_client_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'kinesis_client'
+
+RSpec.describe ActiveRecordStreams::Publishers::KinesisClient do
+  let(:stream_name) { 'lovely-stream' }
+  let(:partition_key) { 'abcdefghihklmopqrstuvwxyz' }
+  let(:data) { 'dummy data' }
+  let(:overrides) { {} }
+
+  let(:aws_kinesis_client) { double }
+
+  before do
+    allow(Aws::Kinesis::Client).to receive(:new).and_return(aws_kinesis_client)
+  end
+
+  describe '#publish' do
+    subject do
+      described_class.new.publish(stream_name, partition_key, data, overrides)
+    end
+
+    context 'no overrides' do
+      it 'calls aws sdk' do
+        expect(aws_kinesis_client).to receive(:put_record).with(
+          stream_name: stream_name,
+          data: data,
+          partition_key: partition_key
+        )
+
+        subject
+      end
+    end
+
+    context 'overrides' do
+      let(:overrides) { { additional_param: true } }
+
+      it 'calls aws sdk' do
+        expect(aws_kinesis_client).to receive(:put_record).with(
+          stream_name: stream_name,
+          data: data,
+          partition_key: partition_key,
+          additional_param: true
+        )
+
+        subject
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/kinesis_stream.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+
+module ActiveRecordStreams
+  module Publishers
+    class KinesisStream
+      ANY_TABLE = '*'
+      PARTITION_KEY_TIME_FORMAT = '%Y%m%dT%H%M%S'
+
+      ##
+      # @param [String] stream_name
+      # @param [String] table_name
+      # @param [Enumerable<String>] ignored_tables
+      # @param [Hash] overrides
+
+      def initialize(
+        stream_name:,
+        table_name: ANY_TABLE,
+        ignored_tables: [],
+        overrides: {}
+      )
+        @stream_name = stream_name
+        @table_name = table_name
+        @ignored_tables = ignored_tables
+        @overrides = overrides
+      end
+
+      ##
+      # @param [String] table_name
+      # @param [ActiveRecordStreams::Message] message
+
+      def publish(table_name, message)
+        return unless (any_table? && allowed_table?(table_name)) ||
+                      table_name == @table_name
+
+        client.publish(
+          @stream_name,
+          partition_key(table_name),
+          message.json,
+          @overrides
+        )
+      end
+
+      private
+
+      def any_table?
+        @table_name == ANY_TABLE
+      end
+
+      def allowed_table?(table_name)
+        !@ignored_tables.include?(table_name)
+      end
+
+      def partition_key(table_name)
+        "#{table_name}-#{Time.now.utc.strftime(PARTITION_KEY_TIME_FORMAT)}"
+      end
+
+      def client
+        @client ||= KinesisClient.new
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/kinesis_stream_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'kinesis_stream'
+
+RSpec.describe ActiveRecordStreams::Publishers::KinesisStream do
+  let(:stream_name) {}
+  let(:partition_key) {}
+  let(:desired_table_name) { '*' }
+  let(:actual_table_name) { 'lovely_records' }
+  let(:ignored_tables) { [] }
+  let(:overrides) { {} }
+
+  let(:message) { double(json: '{}') }
+  let(:kinesis_client) { double(publish: nil) }
+
+  subject do
+    described_class.new(
+      stream_name: stream_name,
+      table_name: desired_table_name,
+      ignored_tables: ignored_tables,
+      overrides: overrides
+    )
+  end
+
+  before do
+    allow(ActiveRecordStreams::Publishers::KinesisClient)
+      .to receive(:new)
+      .and_return(kinesis_client)
+  end
+
+  describe '#publish' do
+    context 'any table' do
+      it 'sends event to kinesis stream' do
+        expect(kinesis_client).to receive(:publish) do |stream, partition_key, data, _overrides|
+          expect(stream).to eq(stream_name)
+          expect(partition_key).to match(/\A#{actual_table_name}-/i)
+          expect(data).to eq(message.json)
+        end
+
+        subject.publish(actual_table_name, message)
+      end
+    end
+
+    context 'specific table' do
+      let(:desired_table_name) { actual_table_name }
+
+      it 'sends event to a kinesis stream' do
+        expect(kinesis_client).to receive(:publish) do |stream, partition_key, data, _overrides|
+          expect(stream).to eq(stream_name)
+          expect(partition_key).to match(/\A#{actual_table_name}-/i)
+          expect(data).to eq(message.json)
+        end
+
+        subject.publish(actual_table_name, message)
+      end
+    end
+
+    context 'non-matching table' do
+      let(:desired_table_name) { 'another_table' }
+
+      it 'does not send event to kinesis stream' do
+        expect(kinesis_client).not_to receive(:publish)
+
+        subject.publish(actual_table_name, message)
+      end
+    end
+
+    context 'blacklisted table' do
+      let(:ignored_tables) { [actual_table_name] }
+
+      it 'does not send event to kinesis stream' do
+        expect(kinesis_client).not_to receive(:publish)
+
+        subject.publish(actual_table_name, message)
+      end
+    end
+
+    context 'with overrides' do
+      let(:overrides) { { 'hello' => 'world' } }
+
+      it 'sends event to a kinesis stream' do
+        expect(kinesis_client).to receive(:publish) do |stream, partition_key, data, overrides|
+          expect(stream).to eq(stream_name)
+          expect(partition_key).to match(/\A#{actual_table_name}-/i)
+          expect(data).to eq(message.json)
+          expect(overrides).to eq(overrides)
+        end
+
+        subject.publish(actual_table_name, message)
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/sns_client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+
+module ActiveRecordStreams
+  module Publishers
+    class SnsClient
+      def publish(topic_arn, message, overrides = {})
+        client.publish(
+          topic_arn: topic_arn,
+          message: message,
+          **overrides
+        )
+      end
+
+      private
+
+      def client
+        @client ||= Aws::SNS::Client.new(
+          ::ActiveRecordStreams::Credentials.new.build_credentials
+        )
+      end
+    end
+  end
+end

data/lib/active_record_streams/publishers/sns_client_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'sns_client'
+
+RSpec.describe ActiveRecordStreams::Publishers::SnsClient do
+  let(:topic_arn) { 'arn::some-topic-arn' }
+  let(:message) { 'dummy data' }
+  let(:overrides) { {} }
+
+  let(:aws_sns_client) { double }
+
+  before do
+    allow(Aws::SNS::Client).to receive(:new).and_return(aws_sns_client)
+  end
+
+  describe '#publish' do
+    subject do
+      described_class.new.publish(topic_arn, message, overrides)
+    end
+
+    context 'no overrides' do
+      it 'calls aws sdk' do
+        expect(aws_sns_client).to receive(:publish).with(
+          topic_arn: topic_arn,
+          message: message
+        )
+
+        subject
+      end
+    end
+
+    context 'overrides' do
+      let(:overrides) { { additional_param: true } }
+
+      it 'calls aws sdk' do
+        expect(aws_sns_client).to receive(:publish).with(
+          topic_arn: topic_arn,
+          message: message,
+          additional_param: true
+        )
+
+        subject
+      end
+    end
+  end
+end