graphql-rails-api 0.1.6 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b644695c5f738ce04ffbffc6751c67f43b5e3e5abe171e39ea98f5a526b50aaf
-  data.tar.gz: b59bdb2628478c676369f59a594181e1cc3a4d98d8ccdbb9ac9e4a52ebdb2f14
+  metadata.gz: d57fa3b16ccdcf04df7d00d4fe67475c52023335a4655a2efa0261023a4cf78c
+  data.tar.gz: 13a7ae285e5f4594322f9960d400f9657c06326e57bfde6322633764b573e3b0
 SHA512:
-  metadata.gz: 7d9293440b05eb1bad81b54d1f980a1247947a19a1282a0713d34d64b440fcfb1f5fdf472ea11530abf2c0b56f94e826acd9cc5b3339bfc2543959a042c8628d
-  data.tar.gz: a8845eb6c68a3b49fe778144bbdcf2986a7ea5f2197b3fcb90217941dc683726508a51bc6898bfee325c0a532241cccf469d4986d8f646baa9976b2b69b0b353
+  metadata.gz: 525754f37def8d961cceb0ae151d44e00369b8f2099f5ad6648f5ab276759b9de36ad1e1ed0e50f1ec48130f5c0088be7193d5bbd8d881c699fa3e1f84f16d95
+  data.tar.gz: 9d5d568d8e8e22a50ef9b4760629cb1efbcf6a536c397510bc4d170bba5d4e178962a3ef933cba12ab8c4a45078319c45e33bc9824a9d16ddf1707bc2a6fdf66

data/lib/graphql/hydrate_query.rb

@@ -10,115 +10,53 @@ module Graphql
 
     def run
       hash = parse_fields(@fields)
-      selectable_values = transform_to_selectable_values(hash)
-      joins = remove_keys_with_nil_values(Marshal.load(Marshal.dump(hash)))
-      join_model = @model.includes(joins)
-      join_model = join_model.where(id: @id) if @id.present?
-      res2d = pluck_to_hash_with_ids(join_model, pluckable_attributes(selectable_values))
-      joins_with_root = { model_name.to_sym => remove_keys_with_nil_values(Marshal.load(Marshal.dump(hash))) }
-      ir = nest(joins_with_root, res2d).first
-      @visibility_hash = Graphql::VisibilityHash.new(joins_with_root, @user).run
-      @id ? ir_to_output(ir).first : ir_to_output(ir)
+      array = hash_to_array_of_hashes(hash, @model)
+      @model = @model.where(id: @id) if @id
+      plucked = @model.deep_pluck(*array)
+      result = plucked_attr_to_structs(plucked)
+      @id ? result.first : result
     end
 
-    def pluck_to_hash_with_ids(model, keys)
-      keys.each do |k|
-        resource = k.split('.').first
-        keys << "#{resource.pluralize}.id" unless keys.include?("#{resource}.id")
-      end
-      keys = keys.compact.uniq
-      model.pluck(*keys).map do |pa|
-        Hash[keys.zip([pa].flatten)]
-      end
+    def plucked_attr_to_structs(arr)
+      arr.map { |e| hash_to_struct(e) }
     end
 
-    def pluckable_attributes(keys)
-      db_attributes = keys.uniq.map { |k| k.gsub(/\..*$/, '') }.uniq.map do |resource|
-        next unless Object.const_defined?(resource.singularize.camelize)
-        resource.singularize.camelize.constantize.new.attributes.keys.map do |attribute|
-          "#{resource}.#{attribute}"
-        end
-      end.flatten.compact
-      keys.select { |e| db_attributes.flatten.include?(e) }.map do |e|
-        split = e.split('.')
-        "#{split.first.pluralize}.#{split.last}"
+    def hash_to_struct(hash)
+      hash.each_with_object(OpenStruct.new) do |(k, v), struct|
+        next struct[k.to_sym] = plucked_attr_to_structs(v) if v.is_a?(Array)
+        next struct[k.to_sym] = hash_to_struct(v) if v.is_a?(Hash)
+        struct[k.to_sym] = v
       end
     end
 
-    def ir_to_output(inter_result)
-      model_name = inter_result&.first&.first&.first&.first&.to_s
-      return [] if model_name.blank?
-      res = if singular?(model_name)
-              ir_node_to_output(inter_result.first)
-            else
-              inter_result.map { |ir_node| ir_node_to_output(ir_node) if ir_node }
-            end
-      res.compact! if res.is_a?(Array)
-      res
-    end
-
-    def ir_node_to_output(ir_node)
-      model_name = ir_node.keys.reject { |key| key == :results }.first.first.to_s
-      t = ir_node[:results].first.each_with_object({}) do |(attribute, v), h|
-        h[attribute.gsub(model_name.pluralize + '.', '')] = v
+    def hash_to_array_of_hashes(hash, parent_class)
+      return if parent_class.nil?
+      hash.each_with_object([]) do |(k, v), arr|
+        next arr << k if v.blank? && parent_class.new.attributes.key?(k)
+        klass = evaluate_model(parent_class, k)
+        arr << { k.to_sym => hash_to_array_of_hashes(v, klass) } if klass.present? && v.present?
       end
-      relations = ir_node.values&.first&.map { |e| e&.first&.first&.first&.first }
-      relations.zip(ir_node[ir_node.keys.reject { |key| key == :results }&.first]).to_h.map do |key, value|
-        res = ir_to_output(value)
-        t[key] = res if value
-        t[key].compact! if t[key].is_a?(Array)
-      end
-      return unless @visibility_hash[model_name.singularize.to_sym]&.include?(t['id'])
-      Struct.new(*t.keys.map(&:to_sym)).new(*t.values) if !t.keys.blank? && !t.values.compact.blank?
-    end
-
-    def singular?(string)
-      string.singularize == string
     end
 
-    def nest(joins, res)
-      joins.map do |relation_name, other_joins|
-        res.group_by do |row|
-          [relation_name, row["#{relation_name.to_s.pluralize}.id"]]
-        end.map do |k, ungrouped|
-          Hash[k, nest(other_joins, ungrouped)].merge(results: extract_values_of_level(k[0], ungrouped).uniq)
-        end
-      end
-    end
-
-    def extract_values_of_level(level, ungrouped)
-      ungrouped.map do |row|
-        row.select { |k, _| k =~ /#{level.to_s.pluralize}.*/ }
-      end
-    end
-
-    def transform_to_selectable_values(hash, res = nil)
-      @values ||= []
-      hash.each do |k, v|
-        if v.nil?
-          @values << "#{res || model_name}.#{k}" unless activerecord_model?(k)
-        else
-          next @values << "#{res || model_name}.#{k}" unless activerecord_model?(k)
-          transform_to_selectable_values(v, k)
-        end
+    def activerecord_model?(name)
+      class_name = name.to_s.singularize.camelize
+      begin
+        class_name.constantize.ancestors.include?(ApplicationRecord)
+      rescue NameError
+        false
       end
-      @values
     end
 
-    def remove_keys_with_nil_values(hash)
-      hash.symbolize_keys!
-      hash.each_key do |k|
-        if hash[k].nil? || !activerecord_model?(k)
-          hash.delete(k)
-        else
-          remove_keys_with_nil_values(hash[k])
-        end
-      end
+    def evaluate_model(parent, child)
+      child_class_name = child.to_s.singularize.camelize
+      parent_class_name = parent.to_s.singularize.camelize
+      return child_class_name.constantize if activerecord_model?(child_class_name)
+      return unless activerecord_model?(parent_class_name)
+      parent_class_name.constantize.reflections[child.to_s.underscore]&.klass
     end
 
     def parse_fields(fields)
       fields.each_with_object({}) do |(k, v), h|
-        next if k == '__typename'
         h[k] = v.scoped_children == {} ? nil : parse_fields(v.scoped_children.values.first)
       end
     end
@@ -127,14 +65,5 @@ module Graphql
       @model.class.to_s.split('::').first.underscore.pluralize
     end
 
-    def activerecord_model?(name)
-      class_name = name.to_s.singularize.camelize
-      begin
-        class_name.constantize.ancestors.include?(ApplicationRecord)
-      rescue NameError
-        false
-      end
-    end
-
   end
 end

data/lib/graphql/rails/api/version.rb

@@ -1,7 +1,7 @@
 module Graphql
   module Rails
     module Api
-      VERSION = '0.1.6'.freeze
+      VERSION = '0.2'.freeze
     end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-api
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: '0.2'
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-11 00:00:00.000000000 Z
+date: 2018-06-20 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: deep_pluck
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement