class SandthornDriverSequel::EventAccess

Public Class Methods

new(storage, serializer, deserializer) click to toggle source

EventAccess

Reads and writes events.

# File lib/sandthorn_driver_sequel/access/event_access.rb, line 8
def initialize storage, serializer, deserializer
  @serializer = serializer
  @deserializer = deserializer
  super storage
end

Public Instance Methods

find_events_by_aggregate_id(aggregate_id, after_aggregate_version = 0) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 23
def find_events_by_aggregate_id(aggregate_id, after_aggregate_version = 0)
  aggregate_version = Sequel.qualify(storage.events_table_name, :aggregate_version)
  wrap(storage.events
    .join(storage.aggregates_table_name, id: :aggregate_table_id)
    .where(aggregate_id: aggregate_id)
    .where(aggregate_version > after_aggregate_version)
    .select(
      :sequence_number,
      :aggregate_id,
      :aggregate_table_id,
      aggregate_version,
      :event_name,
      :event_data,
      :event_metadata,
      :timestamp)
    .order(:sequence_number)
    .all)
end
get_events(*args) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 42
def get_events(*args)
  query_builder = EventQuery.new(storage)
  query_builder.build(*args)
  wrap(query_builder.events)
end
store_events(aggregate, events) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 14
def store_events(aggregate, events)
  events = Utilities.array_wrap(events)
  timestamp = Time.now.utc
  events.each do |event|
    store_event(aggregate, timestamp, event)
  end
  aggregate.save
end

Private Instance Methods

build_event_data(aggregate, timestamp, event) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 67
def build_event_data(aggregate, timestamp, event)
  {
    aggregate_table_id: aggregate.id,
    aggregate_version: aggregate.aggregate_version,
    event_name: event.event_name,
    event_data: serialize(event.event_data),
    event_metadata: serialize(event.event_metadata),
    timestamp: timestamp
  }
end
check_versions!(aggregate, event) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 78
def check_versions!(aggregate, event)
  version = aggregate.aggregate_version
  if version != event[:aggregate_version]
    raise Errors::ConcurrencyError.new(event, aggregate)
  end
rescue TypeError
  raise Errors::EventFormatError, "Event has wrong format: #{event.inspect}"
end
deserialize(event_data) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 59
def deserialize event_data
  event_data ? @deserializer.call(event_data) : nil
end
serialize(event_data) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 63
def serialize event_data
  @serializer.call(event_data)
end
store_event(aggregate, timestamp, event) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 87
def store_event(aggregate, timestamp, event)
  event = EventWrapper.new(event)
  aggregate.aggregate_version += 1
  check_versions!(aggregate, event) if event[:aggregate_version]
  data = build_event_data(aggregate, timestamp, event)
  storage.events.insert(data)
end
wrap(arg) click to toggle source
# File lib/sandthorn_driver_sequel/access/event_access.rb, line 50
def wrap(arg)
  events = Utilities.array_wrap(arg)
  events.each { |e| 
    e[:event_data] = deserialize(e[:event_data])
    e[:event_metadata] = deserialize(e[:event_metadata])
  }
  events.map { |e| EventWrapper.new(e.values) }
end