pg_eventstore 0.9.0 → 0.10.2

data/lib/pg_eventstore/queries/event_type_queries.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class EventTypeQueries
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # @param type [String]
-    # @return [Integer] event type's id
-    def find_or_create_type(type)
-      find_type(type) || create_type(type)
-    end
-
-    # @param type [String]
-    # @return [Integer, nil] event type's id
-    def find_type(type)
-      connection.with do |conn|
-        conn.exec_params('SELECT id FROM event_types WHERE type = $1', [type])
-      end.to_a.dig(0, 'id')
-    end
-
-    # @param type [String]
-    # @return [Integer] event type's id
-    def create_type(type)
-      connection.with do |conn|
-        conn.exec_params('INSERT INTO event_types (type) VALUES ($1) RETURNING id', [type])
-      end.to_a.dig(0, 'id')
-    end
-
-    # @param ids [Array<Integer>]
-    # @return [Array<Hash>]
-    def find_by_ids(ids)
-      return [] if ids.empty?
-
-      builder = SQLBuilder.new.from('event_types').where('id = ANY(?)', ids.uniq)
-      connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end.to_a
-    end
-
-    # @param types [Array<String>]
-    # @return [Array<Integer, nil>]
-    def find_event_types(types)
-      connection.with do |conn|
-        conn.exec_params(<<~SQL, [types])
-          SELECT event_types.id, types.type
-            FROM event_types 
-            RIGHT JOIN (
-              SELECT unnest($1::varchar[]) as type
-            ) types ON types.type = event_types.type
-        SQL
-      end.to_a.map { |attrs| attrs['id'] }
-    end
-
-    # Replaces filter by event type strings with filter by event type ids
-    # @param options [Hash]
-    # @return [Hash]
-    def include_event_types_ids(options)
-      options in { filter: { event_types: Array => event_types } }
-      return options unless event_types
-
-      options = Utils.deep_dup(options)
-      options[:filter][:event_type_ids] = find_event_types(event_types).uniq
-      options[:filter].delete(:event_types)
-      options
-    end
-  end
-end

data/lib/pg_eventstore/queries/preloader.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class Preloader
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # @param raw_events [Array<Hash>]
-    # @return [Array<Hash>]
-    def preload_related_objects(raw_events)
-      streams = stream_queries.find_by_ids(raw_events.map { _1['stream_id'] }).to_h { [_1['id'], _1] }
-      types = event_type_queries.find_by_ids(raw_events.map { _1['event_type_id'] }).to_h { [_1['id'], _1] }
-      raw_events.each do |event|
-        event['stream'] = streams[event['stream_id']]
-        event['type'] = types[event['event_type_id']]['type']
-      end
-    end
-
-    private
-
-    # @return [PgEventstore::EventTypeQueries]
-    def event_type_queries
-      EventTypeQueries.new(connection)
-    end
-
-    # @return [PgEventstore::StreamQueries]
-    def stream_queries
-      StreamQueries.new(connection)
-    end
-  end
-end

data/lib/pg_eventstore/queries/stream_queries.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module PgEventstore
-  # @!visibility private
-  class StreamQueries
-    attr_reader :connection
-    private :connection
-
-    # @param connection [PgEventstore::Connection]
-    def initialize(connection)
-      @connection = connection
-    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
-      deserialize(pg_result) if pg_result.ntuples == 1
-    end
-
-    # @param ids [Array<Integer>]
-    # @return [Array<Hash>]
-    def find_by_ids(ids)
-      return [] if ids.empty?
-
-      builder = SQLBuilder.new.from('streams').where('id = ANY(?)', ids.uniq.sort)
-      connection.with do |conn|
-        conn.exec_params(*builder.to_exec_params)
-      end.to_a
-    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
-      deserialize(pg_result)
-    end
-
-    # @return [PgEventstore::Stream] persisted stream
-    def find_or_create_stream(stream)
-      find_stream(stream) || create_stream(stream)
-    end
-
-    # @param stream [PgEventstore::Stream] persisted stream
-    # @return [PgEventstore::Stream]
-    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
-      stream.stream_revision = revision
-      stream
-    end
-
-    private
-
-    # @param pg_result [PG::Result]
-    # @return [PgEventstore::Stream, nil]
-    def deserialize(pg_result)
-      PgEventstore::Stream.new(**pg_result.to_a.first.transform_keys(&:to_sym))
-    end
-  end
-end