Class: Graphiti::Resource

Inherits:
Object show all
Includes:
Links, Configuration, DSL, Documentation, Interface, Persistence, Sideloading
Defined in:
lib/graphiti/resource.rb,
lib/graphiti/resource/dsl.rb,
lib/graphiti/resource/remote.rb,
lib/graphiti/resource/interface.rb,
lib/graphiti/resource/persistence.rb,
lib/graphiti/resource/sideloading.rb,
lib/graphiti/resource/polymorphism.rb,
lib/graphiti/resource/configuration.rb,
lib/graphiti/resource/documentation.rb

Direct Known Subclasses

Query::RemoteSideloadResource

Defined Under Namespace

Modules: Configuration, DSL, Documentation, Interface, Persistence, Polymorphism, Remote, Sideloading

Constant Summary

Constants included from Links

Links::DEFAULT_ACTIONS

Constants included from Configuration

Configuration::DEFAULT_MAX_PAGE_SIZE

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Persistence

#assign_attributes, #build, #create, #delete, #destroy, #save, #update

Methods included from Sideloading

included

Methods included from Configuration

#adapter, #all_attributes, #attributes, #default_filters, #extra_attributes, #filters, #get_attr, #get_attr!, #grouped_filters, #pagination, #sort_all, #sorts, #stats

Class Method Details

.context ⇒ Object 



46
47
48
 
# File 'lib/graphiti/resource.rb', line 46

def self.context
  Graphiti.context[:object]
end

.context_namespace ⇒ Object 



54
55
56
 
# File 'lib/graphiti/resource.rb', line 54

def self.context_namespace
  Graphiti.context[:namespace]
end

Instance Method Details

#after_commit(model, metadata) ⇒ Object 



160
161
162
163
164
165
 
# File 'lib/graphiti/resource.rb', line 160

def after_commit(model, metadata)
  hooks = self.class.config[:after_commit][metadata[:method]] || []
  hooks.each do |hook|
    instance_exec(model, metadata, &hook)
  end
end

#after_filtering(scope) ⇒ Object 



23
24
25
 
# File 'lib/graphiti/resource.rb', line 23

def after_filtering(scope)
  scope
end

#after_graph_persist(model, metadata) ⇒ Object 



146
147
148
149
150
151
 
# File 'lib/graphiti/resource.rb', line 146

def after_graph_persist(model, metadata)
  hooks = self.class.config[:after_graph_persist][metadata[:method]] || []
  hooks.each do |hook|
    instance_exec(model, metadata, &hook)
  end
end

#around_scoping(scope, query_hash) {|scope| ... } ⇒ Object

Yields:

  • (scope) 


11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/graphiti/resource.rb', line 11

def around_scoping(scope, query_hash)
  extra_fields = query_hash[:extra_fields] || {}
  extra_fields = extra_fields[type] || []
  extra_fields.each do |name|
    if (config = self.class.config[:extra_attributes][name])
      scope = instance_exec(scope, &config[:hook]) if config[:hook]
    end
  end

  yield scope
end

#associate(parent, child, association_name, type) ⇒ Object 



118
119
120
 
# File 'lib/graphiti/resource.rb', line 118

def associate(parent, child, association_name, type)
  adapter.associate(parent, child, association_name, type)
end

#associate_all(parent, children, association_name, type) ⇒ Object 



114
115
116
 
# File 'lib/graphiti/resource.rb', line 114

def associate_all(parent, children, association_name, type)
  adapter.associate_all(parent, children, association_name, type)
end

#base_scope ⇒ Object 



66
67
68
 
# File 'lib/graphiti/resource.rb', line 66

def base_scope
  adapter.base_scope(model)
end

#before_commit(model, metadata) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/graphiti/resource.rb', line 153

def before_commit(model, metadata)
  hooks = self.class.config[:before_commit][metadata[:method]] || []
  hooks.each do |hook|
    instance_exec(model, metadata, &hook)
  end
end

#before_resolve(scope, query) ⇒ Object 



138
139
140
 
# File 'lib/graphiti/resource.rb', line 138

def before_resolve(scope, query)
  scope
end

#build_scope(base, query, opts = {}) ⇒ Object 



62
63
64
 
# File 'lib/graphiti/resource.rb', line 62

def build_scope(base, query, opts = {})
  Scope.new(base, self, query, opts)
end

#context ⇒ Object 



50
51
52
 
# File 'lib/graphiti/resource.rb', line 50

def context
  self.class.context
end

#context_namespace ⇒ Object 



58
59
60
 
# File 'lib/graphiti/resource.rb', line 58

def context_namespace
  self.class.context_namespace
end

#decorate_record(record, index = nil) ⇒ Object 



31
32
33
34
35
36
37
38
 
# File 'lib/graphiti/resource.rb', line 31

def decorate_record(record, index = nil)
  unless record.instance_variable_get(:@__graphiti_serializer)
    serializer = serializer_for(record)
    record.instance_variable_set(:@__graphiti_serializer, serializer)
    record.instance_variable_set(:@__graphiti_resource, self)
    record.instance_variable_set(:@__graphiti_index, index) if index
  end
end

#disassociate(parent, child, association_name, type) ⇒ Object 



122
123
124
 
# File 'lib/graphiti/resource.rb', line 122

def disassociate(parent, child, association_name, type)
  adapter.disassociate(parent, child, association_name, type)
end

#guard_model ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The model a writable guard is being asked about. Resolved lazily and memoized, so it costs nothing unless a guard asks for it, and is only resolved once per payload. On create, this is a new unsaved instance.



84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/graphiti/resource.rb', line 84

def guard_model
  return @guard_model if defined?(@guard_model)

  @guard_model = if !defined?(@guarded_write)
    nil
  elsif @guarded_write[:action] == :create || @guarded_write[:id].nil?
    build(model)
  else
    self.class._find(id: @guarded_write[:id]).data
  end
end

#links(model) ⇒ Object 



183
184
185
186
187
 
# File 'lib/graphiti/resource.rb', line 183

def links(model)
  self.class.links.each_with_object({}) do |(name, blk), memo|
    memo[name] = instance_exec(model, &blk)
  end
end

#links? ⇒ Boolean

Returns:

  • (Boolean) 


179
180
181
 
# File 'lib/graphiti/resource.rb', line 179

def links?
  self.class.links.any?
end

#persist_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil) ⇒ Object 



126
127
128
129
130
 
# File 'lib/graphiti/resource.rb', line 126

def persist_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil)
  persistence = Graphiti::Util::Persistence \
    .new(self, meta, attributes, relationships, caller_model, foreign_key)
  persistence.run
end

#resolve(scope) ⇒ Object 



142
143
144
 
# File 'lib/graphiti/resource.rb', line 142

def resolve(scope)
  adapter.resolve(scope)
end

#serializer_for(model) ⇒ Object 



27
28
29
 
# File 'lib/graphiti/resource.rb', line 27

def serializer_for(model)
  serializer
end

#stat(attribute, calculation) ⇒ Object

Raises:



132
133
134
135
136
 
# File 'lib/graphiti/resource.rb', line 132

def stat(attribute, calculation)
  stats_dsl = stats[attribute] || stats[attribute.to_sym]
  raise Errors::StatNotFound.new(attribute, calculation) unless stats_dsl
  stats_dsl.calculation(calculation)
end

#transaction ⇒ Object 



167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/graphiti/resource.rb', line 167

def transaction
  response = nil
  begin
    adapter.transaction(model) do
      response = yield
    end
  rescue Errors::ValidationError => e
    response = {result: e.validation_response}
  end
  response
end

#typecast(name, value, flag) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/graphiti/resource.rb', line 96

def typecast(name, value, flag)
  att = get_attr!(name, flag, request: true)
  type_name = att[:type]
  if flag == :filterable
    type_name = filters[name][:type]
  end
  type = Graphiti::Types[type_name]
  return if value.nil? && type[:kind] != "array"
  begin
    flag = :read if flag == :readable
    flag = :write if flag == :writable
    flag = :params if [:sortable, :filterable].include?(flag)
    type[flag][value]
  rescue => e
    raise Errors::TypecastFailed.new(self, name, value, e, type_name)
  end
end

#with_context(object, namespace = nil) ⇒ Object 



40
41
42
43
44
 
# File 'lib/graphiti/resource.rb', line 40

def with_context(object, namespace = nil)
  Graphiti.with_context(object, namespace) do
    yield
  end
end

#with_guarded_write(action, id) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Exposes write context to attribute guards for the duration of the block.



72
73
74
75
76
77
78
 
# File 'lib/graphiti/resource.rb', line 72

def with_guarded_write(action, id)
  @guarded_write = {action: action, id: id}
  yield
ensure
  remove_instance_variable(:@guarded_write) if defined?(@guarded_write)
  remove_instance_variable(:@guard_model) if defined?(@guard_model)
end