Class: SolidObjects::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/solid_objects/client.rb,
sig/generated/lib/solid_objects/client.rbs

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(mailbox: Mailbox.new) ⇒ Client

Returns a new instance of Client.

RBS:

  • (?mailbox: Mailbox) -> void

Parameters:

  • mailbox: (Mailbox) (defaults to: Mailbox.new) 


11
12
13
 
# File 'lib/solid_objects/client.rb', line 11

def initialize(mailbox: Mailbox.new)
  @mailbox = mailbox
end

Instance Attribute Details

#mailbox ⇒ Object (readonly)

Returns the value of attribute mailbox.

Returns:

  • (Object) 


94
95
96
 
# File 'lib/solid_objects/client.rb', line 94

def mailbox
  @mailbox
end

Instance Method Details

#async(reference, message_name, arguments, available_at: nil, idempotency_key: nil, authorization_context: nil) ⇒ MessageReference

RBS:

  • (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference

Parameters:

  • (Reference)
  • (Symbol, String)
  • (Hash[Symbol | String, untyped])
  • available_at: (Time, nil) (defaults to: nil)
  • idempotency_key: (String, nil) (defaults to: nil)
  • authorization_context: (Object) (defaults to: nil)

Returns:



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/solid_objects/client.rb', line 16

def async(reference, message_name, arguments, available_at: nil, idempotency_key: nil, authorization_context: nil)
  actor_class = SolidObjects.registry.fetch(reference.actor_type)
  message_symbol = message_name.to_sym
  raise UnknownMessage, "unknown message #{message_name.inspect}" unless actor_class.definition.messages.key?(message_symbol)

  authorize!(
    SolidObjects.configuration.authorize_message,
    reference,
    message_name,
    arguments,
    authorization_context:
  )
  mailbox.enqueue(
    reference,
    message_name,
    arguments,
    kind: "async",
    available_at:,
    idempotency_key:
  )
end

#authorize!(hook, reference, message_name, arguments, authorization_context:) ⇒ void

This method returns an undefined value.

RBS:

  • (Proc, Reference, Symbol | String, Hash[Symbol | String, untyped], authorization_context: untyped) -> void

Parameters:

  • (Proc)
  • (Reference)
  • (Symbol, String)
  • (Hash[Symbol | String, untyped])
  • authorization_context: (Object) 


97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/solid_objects/client.rb', line 97

def authorize!(hook, reference, message_name, arguments, authorization_context:)
  authorized = hook.call(
    actor_type: reference.actor_type,
    actor_id: reference.actor_id,
    message_name: message_name.to_s,
    arguments:,
    authorization_context:
  )
  return if authorized

  raise Unauthorized, "actor invocation is not authorized"
end

#authorize_destroy!(reference, authorization_context:) ⇒ void

This method returns an undefined value.

RBS:

  • (Reference, authorization_context: untyped) -> void

Parameters:

  • (Reference)
  • authorization_context: (Object) 


111
112
113
114
115
116
117
118
119
120
 
# File 'lib/solid_objects/client.rb', line 111

def authorize_destroy!(reference, authorization_context:)
  authorized = SolidObjects.configuration.authorize_destroy.call(
    actor_type: reference.actor_type,
    actor_id: reference.actor_id,
    authorization_context:
  )
  return if authorized

  raise Unauthorized, "actor destruction is not authorized"
end

#destroy(reference, authorization_context: nil) ⇒ Boolean

RBS:

  • (Reference, ?authorization_context: untyped) -> bool

Parameters:

  • (Reference)
  • authorization_context: (Object) (defaults to: nil)

Returns:

  • (Boolean) 


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/solid_objects/client.rb', line 64

def destroy(reference, authorization_context: nil)
  raise ActorCallCycle, "actors cannot synchronously destroy another actor" if Context.current_actor

  SolidObjects.registry.fetch(reference.actor_type)
  authorize_destroy!(reference, authorization_context:)
  instance_id = SolidObjects.database_adapter.transaction do
    instance = Instance.lock.find_by(
      actor_type: reference.actor_type,
      actor_id: reference.actor_id
    )
    next unless instance

    instance_id = instance.id
    instance.delete
    instance_id
  end
  return false unless instance_id

  SolidObjects.instrument(
    :"actor.destroyed",
    instance_id:,
    actor_type: reference.actor_type,
    actor_id: reference.actor_id
  )
  SolidObjects.wake_up.signal
  true
end

#sync(reference, message_name, arguments, timeout:, idempotency_key: nil, authorization_context: nil) ⇒ Object

RBS:

  • (Reference, Symbol | String, Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped

Parameters:

  • (Reference)
  • (Symbol, String)
  • (Hash[Symbol | String, untyped])
  • timeout: (Numeric)
  • idempotency_key: (String, nil) (defaults to: nil)
  • authorization_context: (Object) (defaults to: nil)

Returns:

  • (Object) 


39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/solid_objects/client.rb', line 39

def sync(reference, message_name, arguments, timeout:, idempotency_key: nil, authorization_context: nil)
  actor_class = SolidObjects.registry.fetch(reference.actor_type)
  message_symbol = message_name.to_sym
  query = actor_class.definition.queries.key?(message_symbol)
  actor_message = actor_class.definition.messages.key?(message_symbol)
  raise UnknownMessage, "unknown message #{message_name.inspect}" unless query || actor_message

  authorize!(
    query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
    reference,
    message_name,
    arguments,
    authorization_context:
  )
  message_reference = mailbox.enqueue(
    reference,
    message_name,
    arguments,
    kind: "sync",
    idempotency_key:
  )
  SynchronousInvocation.new.call(message_reference, timeout:)
end