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, 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
 
# File 'lib/graphiti/query.rb', line 7

def initialize(resource, params, association_name = nil, nested_include = nil, parents = [], action = nil)
  @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) 


19
20
21
 
# File 'lib/graphiti/query.rb', line 19

def association?
  !!@association_name
end

#cache_key ⇒ Object 



237
238
239
 
# File 'lib/graphiti/query.rb', line 237

def cache_key
  "args-#{query_cache_key}"
end

#debug_requested? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#extra_fields ⇒ Object 



136
137
138
 
# File 'lib/graphiti/query.rb', line 136

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

#fields ⇒ Object 



126
127
128
129
130
131
132
133
134
 
# File 'lib/graphiti/query.rb', line 126

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 



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/graphiti/query.rb', line 140

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 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/graphiti/query.rb', line 50

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 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/graphiti/query.rb', line 204

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.context_namespace] if allowlist
    end

    allowlist ? Util::IncludeParams.scrub(requested, allowlist) : requested
  end

  @include_hash
end

#links? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
30
31
32
33
34
 
# File 'lib/graphiti/query.rb', line 27

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) 


233
234
235
 
# File 'lib/graphiti/query.rb', line 233

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

#pagination ⇒ Object 



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

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) 


36
37
38
39
40
41
42
43
44
 
# File 'lib/graphiti/query.rb', line 36

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 



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

def parents
  @parents ||= []
end

#resource_for_sideload(sideload) ⇒ Object 



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

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

#sideload_hash ⇒ Object 



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

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

#sideloads ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/graphiti/query.rb', line 94

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,
          key,
          sub_hash,
          query_parents, :all
      else
        handle_missing_sideload(key)
      end
    end
  end
end

#sorts ⇒ Object 



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

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 



220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/graphiti/query.rb', line 220

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) 


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

def top_level?
  !association?
end

#zero_results? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
70
71
 
# File 'lib/graphiti/query.rb', line 67

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