evt-message_store-postgres 0.1.0.0

data/lib/message_store/postgres/controls/message_data.rb

@@ -0,0 +1,7 @@
+module MessageStore
+  module Postgres
+    module Controls
+      MessageData = MessageStore::Controls::MessageData
+    end
+  end
+end

data/lib/message_store/postgres/controls/put.rb

@@ -0,0 +1,26 @@
+module MessageStore
+  module Postgres
+    module Controls
+      module Put
+        def self.call(instances: nil, stream_name: nil, message: nil, category: nil)
+          instances ||= 1
+          stream_name ||= StreamName.example(category: category)
+
+          message_specified = !message.nil?
+
+          message ||= MessageData::Write.example
+
+          instances.times do
+            MessageStore::Postgres::Put.(message, stream_name)
+
+            unless message_specified
+              message.id = MessageData::Write.id
+            end
+          end
+
+          stream_name
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/controls/stream_name.rb

@@ -0,0 +1,22 @@
+# module MessageStore
+#   module Postgres
+#     module Controls
+#       StreamName = MessageStore::Controls::StreamName
+#     end
+#   end
+# end
+
+module MessageStore
+  module Postgres
+    module Controls
+      module StreamName
+        def self.example(category: nil, id: nil, type: nil, types: nil, randomize_category: nil)
+          category ||= Category.example(category: category, randomize_category: randomize_category)
+          id ||= Identifier::UUID.random
+
+          MessageStore::Postgres::StreamName.stream_name(category, id, type: type, types: types)
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get.rb

@@ -0,0 +1,91 @@
+module MessageStore
+  module Postgres
+    class Get
+      include MessageStore::Get
+
+      initializer :batch_size
+
+      dependency :session, Session
+
+      def self.build(batch_size: nil, session: nil)
+        new(batch_size).tap do |instance|
+          instance.configure(session: session)
+        end
+      end
+
+      def self.configure(receiver, attr_name: nil, position: nil, batch_size: nil, session: nil)
+        attr_name ||= :get
+        instance = build(batch_size: batch_size, session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+
+      def configure(session: nil)
+        Session.configure self, session: session
+      end
+
+      def self.call(stream_name, position: nil, batch_size: nil, session: nil)
+        instance = build(batch_size: batch_size, session: session)
+        instance.(stream_name, position: position)
+      end
+
+      def call(stream_name, position: nil)
+        logger.trace { "Getting message data (Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect})" }
+
+        records = get_records(stream_name, position)
+
+        messages = convert(records)
+
+        logger.info { "Finished getting message data (Count: #{messages.length}, Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect})" }
+        logger.info(tags: [:data, :message_data]) { messages.pretty_inspect }
+
+        messages
+      end
+
+      def get_records(stream_name, position)
+        logger.trace { "Getting records (Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
+
+        select_statement = SelectStatement.build(stream_name, position: position, batch_size: batch_size)
+
+        records = session.execute(select_statement.sql)
+
+        logger.debug { "Finished getting records (Count: #{records.ntuples}, Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
+
+        records
+      end
+
+      def convert(records)
+        logger.trace { "Converting records to message data (Records Count: #{records.ntuples})" }
+
+        messages = records.map do |record|
+          record['data'] = Deserialize.data(record['data'])
+          record['metadata'] = Deserialize.metadata(record['metadata'])
+          record['time'] = Time.utc_coerced(record['time'])
+
+          MessageData::Read.build record
+        end
+
+        logger.debug { "Converted records to message data (Message Data Count: #{messages.length})" }
+
+        messages
+      end
+
+      module Deserialize
+        def self.data(serialized_data)
+          return nil if serialized_data.nil?
+          Transform::Read.(serialized_data, MessageData::Hash, :json)
+        end
+
+        def self.metadata(serialized_metadata)
+          return nil if serialized_metadata.nil?
+          Transform::Read.(serialized_metadata, MessageData::Hash, :json)
+        end
+      end
+
+      module Time
+        def self.utc_coerced(local_time)
+          Clock::UTC.coerce(local_time)
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/last.rb

@@ -0,0 +1,111 @@
+module MessageStore
+  module Postgres
+    class Get
+      class Last
+        include Log::Dependency
+
+        dependency :session, Session
+
+        def self.build(session: nil)
+          new.tap do |instance|
+            instance.configure(session: session)
+          end
+        end
+
+        def self.configure(receiver, attr_name: nil, session: nil)
+          attr_name ||= :get_last
+          instance = build(session: session)
+          receiver.public_send "#{attr_name}=", instance
+        end
+
+        def configure(session: nil)
+          Session.configure self, session: session
+        end
+
+        def self.call(stream_name, session: nil)
+          instance = build(session: session)
+          instance.(stream_name)
+        end
+
+        def call(stream_name)
+          logger.trace { "Getting last message data (Stream Name: #{stream_name})" }
+
+          record = get_record(stream_name)
+
+          return nil if record.nil?
+
+          message_data = convert(record)
+
+          logger.info { "Finished getting message data (Stream Name: #{stream_name})" }
+          logger.info(tags: [:data, :message_data]) { message_data.pretty_inspect }
+
+          message_data
+        end
+
+        def get_record(stream_name)
+          logger.trace { "Getting last record (Stream: #{stream_name})" }
+
+          select_statement = SelectStatement.build(stream_name)
+
+          records = session.execute(select_statement.sql)
+
+          logger.debug { "Finished getting record (Stream: #{stream_name})" }
+
+          return nil if records.ntuples == 0
+
+          records[0]
+        end
+
+        def convert(record)
+          logger.trace { "Converting record to message data" }
+
+          record['data'] = Deserialize.data(record['data'])
+          record['metadata'] = Deserialize.metadata(record['metadata'])
+          record['time'] = Time.utc_coerced(record['time'])
+
+          message_data = MessageData::Read.build(record)
+
+          logger.debug { "Converted record to message data" }
+
+          message_data
+        end
+
+        def __convert(records)
+          logger.trace { "Converting records to message data (Records Count: #{records.ntuples})" }
+
+          messages = records.map do |record|
+            record['data'] = Deserialize.data(record['data'])
+            record['metadata'] = Deserialize.metadata(record['metadata'])
+            record['time'] = Time.utc_coerced(record['time'])
+
+            MessageData::Read.build record
+
+            break
+          end
+
+          logger.debug { "Converted records to message data (Message Data Count: #{messages.length})" }
+
+          messages
+        end
+
+        module Deserialize
+          def self.data(serialized_data)
+            return nil if serialized_data.nil?
+            Transform::Read.(serialized_data, MessageData::Hash, :json)
+          end
+
+          def self.metadata(serialized_metadata)
+            return nil if serialized_metadata.nil?
+            Transform::Read.(serialized_metadata, MessageData::Hash, :json)
+          end
+        end
+
+        module Time
+          def self.utc_coerced(local_time)
+            Clock::UTC.coerce(local_time)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/last/select_statement.rb

@@ -0,0 +1,47 @@
+module MessageStore
+  module Postgres
+    class Get
+      class Last
+        class SelectStatement
+          include Log::Dependency
+
+          initializer :stream_name
+
+          def self.build(stream_name)
+            new(stream_name)
+          end
+
+          def sql
+            logger.trace(tag: :sql) { "Composing select statement (Stream: #{stream_name})" }
+
+            statement = <<-SQL
+              SELECT
+                id::varchar,
+                stream_name::varchar,
+                position::int,
+                type::varchar,
+                global_position::bigint,
+                data::varchar,
+                metadata::varchar,
+                time::timestamp
+              FROM
+                events
+              WHERE
+                stream_name = '#{stream_name}'
+              ORDER BY
+                position DESC
+              LIMIT
+                1
+              ;
+            SQL
+
+            logger.debug(tag: :sql) { "Composed select statement (Stream: #{stream_name})" }
+            logger.debug(tags: [:data, :sql]) { "Statement: #{statement}" }
+
+            statement
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/get/select_statement.rb

@@ -0,0 +1,88 @@
+module MessageStore
+  module Postgres
+    class Get
+      class SelectStatement
+        include Log::Dependency
+
+        initializer :stream_name, w(:position), w(:batch_size)
+
+        def position
+          @position ||= Defaults.position
+        end
+
+        def batch_size
+          @batch_size ||= Defaults.batch_size
+        end
+
+        def stream_type_list
+          @stream_type ||= StreamName.get_type_list(stream_name)
+        end
+
+        def category_stream?
+          is_category_stream ||= StreamName.category?(stream_name)
+        end
+
+        def self.build(stream_name, position: nil, batch_size: nil)
+          new(stream_name, position, batch_size)
+        end
+
+        def sql
+          logger.trace(tag: :sql) { "Composing select statement (Stream: #{stream_name}, Category: #{category_stream?}, Types: #{stream_type_list.inspect}, Position: #{position}, Batch Size: #{batch_size})" }
+
+          statement = <<-SQL
+            SELECT
+              id::varchar,
+              stream_name::varchar,
+              position::int,
+              type::varchar,
+              global_position::bigint,
+              data::varchar,
+              metadata::varchar,
+              time::timestamp
+            FROM
+              events
+            WHERE
+              #{where_clause_field} = '#{stream_name}' AND
+              #{position_field} >= #{position}
+            ORDER BY
+              #{position_field} ASC
+            LIMIT
+              #{batch_size}
+            ;
+          SQL
+
+          logger.debug(tag: :sql) { "Composed select statement (Stream: #{stream_name}, Category: #{category_stream?}, Types: #{stream_type_list.inspect}, Position: #{position}, Batch Size: #{batch_size})" }
+          logger.debug(tags: [:data, :sql]) { "Statement: #{statement}" }
+
+          statement
+        end
+
+        def where_clause_field
+          unless category_stream?
+            'stream_name'
+          else
+            'category(stream_name)'
+          end
+        end
+
+        def position_field
+          unless category_stream?
+            'position'
+          else
+            'global_position'
+          end
+        end
+
+        module Defaults
+          def self.position
+            0
+          end
+
+          def self.batch_size
+            1000
+          end
+        end
+      end
+    end
+  end
+end

data/lib/message_store/postgres/log.rb

@@ -0,0 +1,11 @@
+module MessageStore
+  module Postgres
+    class Log < ::Log
+      def tag!(tags)
+        tags << :message_store_postgres
+        tags << :library
+        tags << :verbose
+      end
+    end
+  end
+end

data/lib/message_store/postgres/put.rb

@@ -0,0 +1,145 @@
+module MessageStore
+  module Postgres
+    class Put
+      include Log::Dependency
+
+      dependency :session, Session
+      dependency :identifier, Session
+
+      def self.build(session: nil)
+        new.tap do |instance|
+          instance.configure(session: session)
+        end
+      end
+
+      def configure(session: nil)
+        Session.configure(self, session: session)
+        Identifier::UUID::Random.configure(self)
+      end
+
+      def self.configure(receiver, session: nil, attr_name: nil)
+        attr_name ||= :put
+        instance = build(session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+
+      def self.call(write_message, stream_name, expected_version: nil, session: nil)
+        instance = build(session: session)
+        instance.(write_message, stream_name, expected_version: expected_version)
+      end
+
+      def call(write_message, stream_name, expected_version: nil)
+        logger.trace { "Putting message data (Stream Name: #{stream_name}, Type: #{write_message.type}, Expected Version: #{expected_version.inspect})" }
+        logger.trace(tags: [:data, :message_data]) { write_message.pretty_inspect }
+
+        write_message.id ||= identifier.get
+
+        id, type, data, metadata = destructure_message(write_message)
+        expected_version = ExpectedVersion.canonize(expected_version)
+
+        insert_message(id, stream_name, type, data, metadata, expected_version).tap do |position|
+          logger.info { "Put message data (Position: #{position}, Stream Name: #{stream_name}, Type: #{write_message.type}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect})" }
+          logger.info(tags: [:data, :message_data]) { write_message.pretty_inspect }
+        end
+      end
+
+      def destructure_message(write_message)
+        id = write_message.id
+        type = write_message.type
+        data = write_message.data
+        metadata = write_message.metadata
+
+        logger.debug(tags: [:data, :message_data]) { "ID: #{id.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Type: #{type.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Data: #{data.pretty_inspect}" }
+        logger.debug(tags: [:data, :message_data]) { "Metadata: #{metadata.pretty_inspect}" }
+
+        return id, type, data, metadata
+      end
+
+      def insert_message(id, stream_name, type, data, metadata, expected_version)
+        serialized_data = serialized_data(data)
+        serialized_metadata = serialized_metadata(metadata)
+        records = execute_query(id, stream_name, type, serialized_data, serialized_metadata, expected_version)
+        position(records)
+      end
+
+      def execute_query(id, stream_name, type, serialized_data, serialized_metadata, expected_version)
+        logger.trace { "Executing insert (Stream Name: #{stream_name}, Type: #{type}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect})" }
+
+        params = [
+          id,
+          stream_name,
+          type,
+          serialized_data,
+          serialized_metadata,
+          expected_version
+        ]
+
+        begin
+          records = session.execute(self.class.statement, params)
+        rescue PG::RaiseException => e
+          raise_error e
+        end
+
+        logger.debug { "Executed insert (Stream Name: #{stream_name}, Type: #{type}, Expected Version: #{expected_version.inspect}, ID: #{id.inspect})" }
+
+        records
+      end
+
+      def self.statement
+        @statement ||= "SELECT write_event($1::varchar, $2::varchar, $3::varchar, $4::jsonb, $5::jsonb, $6::int);"
+      end
+
+      def serialized_data(data)
+        serialized_data = nil
+
+        if data.is_a?(Hash) && data.empty?
+          data = nil
+        end
+
+        unless data.nil?
+          serializable_data = MessageData::Hash[data]
+          serialized_data = Transform::Write.(serializable_data, :json)
+        end
+
+        logger.debug(tags: [:data, :serialize]) { "Serialized Data: #{serialized_data.inspect}" }
+        serialized_data
+      end
+
+      def serialized_metadata(metadata)
+        serialized_metadata = nil
+
+        if metadata.is_a?(Hash) && metadata.empty?
+          metadata = nil
+        end
+
+        unless metadata.nil?
+          serializable_metadata = MessageData::Hash[metadata]
+          serialized_metadata = Transform::Write.(serializable_metadata, :json)
+        end
+
+        logger.debug(tags: [:data, :serialize]) { "Serialized Metadata: #{serialized_metadata.inspect}" }
+        serialized_metadata
+      end
+
+      def position(records)
+        position = nil
+        unless records[0].nil?
+          position = records[0].values[0]
+        end
+        position
+      end
+
+      def raise_error(pg_error)
+        error_message = pg_error.message
+        if error_message.include? 'Wrong expected version'
+          error_message.gsub!('ERROR:', '').strip!
+          logger.error { error_message }
+          raise ExpectedVersion::Error, error_message
+        end
+        raise pg_error
+      end
+    end
+  end
+end