Class: RubyEventStore::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/ruby_event_store/client.rb

Defined Under Namespace

Classes: Page, Within

Constant Summary collapse

DEPRECATED_WITHIN = 
"subscribe(subscriber, event_types, &task) has been deprecated. Use within(&task).subscribe(subscriber, to: event_types).call instead"
DEPRECATED_TO = 
"subscribe(subscriber, event_types) has been deprecated. Use subscribe(subscriber, to: event_types) instead"
DEPRECATED_ALL_WITHIN = 
"subscribe_to_all_events(subscriber, &task) has been deprecated. Use within(&task).subscribe_to_all_events(subscriber).call instead."

Instance Method Summary collapse

Constructor Details

#initialize(repository:, event_broker: PubSub::Broker.new, page_size: PAGE_SIZE, metadata_proc: nil, clock: ->{ Time.now.utc }) ⇒ Client

Returns a new instance of Client.



3
4
5
6
7
8
9
10
11
12
13
 
# File 'lib/ruby_event_store/client.rb', line 3

def initialize(repository:,
               event_broker:  PubSub::Broker.new,
               page_size: PAGE_SIZE,
               metadata_proc: nil,
               clock: ->{ Time.now.utc })
  @repository     = repository
  @event_broker   = event_broker
  @page_size      = page_size
  @metadata_proc  = metadata_proc
  @clock          = clock
end

Instance Method Details

#append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any) ⇒ Object 



27
28
29
30
31
32
 
# File 'lib/ruby_event_store/client.rb', line 27

def append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any)
  events = normalize_to_array(events)
  events.each{|event| enrich_event_metadata(event) }
  @repository.append_to_stream(events, stream_name, expected_version)
  :ok
end

#delete_stream(stream_name) ⇒ Object

Raises:



39
40
41
42
43
 
# File 'lib/ruby_event_store/client.rb', line 39

def delete_stream(stream_name)
  raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
  @repository.delete_stream(stream_name)
  :ok
end

#get_all_streams ⇒ Object 



81
82
83
 
# File 'lib/ruby_event_store/client.rb', line 81

def get_all_streams
  @repository.get_all_streams
end

#link_to_stream(event_ids, stream_name:, expected_version: :any) ⇒ Object 



34
35
36
37
 
# File 'lib/ruby_event_store/client.rb', line 34

def link_to_stream(event_ids, stream_name:, expected_version: :any)
  @repository.link_to_stream(event_ids, stream_name, expected_version)
  self
end

#publish_event(event, stream_name: GLOBAL_STREAM, expected_version: :any) ⇒ Object 



23
24
25
 
# File 'lib/ruby_event_store/client.rb', line 23

def publish_event(event, stream_name: GLOBAL_STREAM, expected_version: :any)
  publish_events([event], stream_name: stream_name, expected_version: expected_version)
end

#publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/ruby_event_store/client.rb', line 15

def publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any)
  append_to_stream(events, stream_name: stream_name, expected_version: expected_version)
  events.each do |ev|
    @event_broker.notify_subscribers(ev)
  end
  :ok
end

#read_all_streams_backward(start: :head, count: @page_size) ⇒ Object 



72
73
74
75
 
# File 'lib/ruby_event_store/client.rb', line 72

def read_all_streams_backward(start: :head, count: @page_size)
  page = Page.new(@repository, start, count)
  @repository.read_all_streams_backward(page.start, page.count)
end

#read_all_streams_forward(start: :head, count: @page_size) ⇒ Object 



67
68
69
70
 
# File 'lib/ruby_event_store/client.rb', line 67

def read_all_streams_forward(start: :head, count: @page_size)
  page = Page.new(@repository, start, count)
  @repository.read_all_streams_forward(page.start, page.count)
end

#read_event(event_id) ⇒ Object 



77
78
79
 
# File 'lib/ruby_event_store/client.rb', line 77

def read_event(event_id)
  @repository.read_event(event_id)
end

#read_events_backward(stream_name, start: :head, count: @page_size) ⇒ Object

Raises:



51
52
53
54
55
 
# File 'lib/ruby_event_store/client.rb', line 51

def read_events_backward(stream_name, start: :head, count: @page_size)
  raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
  page = Page.new(@repository, start, count)
  @repository.read_events_backward(stream_name, page.start, page.count)
end

#read_events_forward(stream_name, start: :head, count: @page_size) ⇒ Object

Raises:



45
46
47
48
49
 
# File 'lib/ruby_event_store/client.rb', line 45

def read_events_forward(stream_name, start: :head, count: @page_size)
  raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
  page = Page.new(@repository, start, count)
  @repository.read_events_forward(stream_name, page.start, page.count)
end

#read_stream_events_backward(stream_name) ⇒ Object

Raises:



62
63
64
65
 
# File 'lib/ruby_event_store/client.rb', line 62

def read_stream_events_backward(stream_name)
  raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
  @repository.read_stream_events_backward(stream_name)
end

#read_stream_events_forward(stream_name) ⇒ Object

Raises:



57
58
59
60
 
# File 'lib/ruby_event_store/client.rb', line 57

def read_stream_events_forward(stream_name)
  raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
  @repository.read_stream_events_forward(stream_name)
end

#subscribe(subscriber = nil, event_types = nil, to: nil, &proc) ⇒ Object

OLD:

subscribe(subscriber, event_types, &within)
subscribe(subscriber, event_types)

NEW:

subscribe(subscriber, to:)
subscribe(to:, &subscriber)



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/ruby_event_store/client.rb', line 94

def subscribe(subscriber = nil, event_types = nil, to: nil, &proc)
  if to
    raise ArgumentError, "subscriber must be first argument or block, cannot be both" if subscriber && proc
    raise SubscriberNotExist, "subscriber must be first argument or block" unless subscriber || proc
    raise ArgumentError, "list of event types must be second argument or named argument to: , it cannot be both" if event_types
    subscriber ||= proc
    @event_broker.add_subscriber(subscriber, to)
  else
    if proc
      warn(DEPRECATED_WITHIN)
      within(&proc).subscribe(subscriber, to: event_types).call
      -> {}
    else
      warn(DEPRECATED_TO)
      subscribe(subscriber, to: event_types)
    end
  end
end

#subscribe_to_all_events(subscriber = nil, &proc) ⇒ Object

OLD:

subscribe_to_all_events(subscriber, &within)
subscribe_to_all_events(subscriber)

NEW:

subscribe_to_all_events(subscriber)
subscribe_to_all_events(&subscriber)



120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/ruby_event_store/client.rb', line 120

def subscribe_to_all_events(subscriber = nil, &proc)
  if subscriber
    if proc
      warn(DEPRECATED_ALL_WITHIN)
      within(&proc).subscribe_to_all_events(subscriber).call
      -> {}
    else
      @event_broker.add_global_subscriber(subscriber)
    end
  else
    @event_broker.add_global_subscriber(proc)
  end
end

#within(&block) ⇒ Object

Raises:

  • (ArgumentError) 


181
182
183
184
 
# File 'lib/ruby_event_store/client.rb', line 181

def within(&block)
  raise ArgumentError if block.nil?
  Within.new(block, @event_broker)
end