pg_eventstore 0.1.0

data/lib/pg_eventstore/connection.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'pg'
+require 'pg/basic_type_map_for_results'
+require 'pg/basic_type_map_for_queries'
+require 'connection_pool'
+
+module PgEventstore
+  class Connection
+    # Starting from ruby v3.1 ConnectionPool closes connections after forking by default. For ruby v3 we need this patch
+    # to correctly reload the ConnectionPool. Otherwise the same connection will leak into another process which will
+    # result in disaster.
+    # @!visibility private
+    module Ruby30Patch
+      def initialize(**)
+        @current_pid = Process.pid
+        @mutext = Mutex.new
+        super
+      end
+
+      def with(&blk)
+        reload_after_fork
+        super
+      end
+
+      private
+
+      def reload_after_fork
+        return if @current_pid == Process.pid
+
+        @mutext.synchronize do
+          return if @current_pid == Process.pid
+
+          @pool.reload(&:close)
+          @current_pid = Process.pid
+        end
+      end
+    end
+
+    attr_reader :uri, :pool_size, :pool_timeout
+    private :uri, :pool_size, :pool_timeout
+
+    # @param uri [String] PostgreSQL connection URI.
+    #   Example: "postgresql://postgres:postgres@localhost:5432/eventstore"
+    # @param pool_size [Integer] Connection pool size
+    # @param pool_timeout [Integer] Connection pool timeout in seconds
+    def initialize(uri:, pool_size: 5, pool_timeout: 5)
+      @uri = uri
+      @pool_size = pool_size
+      @pool_timeout = pool_timeout
+      init_pool
+    end
+
+    # A shorthand from ConnectionPool#with.
+    # @yieldparam connection [PG::Connection] PostgreSQL connection instance
+    # @return [Object] a value of a given block
+    def with(&blk)
+      should_retry = true
+      @pool.with do |conn|
+        yield conn
+      rescue PG::ConnectionBad
+        # Recover connection after fork. We do it only once and without any delay. Recover is required by both
+        # processes - child process and parent process
+        conn.sync_reset
+        raise unless should_retry
+        should_retry = false
+        retry
+      end
+    end
+
+    private
+
+    # @return [ConnectionPool]
+    def init_pool
+      @pool ||= ConnectionPool.new(size: pool_size, timeout: pool_timeout) do
+        PG::Connection.new(uri).tap do |conn|
+          conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn, registry: pg_type_registry)
+          conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn, registry: pg_type_registry)
+          # conn.trace($stdout) # logs
+        end
+      end
+    end
+
+    # @return [PG::BasicTypeRegistry]
+    def pg_type_registry
+      registry = PG::BasicTypeRegistry.new.register_default_types
+      # 0 means that the pg value format is a text(1 for binary)
+      registry.alias_type(0, 'uuid', 'text')
+      registry.register_type 0, 'timestamp', PG::TextEncoder::TimestampUtc, PG::TextDecoder::TimestampUtc
+      registry
+    end
+  end
+end
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
+  PgEventstore::Connection.prepend(PgEventstore::Connection::Ruby30Patch)
+end

data/lib/pg_eventstore/errors.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class Error < StandardError
+    # @return [Hash]
+    def as_json(*)
+      to_h.transform_keys(&:to_s)
+    end
+
+    # @return [Hash]
+    def to_h
+      hash =
+        instance_variables.each_with_object({}) do |var, result|
+          key = var.to_s
+          key[0] = '' # remove @ sign
+          result[key.to_sym] = instance_variable_get(var)
+        end
+      hash[:message] = message
+      hash[:backtrace] = backtrace
+      hash
+    end
+  end
+
+  class StreamNotFoundError < Error
+    attr_reader :stream
+
+    # @param stream [PgEventstore::Stream]
+    def initialize(stream)
+      @stream = stream
+      super("Stream #{stream.inspect} does not exist.")
+    end
+  end
+
+  class SystemStreamError < Error
+    attr_reader :stream
+
+    # @param stream [PgEventstore::Stream]
+    def initialize(stream)
+      @stream = stream
+      super("Stream #{stream.inspect} is a system stream and can't be used to append events.")
+    end
+  end
+
+  class WrongExpectedRevisionError < Error
+    attr_reader :revision, :expected_revision
+
+    # @param revision [Integer]
+    # @param expected_revision [Integer, Symbol]
+    def initialize(revision, expected_revision)
+      @revision = revision
+      @expected_revision = expected_revision
+      super(user_friendly_message)
+    end
+
+    private
+
+    # @return [String]
+    def user_friendly_message
+      return expected_stream_exists if revision == -1 && expected_revision == :stream_exists
+      return expected_no_stream if revision > -1 && expected_revision == :no_stream
+      return current_no_stream if revision == -1 && expected_revision.is_a?(Integer)
+
+      unmatched_stream_revision
+    end
+
+    # @return [String]
+    def expected_stream_exists
+      "Expected stream to exist, but it doesn't."
+    end
+
+    # @return [String]
+    def expected_no_stream
+      "Expected stream to be absent, but it actually exists."
+    end
+
+    # @return [String]
+    def current_no_stream
+      "Stream revision #{expected_revision} is expected, but stream does not exist."
+    end
+
+    # @return [String]
+    def unmatched_stream_revision
+      "Stream revision #{expected_revision} is expected, but actual stream revision is #{revision.inspect}."
+    end
+  end
+
+  class StreamDeletionError < Error
+    attr_reader :stream_name, :details
+
+    # @param stream_name [String]
+    # @param details [String]
+    def initialize(stream_name, details:)
+      @stream_name = stream_name
+      @details = details
+      super(user_friendly_message)
+    end
+
+    # @return [String]
+    def user_friendly_message
+      <<~TEXT.strip
+        Could not delete #{stream_name.inspect} stream. It seems that a stream with that \
+        name does not exist, has already been deleted or its state does not match the \
+        provided :expected_revision option. Please check #details for more info.
+      TEXT
+    end
+  end
+end

data/lib/pg_eventstore/event.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class Event
+    include Extensions::OptionsExtension
+
+    LINK_TYPE = '$>'
+
+    # @!attribute id
+    #   @return [String] UUIDv4 string
+    attribute(:id)
+    # @!attribute type
+    #   @return [String] event type
+    attribute(:type) { self.class.name }
+    # @!attribute global_position
+    #   @return [Integer] event's position in "all" stream
+    attribute(:global_position)
+    # @!attribute stream
+    #   @return [PgEventstore::Stream, nil] event's stream
+    attribute(:stream)
+    # @!attribute stream_revision
+    #   @return [Integer] a revision of an event inside event's stream
+    attribute(:stream_revision)
+    # @!attribute data
+    #   @return [Hash] event's data
+    attribute(:data) { {} }
+    # @!attribute metadata
+    #   @return [Hash] event's metadata
+    attribute(:metadata) { {} }
+    # @!attribute link_id
+    #   @return [String, nil] UUIDv4 of an event the current event points to. If it is not nil, then the current
+    #     event is a link
+    attribute(:link_id)
+    # @!attribute created_at
+    #   @return [Time, nil] a timestamp an event was created at
+    attribute(:created_at)
+
+    # Implements comparison of `PgEventstore::Event`-s. Two events matches if all of their attributes matches
+    # @param other [Object, EventStoreClient::DeserializedEvent]
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(PgEventstore::Event)
+
+      attributes_hash == other.attributes_hash
+    end
+
+    # Detect whether an event is a link event
+    # @return [Boolean]
+    def link?
+      !link_id.nil?
+    end
+
+    # Detect whether an event is a system event
+    # @return [Boolean]
+    def system?
+      type.start_with?('$')
+    end
+  end
+end

data/lib/pg_eventstore/event_class_resolver.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class EventClassResolver
+    # @param event_type [String]
+    # @return [Class]
+    def call(event_type)
+      Object.const_get(event_type)
+    rescue NameError, TypeError
+      PgEventstore.logger&.debug(<<~TEXT.strip)
+        Unable to resolve class by `#{event_type}' event type. \
+        Picking #{Event} event class to instantiate the event.
+      TEXT
+      Event
+    end
+  end
+end

data/lib/pg_eventstore/event_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventSerializer
+    attr_reader :middlewares
+
+    # @param middlewares [Array<#deserialize, #serialize>]
+    def initialize(middlewares)
+      @middlewares = middlewares
+    end
+
+    # @param event [PgEventstore::Event]
+    # @return [PgEventstore::Event]
+    def serialize(event)
+      @middlewares.each do |middleware|
+        middleware.serialize(event)
+      end
+      event
+    end
+
+    # @return [PgEventstore::EventSerializer]
+    def without_middlewares
+      self.class.new([])
+    end
+  end
+end

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module PgEventstore
+  module Extensions
+    # A very simple extension that implements a DSL for adding attr_accessors with default values,
+    # and assigning their values during object initialization.
+    # Example. Let's say you frequently do something like this:
+    # ```ruby
+    # class SomeClass
+    #   attr_accessor :attr1, :attr2, :attr3, :attr4
+    #
+    #   def initialize(opts = {})
+    #     @attr1 = opts[:attr1] || 'Attr 1 value'
+    #     @attr2 = opts[:attr2] || 'Attr 2 value'
+    #     @attr3 = opts[:attr3] || do_some_calc
+    #     @attr4 = opts[:attr4]
+    #   end
+    #
+    #   def do_some_calc
+    #   end
+    # end
+    #
+    # SomeClass.new(attr1: 'hihi', attr4: 'byebye')
+    # ```
+    #
+    # You can replace the code above using the OptionsExtension:
+    # ```ruby
+    # class SomeClass
+    #   include PgEventstore::Extensions::OptionsExtension
+    #
+    #   option(:attr1) { 'Attr 1 value' }
+    #   option(:attr2) { 'Attr 2 value' }
+    #   option(:attr3) { do_some_calc }
+    #   option(:attr4)
+    # end
+    #
+    # SomeClass.new(attr1: 'hihi', attr4: 'byebye')
+    # ```
+    module OptionsExtension
+      module ClassMethods
+        # @param opt_name [Symbol] option name
+        # @param blk [Proc] provide define value using block. It will be later evaluated in the
+        #   context of your object to determine the default value of the option
+        # @return [Symbol]
+        def option(opt_name, &blk)
+          self.options = (options + Set.new([opt_name])).freeze
+          warn_already_defined(opt_name)
+          warn_already_defined(:"#{opt_name}=")
+          attr_writer opt_name
+
+          define_method opt_name do
+            result = instance_variable_get(:"@#{opt_name}")
+            return result if instance_variable_defined?(:"@#{opt_name}")
+
+            instance_exec(&blk) if blk
+          end
+        end
+        alias attribute option
+
+        def inherited(klass)
+          super
+          klass.options = Set.new(options).freeze
+        end
+
+        private
+
+        # @param method_name [Symbol]
+        # @return [void]
+        def warn_already_defined(method_name)
+          return unless instance_methods.include?(method_name)
+
+          puts "Warning: Redefining already defined method #{self}##{method_name}"
+        end
+      end
+
+      def self.included(klass)
+        klass.singleton_class.attr_accessor(:options)
+        klass.options = Set.new.freeze
+        klass.extend(ClassMethods)
+      end
+
+      def initialize(**options)
+        self.class.options.each do |option|
+          # init default values of options
+          value = options.key?(option) ? options[option] : public_send(option)
+          public_send("#{option}=", value)
+        end
+      end
+
+      # Construct a hash from options, where key is the option's name and the value is option's
+      # value
+      # @return [Hash]
+      def options_hash
+        self.class.options.each_with_object({}) do |option, res|
+          res[option] = public_send(option)
+        end
+      end
+      alias attributes_hash options_hash
+    end
+  end
+end

data/lib/pg_eventstore/middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Middleware
+    # @param event [PgEventstore::Event]
+    # @return [void]
+    def serialize(event)
+    end
+
+    # @param event [PgEventstore::Event]
+    # @return [void]
+    def deserialize(event)
+    end
+  end
+end

data/lib/pg_eventstore/pg_result_deserializer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class PgResultDeserializer
+    attr_reader :middlewares, :event_class_resolver
+
+    # @param middlewares [Array<Object<#deserialize, #serialize>>]
+    # @param event_class_resolver [#call]
+    def initialize(middlewares, event_class_resolver)
+      @middlewares = middlewares
+      @event_class_resolver = event_class_resolver
+    end
+
+    # @param pg_result [PG::Result]
+    # @return [Array<PgEventstore::Event>]
+    def deserialize(pg_result)
+      pg_result.map(&method(:_deserialize))
+    end
+    alias deserialize_many deserialize
+
+    # @param pg_result [PG::Result]
+    # @return [PgEventstore::Event, nil]
+    def deserialize_one(pg_result)
+      return if pg_result.ntuples.zero?
+
+      _deserialize(pg_result.first)
+    end
+
+    # @return [PgEventstore::PgResultDeserializer]
+    def without_middlewares
+      self.class.new([], event_class_resolver)
+    end
+
+    private
+
+    # @param attrs [Hash]
+    # @return [PgEventstore::Event]
+    def _deserialize(attrs)
+      event = event_class_resolver.call(attrs['type']).new(**attrs.transform_keys(&:to_sym))
+      middlewares.each do |middleware|
+        middleware.deserialize(event)
+      end
+      event.stream = PgEventstore::Stream.new(**attrs['stream'].transform_keys(&:to_sym)) if attrs.key?('stream')
+      event
+    end
+  end
+end

data/lib/pg_eventstore/queries.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'query_builders/events_filtering_query'
+
+module PgEventstore
+  # @!visibility private
+  class Queries
+    attr_reader :connection, :serializer, :deserializer
+    private :connection, :serializer, :deserializer
+
+    # @param connection [PgEventstore::Connection]
+    # @param serializer [PgEventstore::EventSerializer]
+    # @param deserializer [PgEventstore::PgResultDeserializer]
+    def initialize(connection, serializer, deserializer)
+      @connection = connection
+      @serializer = serializer
+      @deserializer = deserializer
+    end
+
+    # @return [void]
+    def transaction
+      connection.with do |conn|
+        # We are inside a transaction already - no need to start another one
+        if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
+          next yield
+        end
+
+        conn.transaction do
+          conn.exec("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
+          yield
+        end
+      end
+    rescue PG::TRSerializationFailure, PG::TRDeadlockDetected => e
+      retry if e.connection.transaction_status == PG::PQTRANS_IDLE
+      raise
+    end
+
+    # Finds a stream in the database by the given Stream object
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::Stream, nil] persisted stream
+    def find_stream(stream)
+      builder =
+        SQLBuilder.new.
+          from('streams').
+          where('streams.context = ? AND streams.stream_name = ? AND streams.stream_id = ?', *stream.to_a).
+          limit(1)
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym)) if pg_result.ntuples == 1
+    end
+
+    # @param stream [PgEventstore::Stream]
+    # @return [PgEventstore::RawStream] persisted stream
+    def create_stream(stream)
+      create_sql = <<~SQL
+        INSERT INTO streams (context, stream_name, stream_id) VALUES ($1, $2, $3) RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(create_sql, stream.to_a)
+      end
+      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym))
+    end
+
+    # @return [PgEventstore::Stream] persisted stream
+    def find_or_create_stream(stream)
+      find_stream(stream) || create_stream(stream)
+    end
+
+    # @see PgEventstore::Client#read for more info
+    # @param stream [PgEventstore::Stream]
+    # @param options [Hash]
+    # @return [Array<PgEventstore::Event>]
+    def stream_events(stream, options)
+      exec_params = events_filtering(stream, options).to_exec_params
+      pg_result = connection.with do |conn|
+        conn.exec_params(*exec_params)
+      end
+      deserializer.deserialize_many(pg_result)
+    end
+
+    # @param stream [PgEventstore::Stream] persisted stream
+    # @param event [PgEventstore::Event]
+    # @return [PgEventstore::Event]
+    def insert(stream, event)
+      serializer.serialize(event)
+
+      attributes = event.options_hash.slice(:id, :type, :data, :metadata, :stream_revision, :link_id).compact
+      attributes[:stream_id] = stream.id
+
+      sql = <<~SQL
+        INSERT INTO events (#{attributes.keys.join(', ')}) 
+          VALUES (#{(1..attributes.values.size).map { |n| "$#{n}" }.join(', ')}) 
+          RETURNING *
+      SQL
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, attributes.values)
+      end
+      deserializer.without_middlewares.deserialize_one(pg_result).tap do |persisted_event|
+        persisted_event.stream = stream
+      end
+    end
+
+    # @param stream [PgEventstore::Stream] persisted stream
+    # @return [void]
+    def update_stream_revision(stream, revision)
+      connection.with do |conn|
+        conn.exec_params(<<~SQL, [revision, stream.id])
+          UPDATE streams SET stream_revision = $1 WHERE id = $2
+        SQL
+      end
+    end
+
+    private
+
+    # @param stream [PgEventstore::Stream]
+    # @param options [Hash]
+    # @param offset [Integer]
+    # @return [PgEventstore::EventsFilteringQuery]
+    def events_filtering(stream, options, offset: 0)
+      return QueryBuilders::EventsFiltering.all_stream_filtering(options, offset: offset) if stream.all_stream?
+
+      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options, offset: offset)
+    end
+  end
+end