pg_eventstore 0.1.0

data/lib/pg_eventstore/query_builders/events_filtering_query.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module QueryBuilders
+    # @!visibility private
+    class EventsFiltering
+      DEFAULT_OFFSET = 0
+      DEFAULT_LIMIT = 1000
+      SQL_DIRECTIONS = {
+        'asc' => 'ASC',
+        'desc' => 'DESC',
+        :asc => 'ASC',
+        :desc => 'DESC',
+        'Forwards' => 'ASC',
+        'Backwards' => 'DESC'
+      }.tap do |directions|
+        directions.default = 'ASC'
+      end.freeze
+
+      class << self
+        # @param options [Hash]
+        # @param offset [Integer]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def all_stream_filtering(options, offset: 0)
+          event_filter = new
+          options in { filter: { event_types: Array => event_types } }
+          event_filter.add_event_types(event_types)
+          event_filter.add_limit(options[:max_count])
+          event_filter.add_offset(offset)
+          event_filter.resolve_links(options[:resolve_link_tos])
+          options in { filter: { streams: Array => streams } }
+          streams&.each { |attrs| event_filter.add_stream_attrs(**attrs) }
+          event_filter.add_global_position(options[:from_position], options[:direction])
+          event_filter.add_all_stream_direction(options[:direction])
+          event_filter
+        end
+
+        # @param stream [PgEventstore::Stream]
+        # @param options [Hash]
+        # @param offset [Integer]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def specific_stream_filtering(stream, options, offset: 0)
+          event_filter = new
+          options in { filter: { event_types: Array => event_types } }
+          event_filter.add_event_types(event_types)
+          event_filter.add_limit(options[:max_count])
+          event_filter.add_offset(offset)
+          event_filter.resolve_links(options[:resolve_link_tos])
+          event_filter.add_stream(stream)
+          event_filter.add_revision(options[:from_revision], options[:direction])
+          event_filter.add_stream_direction(options[:direction])
+          event_filter
+        end
+      end
+
+      def initialize
+        @sql_builder =
+          SQLBuilder.new.
+            select('events.*').
+            select('row_to_json(streams.*) as stream').
+            from('events').
+            join('JOIN streams ON streams.id = events.stream_id').
+            limit(DEFAULT_LIMIT).
+            offset(DEFAULT_OFFSET)
+      end
+
+      # @param context [String, nil]
+      # @param stream_name [String, nil]
+      # @param stream_id [String, nil]
+      # @return [void]
+      def add_stream_attrs(context: nil, stream_name: nil, stream_id: nil)
+        stream_attrs = { context: context, stream_name: stream_name, stream_id: stream_id }
+        return unless correct_stream_filter?(stream_attrs)
+
+        stream_attrs.compact!
+        sql = stream_attrs.map do |attr, _|
+          "streams.#{attr} = ?"
+        end.join(" AND ")
+        @sql_builder.where_or(sql, *stream_attrs.values)
+      end
+
+      # @param stream [PgEventstore::Stream]
+      # @return [void]
+      def add_stream(stream)
+        @sql_builder.where("streams.id = ?", stream.id)
+      end
+
+      # @param event_types [Array, nil]
+      # @return [void]
+      def add_event_types(event_types)
+        return if event_types.nil?
+        return if event_types.empty?
+
+        sql = event_types.size.times.map do
+          "events.type = ?"
+        end.join(" OR ")
+        @sql_builder.where(sql, *event_types)
+      end
+
+      # @param revision [Integer, nil]
+      # @param direction [String, Symbol, nil]
+      # @return [void]
+      def add_revision(revision, direction)
+        return unless revision
+
+        @sql_builder.where("events.stream_revision #{direction_operator(direction)} ?", revision)
+      end
+
+      # @param position [Integer, nil]
+      # @param direction [String, Symbol, nil]
+      # @return [void]
+      def add_global_position(position, direction)
+        return unless position
+
+        @sql_builder.where("events.global_position #{direction_operator(direction)} ?", position)
+      end
+
+      # @param direction [String, Symbol, nil]
+      # @return [void]
+      def add_stream_direction(direction)
+        @sql_builder.order("events.stream_revision #{SQL_DIRECTIONS[direction]}")
+      end
+
+      # @param direction [String, Symbol, nil]
+      # @return [void]
+      def add_all_stream_direction(direction)
+        @sql_builder.order("events.global_position #{SQL_DIRECTIONS[direction]}")
+      end
+
+      # @param limit [Integer, nil]
+      # @return [void]
+      def add_limit(limit)
+        return unless limit
+
+        @sql_builder.limit(limit)
+      end
+
+      # @param offset [Integer, nil]
+      # @return [void]
+      def add_offset(offset)
+        return unless offset
+
+        @sql_builder.offset(offset)
+      end
+
+      # @param should_resolve [Boolean]
+      # @return [void]
+      def resolve_links(should_resolve)
+        return unless should_resolve
+
+        @sql_builder.
+          unselect.
+          select("(COALESCE(original_events.*, events.*)).*").
+          select('row_to_json(streams.*) as stream').
+          join("LEFT JOIN events original_events ON original_events.id = events.link_id")
+      end
+
+      # @return [Array]
+      def to_exec_params
+        @sql_builder.to_exec_params
+      end
+
+      private
+
+      # @param stream_attrs [Hash]
+      # @return [Boolean]
+      def correct_stream_filter?(stream_attrs)
+        result = (stream_attrs in { context: String, stream_name: String, stream_id: String } |
+          { context: String, stream_name: String, stream_id: nil } |
+          { context: String, stream_name: nil, stream_id: nil })
+        return true if result
+
+        PgEventstore&.logger&.debug(<<~TEXT)
+          Ignoring unsupported stream filter format for searching #{stream_attrs.compact.inspect}. \
+          See docs/reading_events.md docs for supported formats.
+        TEXT
+        false
+      end
+
+      # @param direction [String, Symbol, nil]
+      # @return [String]
+      def direction_operator(direction)
+        SQL_DIRECTIONS[direction] == 'ASC' ? '>=' : '<='
+      end
+    end
+  end
+end

data/lib/pg_eventstore/rspec/has_option_matcher.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# This matcher is defined to test options which are defined by using
+# EventStoreClient::Extensions::OptionsExtension option. Example:
+# Let's say you have next class
+# class SomeClass
+#   include PgEventstore::Extensions::OptionsExtension
+#
+#   option(:some_opt) { '1' }
+# end
+#
+# To test that its instance has the proper option with the proper default value you can use this
+# matcher:
+# RSpec.describe SomeClass do
+#   subject { described_class.new }
+#
+#   # Check that :some_opt is present
+#   it { is_expected.to have_option(:some_opt) }
+#   # Check that :some_opt is present and has the correct default value
+#   it { is_expected.to have_option(:some_opt).with_default_value('1') }
+# end
+#
+# If you have more complex implementation of default value of your option - you should handle it
+# customly. For example:
+# class SomeClass
+#   include PgEventstore::Extensions::OptionsExtension
+#
+#   option(:some_opt) { calc_value }
+# end
+# You could test it like so:
+# RSpec.described SomeClass do
+#   let(:instance) { described_class.new }
+#
+#   describe ':some_opt default value' do
+#     subject { instance.some_opt }
+#
+#     let(:value) { 'some val' }
+#
+#     before do
+#       allow(instance).to receive(:calc_value).and_return(value)
+#     end
+#
+#     it { is_expected.to eq(value) }
+#   end
+# end
+RSpec::Matchers.define :has_option do |option_name|
+  match do |obj|
+    option_presence = obj.class.respond_to?(:options) && obj.class.options.include?(option_name)
+    if @default_value
+      option_presence && RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(obj.class.allocate.public_send(option_name))
+    else
+      option_presence
+    end
+  end
+
+  failure_message do |obj|
+    option_presence = obj.class.respond_to?(:options) && obj.class.options.include?(option_name)
+    if option_presence && @default_value
+      msg = "Expected #{obj.class} to have `#{option_name.inspect}' option with #{@default_value.inspect}"
+      msg += ' default value, but default value is'
+      msg += " #{obj.class.allocate.public_send(option_name).inspect}"
+    else
+      msg = "Expected #{obj} to have `#{option_name.inspect}' option."
+    end
+
+    msg
+  end
+
+  description do
+    expected_list = RSpec::Matchers::EnglishPhrasing.list(expected)
+    sentences =
+      @chained_method_clauses.map do |(method_name, method_args)|
+        next '' if method_name == :required_kwargs
+
+        english_name = RSpec::Matchers::EnglishPhrasing.split_words(method_name)
+        arg_list = RSpec::Matchers::EnglishPhrasing.list(method_args)
+        " #{english_name}#{arg_list}"
+      end.join
+
+    "have#{expected_list} option#{sentences}"
+  end
+
+  chain :with_default_value do |val|
+    @default_value = val
+  end
+end
+
+RSpec::Matchers.alias_matcher :have_option, :has_option
+RSpec::Matchers.alias_matcher :has_attribute, :has_option
+RSpec::Matchers.alias_matcher :have_attribute, :has_option

data/lib/pg_eventstore/sql_builder.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # Deadly simple SQL builder
+  # @!visibility private
+  class SQLBuilder
+    def initialize
+      @select_values = []
+      @from_value = nil
+      @where_values = { 'AND' => [], 'OR' => [] }
+      @join_values = []
+      @order_values = []
+      @limit_value = nil
+      @offset_value = nil
+      @positional_values = []
+    end
+
+    # @param sql [String]
+    # @return self
+    def select(sql)
+      @select_values.push(sql)
+      self
+    end
+
+    # @return self
+    def unselect
+      @select_values.clear
+      self
+    end
+
+    # @param sql [String]
+    # @param arguments [Array] positional values
+    # @return self
+    def where(sql, *arguments)
+      sql = extract_positional_args(sql, *arguments)
+      @where_values['AND'].push("(#{sql})")
+      self
+    end
+
+    # @param sql [String]
+    # @param arguments [Object] positional values
+    # @return self
+    def where_or(sql, *arguments)
+      sql = extract_positional_args(sql, *arguments)
+      @where_values['OR'].push("(#{sql})")
+      self
+    end
+
+    # @param table_name [String]
+    # @return self
+    def from(table_name)
+      @from_value = table_name
+      self
+    end
+
+    # @param sql [String]
+    # @param arguments [Object]
+    # @return self
+    def join(sql, *arguments)
+      @join_values.push(extract_positional_args(sql, *arguments))
+      self
+    end
+
+    # @param sql [String]
+    # @return self
+    def order(sql)
+      @order_values.push(sql)
+      self
+    end
+
+    # @param limit [Integer]
+    # @return self
+    def limit(limit)
+      @limit_value = limit.to_i
+      self
+    end
+
+    # @param offset [Integer]
+    # @return self
+    def offset(offset)
+      @offset_value = offset.to_i
+      self
+    end
+
+    def to_exec_params
+      where_sql = [where_sql('OR'), where_sql('AND')].reject(&:empty?).map { |sql| "(#{sql})" }.join(' AND ')
+      sql = "SELECT #{select_sql} FROM #{@from_value}"
+      sql += " #{join_sql}" unless @join_values.empty?
+      sql += " WHERE #{where_sql}" unless where_sql.empty?
+      sql += " ORDER BY #{order_sql}" unless @order_values.empty?
+      sql += " LIMIT #{@limit_value}" if @limit_value
+      sql += " OFFSET #{@offset_value}" if @offset_value
+      [sql, @positional_values]
+    end
+
+    private
+
+    # @return [String]
+    def select_sql
+      @select_values.empty? ? '*' : @select_values.join(', ')
+    end
+
+    # @param join_pattern [String] "OR"/"AND"
+    # @return [String]
+    def where_sql(join_pattern)
+      @where_values[join_pattern].join(" #{join_pattern} ")
+    end
+
+    # @return [String]
+    def join_sql
+      @join_values.join(" ")
+    end
+
+    # @return [String]
+    def order_sql
+      @order_values.join(', ')
+    end
+
+    def extract_positional_args(sql, *arguments)
+      sql.gsub("?").each_with_index do |_, index|
+        @positional_values.push(arguments[index])
+        "$#{@positional_values.size}"
+      end
+    end
+  end
+end

data/lib/pg_eventstore/stream.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+module PgEventstore
+  class Stream
+    SYSTEM_STREAM_PREFIX = '$'
+    INITIAL_STREAM_REVISION = -1 # this is the default value of streams.stream_revision column
+
+    class << self
+      # Produces "all" stream instance. "all" stream does not represent any specific stream. Instead, it indicates that
+      # a specific command should be performed over any kind of streams if possible
+      # @return [PgEventstore::Stream]
+      def all_stream
+        allocate.tap do |stream|
+          stream.instance_variable_set(:@all_stream, true)
+        end
+      end
+    end
+
+    attr_reader :context, :stream_name, :stream_id, :id, :stream_revision
+
+    # @param context [String]
+    # @param stream_name [String]
+    # @param stream_id [String]
+    # @param id [Integer, nil] internal stream's id, read only
+    # @param stream_revision [Integer, nil] current stream revision, read only
+    def initialize(context:, stream_name:, stream_id:, id: nil, stream_revision: nil)
+      @context = context
+      @stream_name = stream_name
+      @stream_id = stream_id
+      @id = id
+      @stream_revision = stream_revision
+    end
+
+    # @return [Boolean]
+    def all_stream?
+      !!@all_stream
+    end
+
+    # Determine whether a stream is reserved by `pg_eventstore`. You can't append events to such streams.
+    # @return [Boolean]
+    def system?
+      all_stream? || context.start_with?(SYSTEM_STREAM_PREFIX)
+    end
+
+    # @return [Array]
+    def deconstruct
+      [context, stream_name, stream_id]
+    end
+    alias to_a deconstruct
+
+    # @param keys [Array<Symbol>, nil]
+    def deconstruct_keys(keys)
+      hash = { context: context, stream_name: stream_name, stream_id: stream_id }
+      return hash unless keys
+
+      hash.slice(*keys)
+    end
+
+    # @return [Hash]
+    def to_hash
+      deconstruct_keys(nil)
+    end
+
+    def ==(other_stream)
+      return false unless other_stream.is_a?(Stream)
+
+      to_hash == other_stream.to_hash
+    end
+  end
+end

data/lib/pg_eventstore/tasks/setup.rake

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+namespace :pg_eventstore do
+  desc "Creates events table, indexes, etc."
+  task :create do
+    PgEventstore.configure do |config|
+      config.pg_uri = ENV['PG_EVENTSTORE_URI']
+    end
+
+    db_files_root = "#{Gem::Specification.find_by_name("pg_eventstore").gem_dir}/db"
+
+    PgEventstore.connection.with do |conn|
+      conn.transaction do
+        conn.exec(File.read("#{db_files_root}/extensions.sql"))
+        conn.exec(File.read("#{db_files_root}/tables.sql"))
+        conn.exec(File.read("#{db_files_root}/primary_and_foreign_keys.sql"))
+        conn.exec(File.read("#{db_files_root}/indexes.sql"))
+      end
+    end
+  end
+
+  desc "Drops events table and related pg_eventstore objects."
+  task :drop do
+    PgEventstore.configure do |config|
+      config.pg_uri = ENV['PG_EVENTSTORE_URI']
+    end
+
+    PgEventstore.connection.with do |conn|
+      conn.exec <<~SQL
+        DROP TABLE IF EXISTS public.events;
+        DROP TABLE IF EXISTS public.streams;
+        DROP EXTENSION IF EXISTS "uuid-ossp";
+        DROP EXTENSION IF EXISTS pgcrypto;
+      SQL
+    end
+  end
+end

data/lib/pg_eventstore/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  VERSION = "0.1.0"
+end

data/lib/pg_eventstore.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'pg_eventstore/version'
+require_relative 'pg_eventstore/extensions/options_extension'
+require_relative 'pg_eventstore/event_class_resolver'
+require_relative 'pg_eventstore/config'
+require_relative 'pg_eventstore/event'
+require_relative 'pg_eventstore/sql_builder'
+require_relative 'pg_eventstore/stream'
+require_relative 'pg_eventstore/client'
+require_relative 'pg_eventstore/connection'
+require_relative 'pg_eventstore/errors'
+require_relative 'pg_eventstore/middleware'
+
+module PgEventstore
+  class << self
+    attr_reader :mutex
+    private :mutex
+
+    # Creates a Config if not exists and yields it to the given block.
+    # @param name [Symbol] a name to assign to a config
+    # @return [Object] a result of the given block
+    def configure(name: :default)
+      mutex.synchronize do
+        @config[name] ||= Config.new(name: name)
+        connection_config_was = @config[name].connection_options
+
+        yield(@config[name]).tap do
+          next if connection_config_was == @config[name].connection_options
+
+          # Reset the connection if user decided to reconfigure connection's options
+          @connection.delete(name)
+        end
+      end
+    end
+
+    # @param name [Symbol]
+    # @return [PgEventstore::Config]
+    def config(name = :default)
+      return @config[name] if @config[name]
+
+      error_message = <<~TEXT
+        Could not find #{name.inspect} config. You can define it like this:
+        PgEventstore.configure(name: #{name.inspect}) do |config|
+          # your config goes here
+        end
+      TEXT
+      raise error_message
+    end
+
+    # Look ups and returns a Connection, based on the given config. If not exists - it creates one. This operation is a
+    # thread-safe
+    # @param name [Symbol]
+    # @return [PgEventstore::Connection]
+    def connection(name = :default)
+      mutex.synchronize do
+        @connection[name] ||= Connection.new(**config(name).connection_options)
+      end
+    end
+
+    # @param name [Symbol]
+    # @return [PgEventstore::Client]
+    def client(name = :default)
+      Client.new(config(name))
+    end
+
+    def logger
+      @logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    private
+
+    # @return [void]
+    def init_variables
+      @config = { default: Config.new(name: :default) }
+      @connection = {}
+      @mutex = Thread::Mutex.new
+    end
+  end
+  init_variables
+end

data/pg_eventstore.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/pg_eventstore/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pg_eventstore"
+  spec.version = PgEventstore::VERSION
+  spec.authors = ["Ivan Dzyzenko"]
+  spec.email = ["ivan.dzyzenko@gmail.com"]
+
+  spec.summary = "EventStore implementation using PostgreSQL"
+  spec.description = "EventStore implementation using PostgreSQL"
+  spec.homepage = "https://github.com/yousty/pg_eventstore"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/yousty/pg_eventstore"
+  spec.metadata["changelog_uri"] = "https://github.com/yousty/pg_eventstore/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    paths_to_exclude = %w[
+      bin/ test/ spec/ features/ .git .circleci appveyor Gemfile .ruby-version .ruby-gemset .rspec docker-compose.yml
+      Rakefile benchmark/ .yardopts
+    ]
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*paths_to_exclude)
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "pg", "~> 1.5"
+  spec.add_dependency "connection_pool", "~> 2.4"
+end