Module: Graphoid::ActiveRecordDriver

Defined in:
lib/graphoid/drivers/active_record.rb

Class Method Summary collapse

Class Method Details

.belongs_to?(type) ⇒ Boolean

Returns:

  • (Boolean) 


18
19
20
 
# File 'lib/graphoid/drivers/active_record.rb', line 18

def belongs_to?(type)
  type == ActiveRecord::Reflection::BelongsToReflection
end

.class_of(relation) ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/graphoid/drivers/active_record.rb', line 56

def class_of(relation)
  {
    ActiveRecord::Reflection::HasAndBelongsToManyReflection => ManyToMany,
    ActiveRecord::Reflection::BelongsToReflection => BelongsTo,
    ActiveRecord::Reflection::ThroughReflection => ManyToMany,
    ActiveRecord::Reflection::HasManyReflection => HasMany,
    ActiveRecord::Reflection::HasOneReflection => HasOne
  }[relation.class] || Relation
end

.eager_load(_selection, model) ⇒ Object 



86
87
88
 
# File 'lib/graphoid/drivers/active_record.rb', line 86

def eager_load(_selection, model)
  model
end

.embedded_in?(_type) ⇒ Boolean

Returns:

  • (Boolean) 


34
35
36
 
# File 'lib/graphoid/drivers/active_record.rb', line 34

def embedded_in?(_type)
  false
end

.embeds_many?(_type) ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
 
# File 'lib/graphoid/drivers/active_record.rb', line 30

def embeds_many?(_type)
  false
end

.embeds_one?(_type) ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
 
# File 'lib/graphoid/drivers/active_record.rb', line 26

def embeds_one?(_type)
  false
end

.execute_and(scope, parsed) ⇒ Object 



90
91
92
 
# File 'lib/graphoid/drivers/active_record.rb', line 90

def execute_and(scope, parsed)
  scope.where(parsed)
end

.execute_or(scope, list) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/graphoid/drivers/active_record.rb', line 94

def execute_or(scope, list)
  list.map! do |object|
    Graphoid::Queries::Processor.execute(scope, object)
  end
  list.reduce(:or)
end

.fields_of(model) ⇒ Object 



70
71
72
 
# File 'lib/graphoid/drivers/active_record.rb', line 70

def fields_of(model)
  model.columns
end

.has_and_belongs_to_many?(type) ⇒ Boolean

Returns:

  • (Boolean) 


10
11
12
 
# File 'lib/graphoid/drivers/active_record.rb', line 10

def has_and_belongs_to_many?(type)
  type == ActiveRecord::Reflection::HasAndBelongsToManyReflection
end

.has_many?(type) ⇒ Boolean

Returns:

  • (Boolean) 


14
15
16
 
# File 'lib/graphoid/drivers/active_record.rb', line 14

def has_many?(type)
  type == ActiveRecord::Reflection::HasManyReflection
end

.has_one?(type) ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/graphoid/drivers/active_record.rb', line 22

def has_one?(type)
  type == ActiveRecord::Reflection::HasOneReflection
end

.inverse_name_of(relation) ⇒ Object 



66
67
68
 
# File 'lib/graphoid/drivers/active_record.rb', line 66

def inverse_name_of(relation)
  relation.inverse_of&.class_name&.underscore
end

.parse(attribute, value, operator) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/graphoid/drivers/active_record.rb', line 101

def parse(attribute, value, operator)
  field = attribute.name
  case operator
  when 'not'
    parsed = ["#{field} != ?", value]
    parsed = ["#{field} not like ?", value.to_s] if attribute.type == :string
    parsed = ["#{field} is not null"] if value.nil?
  when 'contains', 'regex'
    parsed = ["#{field} like ?", "%#{value}%"]
  when 'gt', 'gte', 'lt', 'lte', 'not', 'in', 'nin'
    operator = { gt: '>', gte: '>=', lt: '<', lte: '<=', in: 'in', nin: 'not in' }[operator.to_sym]
    parsed = ["#{field} #{operator} (?)", value]
  else
    parsed = ["#{field} = ?", value]
  end
  parsed
end

.relate_many(scope, relation, value, operator) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/graphoid/drivers/active_record.rb', line 130

def relate_many(scope, relation, value, operator)
  parsed = {}
  field_name = relation.inverse_name || scope.name.underscore
  target = Graphoid::Queries::Processor.execute(relation.klass, value).to_a

  if relation.many_to_many?
    field_name = field_name.to_s.singularize + '_ids'
    ids = target.map(&field_name.to_sym)
    ids.flatten!.uniq!
  else
    field_name = :"#{field_name}_id"
    ids = target.map(&field_name)
  end

  if operator == 'none'
    parsed = ['id not in (?)', ids] if ids.present?
  elsif operator == 'some'
    parsed = ['id in (?)', ids]
  elsif operator == 'every'

    # the following process is a SQL division
    # the amount of queries it executes is on per row
    # it is the same than doing an iteration process
    # that iteration process would work in mongoid too

    # TODO: check and fix this query for many to many relations

    plural_name = relation.name.pluralize
    conditions = value.map do |_key, _value|
      operation = Operation.new(relation.klass, _key, _value)
      parsed = parse(operation.operand, operation.value, operation.operator)
      val = parsed.last.is_a?(String) ? "'#{parsed.last}'" : parsed.last
      parsed = parsed.first.sub('?', val)
      " AND #{parsed}"
    end.join

    query = "
              SELECT count(id) as total, #{field_name}
              FROM #{plural_name} A
              GROUP BY #{field_name}
              HAVING total = (
                SELECT count(id)
                FROM #{plural_name} B
                WHERE B.#{field_name} = A.#{field_name}
                #{conditions}
              )
            "
    result = ActiveRecord::Base.connection.execute(query)
    ids = result.map { |row| row[field_name.to_s] }

    parsed = ['id in (?)', ids]
  end

  parsed
end

.relate_through(scope, relation, value) ⇒ Object

TODO: fix this as it is unused



120
121
122
123
124
125
126
127
128
 
# File 'lib/graphoid/drivers/active_record.rb', line 120

def relate_through(scope, relation, value)
  # if relation.has_one_through?
  #   ids = Graphoid::Queries::Processor.execute(relation.klass, value).to_a.map(&:id)
  #   through = relation.source.options[:through].to_s.camelize.constantize
  #   ids = through.where(id: ids)
  #   ids = Graphoid::Queries::Processor.execute(relation.klass, value).to_a.map(&:id)
  #   parsed = *["#{field.underscore}_id in (?)", ids]
  # end
end

.relation_type(relation) ⇒ Object 



82
83
84
 
# File 'lib/graphoid/drivers/active_record.rb', line 82

def relation_type(relation)
  relation.class
end

.relations_of(model) ⇒ Object 



74
75
76
 
# File 'lib/graphoid/drivers/active_record.rb', line 74

def relations_of(model)
  model.reflections
end

.skip(result, skip) ⇒ Object 



78
79
80
 
# File 'lib/graphoid/drivers/active_record.rb', line 78

def skip(result, skip)
  result.offset(skip)
end

.through?(type) ⇒ Boolean

Returns:

  • (Boolean) 


6
7
8
 
# File 'lib/graphoid/drivers/active_record.rb', line 6

def through?(type)
  type == ActiveRecord::Reflection::ThroughReflection
end

.types_map ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/graphoid/drivers/active_record.rb', line 38

def types_map
  {
    binary: GraphQL::Types::Boolean,
    boolean: GraphQL::Types::Boolean,
    float: GraphQL::Types::Float,
    integer: GraphQL::Types::Int,
    string: GraphQL::Types::String,

    datetime: Graphoid::Scalars::DateTime,
    date: Graphoid::Scalars::DateTime,
    time: Graphoid::Scalars::DateTime,
    timestamp: Graphoid::Scalars::DateTime,
    text: Graphoid::Scalars::Text,
    bigint: Graphoid::Scalars::BigInt,
    decimal: Graphoid::Scalars::Decimal
  }
end