Class: Graphiti::Query

Inherits:
Object show all
Defined in:
lib/graphiti/query.rb

Defined Under Namespace

Classes: RemoteSideloadResource

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(resource, params, *positional, association_name: nil, nested_include: nil, parents: [], action: nil) ⇒ Query

Returns a new instance of Query.



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/graphiti/query.rb', line 7

def initialize(resource, params, *positional, association_name: nil, nested_include: nil, parents: [], action: nil)
  if positional.any?
    Graphiti::DEPRECATOR.warn("Passing Query.new trailing arguments positionally is deprecated. Use association_name:/nested_include:/parents:/action: keywords.")
    association_name ||= positional[0]
    nested_include ||= positional[1]
    parents = positional[2] if positional.length > 2
    action ||= positional[3]
  end

  @resource = resource
  @association_name = association_name
  @params = params
  @params = @params.permit! if @params.respond_to?(:permit!)
  @params = @params.to_h if @params.respond_to?(:to_h)
  @params = @params.deep_symbolize_keys
  @include_param = nested_include || @params[:include]
  @parents = parents
  @action = parse_action(action)
end

Instance Attribute Details

#action ⇒ Object (readonly)

Returns the value of attribute action.



5
6
7
 
# File 'lib/graphiti/query.rb', line 5

def action
  @action
end

#association_name ⇒ Object (readonly)

Returns the value of attribute association_name.



5
6
7
 
# File 'lib/graphiti/query.rb', line 5

def association_name
  @association_name
end

#params ⇒ Object (readonly)

Returns the value of attribute params.



5
6
7
 
# File 'lib/graphiti/query.rb', line 5

def params
  @params
end

#resource ⇒ Object (readonly)

Returns the value of attribute resource.



5
6
7
 
# File 'lib/graphiti/query.rb', line 5

def resource
  @resource
end

Instance Method Details

#association? ⇒ Boolean

Returns:

  • (Boolean) 


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

def association?
  !!@association_name
end

#cache_key ⇒ Object 



260
261
262
 
# File 'lib/graphiti/query.rb', line 260

def cache_key
  "args-#{query_cache_key}"
end

#debug_requested? ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/graphiti/query.rb', line 61

def debug_requested?
  !!@params[:debug]
end

#entity_map ⇒ Object

Concurrent::Map because sideload scopes resolve on pool threads



32
33
34
35
36
 
# File 'lib/graphiti/query.rb', line 32

def entity_map
  return root.entity_map unless root == self

  @entity_map ||= Concurrent::Map.new
end

#extra_fields ⇒ Object 



156
157
158
 
# File 'lib/graphiti/query.rb', line 156

def extra_fields
  @extra_fields ||= parse_fieldset(@params[:extra_fields] || {})
end

#fields ⇒ Object 



146
147
148
149
150
151
152
153
154
 
# File 'lib/graphiti/query.rb', line 146

def fields
  @fields ||= begin
    hash = parse_fieldset(@params[:fields] || {})
    hash.each_pair do |type, fields|
      hash[type] += extra_fields[type] if extra_fields[type]
    end
    hash
  end
end

#filters ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/graphiti/query.rb', line 160

def filters
  @filters ||= {}.tap do |hash|
    (@params[:filter] || {}).each_pair do |name, value|
      name = name.to_sym

      if legacy_nested?(name)
        value.keys.each do |key|
          filter_name = key.to_sym
          filter_value = value[key]

          if @resource.get_attr!(filter_name, :filterable, request: true)
            hash[filter_name] = filter_value
          end
        end
      elsif nested?(name)
        name = name.to_s.split(".").last.to_sym
        validate!(name, :filterable)
        hash[name] = value
      elsif top_level? && validate!(name, :filterable)
        hash[name] = value
      end
    end
  end
end

#hash ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/graphiti/query.rb', line 65

def hash
  @hash ||= {}.tap do |h|
    h[:filter] = filters
    h[:sort] = sorts
    h[:page] = pagination
    if association?
      resource_type = @resource.class.type
      h[:extra_fields] = {resource_type => extra_fields[resource_type]} if extra_fields.key?(resource_type)
    else
      h[:fields] = fields
      h[:extra_fields] = extra_fields
    end
    h[:stats] = stats
    h[:include] = sideload_hash
  end.reject { |_, value| value.empty? }
end

#include_hash ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/graphiti/query.rb', line 224

def include_hash
  @include_hash ||= begin
    requested = include_directive.to_hash

    allowlist = nil
    if @resource.context&.respond_to?(:sideload_allowlist)
      allowlist = @resource.context.sideload_allowlist
      allowlist = allowlist[@resource.current_action] if allowlist
    end

    scrubbed = allowlist ? Util::IncludeParams.scrub(requested, allowlist) : requested

    scrubbed.filter do |key, value|
      sideload = @resource.class.sideload(key)
      sideload.nil? || sideload.readable?
    end
  end
end

#links? ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
45
46
47
48
49
 
# File 'lib/graphiti/query.rb', line 42

def links?
  return false if [:json, :xml, "json", "xml"].include?(params[:format])
  if Graphiti.config.links_on_demand
    [true, "true"].include?(@params[:links])
  else
    true
  end
end

#paginate? ⇒ Boolean

Returns:

  • (Boolean) 


256
257
258
 
# File 'lib/graphiti/query.rb', line 256

def paginate?
  ![false, "false"].include?(@params[:paginate])
end

#pagination ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/graphiti/query.rb', line 207

def pagination
  @pagination ||= {}.tap do |hash|
    (@params[:page] || {}).each_pair do |name, value|
      if legacy_nested?(name)
        value.each_pair do |k, v|
          hash[k.to_sym] = cast_page_param(k.to_sym, v)
        end
      elsif nested?(name)
        param_name = name.to_s.split(".").last.to_sym
        hash[param_name] = cast_page_param(param_name, value)
      elsif top_level? && Scoping::Paginate::PARAMS.include?(name.to_sym)
        hash[name.to_sym] = cast_page_param(name.to_sym, value)
      end
    end
  end
end

#pagination_links? ⇒ Boolean

Returns:

  • (Boolean) 


51
52
53
54
55
56
57
58
59
 
# File 'lib/graphiti/query.rb', line 51

def pagination_links?
  if action == :find
    false
  elsif Graphiti.config.pagination_links_on_demand
    [true, "true"].include?(@params[:pagination_links])
  else
    Graphiti.config.pagination_links
  end
end

#parents ⇒ Object 



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

def parents
  @parents ||= []
end

#resource_for_sideload(sideload) ⇒ Object 



101
102
103
104
105
106
107
 
# File 'lib/graphiti/query.rb', line 101

def resource_for_sideload(sideload)
  if @resource.remote?
    RemoteSideloadResource.new
  else
    sideload.resource
  end
end

#root ⇒ Object 



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

def root
  parents.first || self
end

#sideload_hash ⇒ Object 



88
89
90
91
92
93
94
 
# File 'lib/graphiti/query.rb', line 88

def sideload_hash
  @sideload_hash = {}.tap do |hash|
    sideloads.each_pair do |key, value|
      hash[key] = sideloads[key].hash
    end
  end
end

#sideloads ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/graphiti/query.rb', line 109

def sideloads
  @sideloads ||= {}.tap do |hash|
    include_hash.each_pair do |key, sub_hash|
      sideload = @resource.class.sideload(key)

      if sideload || @resource.remote?
        sl_resource = resource_for_sideload(sideload)
        query_parents = parents + [self]
        sub_hash = sub_hash[:include] if sub_hash.key?(:include)

        # NB: To handle on__<type>--<name>
        # A) relationship_name == :positions
        # B) key == on__employees.positions
        # This way A) ensures sideloads are resolved
        # And B) ensures nested filters, sorts etc still work
        relationship_name = sideload ? sideload.name : key
        hash[relationship_name] = Query.new sl_resource,
          @params,
          association_name: key,
          nested_include: sub_hash,
          parents: query_parents,
          action: :all
      else
        handle_missing_sideload(key)
      end
    end
  end
end

#sorts ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/graphiti/query.rb', line 185

def sorts
  @sorts ||= begin
    return @params[:sort] if @params[:sort].is_a?(Array)
    return [] if @params[:sort].nil?

    [].tap do |arr|
      sort_hashes do |key, value, type|
        if legacy_nested?(type)
          unless @resource.remote?
            @resource.get_attr!(key, :sortable, request: true)
          end
          arr << {key => value}
        elsif !type && top_level? && validate!(key, :sortable)
          arr << {key => value}
        elsif nested?("#{type}.#{key}")
          arr << {key => value}
        end
      end
    end
  end
end

#stats ⇒ Object 



243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'lib/graphiti/query.rb', line 243

def stats
  @stats ||= {}.tap do |hash|
    (@params[:stats] || {}).each_pair do |k, v|
      if legacy_nested?(k)
        raise NotImplementedError.new("Association statistics are not currently supported")
      elsif top_level?
        v = v.split(",") if v.is_a?(String)
        hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
      end
    end
  end
end

#top_level? ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
 
# File 'lib/graphiti/query.rb', line 38

def top_level?
  !association?
end

#zero_results? ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
85
86
 
# File 'lib/graphiti/query.rb', line 82

def zero_results?
  !@params[:page].nil? &&
    !@params[:page][:size].nil? &&
    @params[:page][:size].to_i == 0
end