graphql_includable 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d25c20a822decf0d9e5ee56419b85a5794c9ae5f
-  data.tar.gz: a0a6803c0cde3cb012b57b2b6bd51bdad46d9971
+  metadata.gz: a1d376f28ad0b33963bc79eb820a3301964e621d
+  data.tar.gz: a6685ec899a6a3615d5fb1fafd366cb9e611c438
 SHA512:
-  metadata.gz: 3e70cf65b71d6299ed2b118b600fdffc7b330c43c3a357e378c72bcfdc88623b0eed2fb7651a1531c2f9ac2b256919652a98b75487a9d05261fb24b47152dca1
-  data.tar.gz: f87b181a30dbb8f806380bead5fdcb163ed51762ccaaef7a0d4cb6f36b2f5cf5a9f1376bc21661baa1ea4ef4e1d9a7ec5578aeb4321920961ba85f22ac50916a
+  metadata.gz: 57475ac341e200bbecca1f8bcfe554074e9dd9e5db39b325a3e252c77f9292e7a0583633119ab95b50c3277c554c7c83cec90ed8ff33ae2e51859f9efe50fc56
+  data.tar.gz: 84b171467d90d4e531c3f38e26f4103763d9aa05e330bbe9e89a73f4d76eb05fe1cd43bee70896a75def7dc1292f66fd5f8674a207aae6faa8011d325cdd4bda

data/lib/graphql_includable/concern.rb

@@ -0,0 +1,176 @@
+require 'active_support/concern'
+
+module GraphQLIncludable
+  module Concern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def includes_from_graphql(ctx)
+        node = GraphQLIncludable::Concern.first_child_by_return_type(ctx.irep_node, model_name.to_s)
+        generated_includes = Concern.includes_from_graphql_node(node)
+        includes(generated_includes)
+      end
+
+      def delegate_cache
+        @delegate_cache ||= {}
+      end
+
+      # hook ActiveSupport's delegate method to track models and where their delegated methods go
+      def delegate(*methods, args)
+        methods.each do |method|
+          delegate_cache[method] = args[:to]
+        end
+        super(*methods, args) if defined?(super)
+      end
+    end
+
+    def self.first_child_by_return_type(node, model_name)
+      matching_node = nil
+      return_type = node.return_type.unwrap
+      if return_type.to_s == model_name
+        matching_node = node
+      elsif node.respond_to?(:scoped_children)
+        node.scoped_children[return_type].each_value do |child_node|
+          matching_node = first_child_by_return_type(child_node, model_name)
+          break if matching_node
+        end
+      end
+      matching_node
+    end
+
+    def self.children_through_connection(node, return_model)
+      includes = {}
+      # if node_is_relay_connection?(node)
+      #   all_connection_children = node.scoped_children[node.return_type.unwrap]
+      #   connection_children = all_connection_children.except('edges')
+      #   edge_node = all_connection_children['edges']
+      #   all_edge_children = edge_node.scoped_children[edge_node.return_type.unwrap]
+      #   edge_children = all_edge_children.except('node')
+      #   target_node = all_edge_children['node']
+      #   children = target_node.scoped_children[target_node.return_type.unwrap]
+
+      #   target_association = return_model.reflect_on_association(node_return_class(target_node).name.underscore)
+      #   includes[target_association.name] = includes_from_graphql_node(target_node) if target_association
+      # else
+        children = node.scoped_children[node.return_type.unwrap]
+      # end
+
+      [children, includes]
+    end
+
+    def self.includes_from_graphql_node(node)
+      return_model = node_return_class(node)
+      return [] unless return_model
+
+      includes = []
+      children, nested_includes = children_through_connection(node, return_model)
+      children.each_value do |child_node|
+        child_includes = includes_from_graphql_child(child_node, return_model)
+
+        if child_includes.is_a?(Hash)
+          nested_includes.merge!(child_includes)
+        else
+          includes += child_includes.is_a?(Array) ? child_includes : [child_includes]
+        end
+      end
+
+      includes << nested_includes unless nested_includes.blank?
+      includes.uniq
+    end
+
+    def self.includes_from_graphql_child(child_node, return_model)
+      specified_includes = child_node.definitions[0].metadata[:includes]
+      attribute_name = node_predicted_association_name(child_node)
+      includes_chain = delegated_includes_chain(return_model, attribute_name)
+      association = get_model_association(return_model, attribute_name, includes_chain)
+
+      if association
+        child_includes = includes_from_graphql_node(child_node)
+        join_name = (specified_includes || attribute_name)
+
+        # if node_is_relay_connection?(child_node)
+        #   join_name = association.options[:through]
+        #   edge_includes_chain = [association.name]
+        #   edge_includes_chain << child_includes.pop[association.name.to_s.singularize.to_sym] if child_includes.last&.is_a?(Hash)
+        #   edge_includes = array_to_nested_hash(edge_includes_chain)
+        # end
+
+        includes_chain << join_name
+        includes_chain << child_includes unless child_includes.blank?
+        # byebug if node_is_relay_connection?(child_node)
+        edge_includes=nil
+        [edge_includes, array_to_nested_hash(includes_chain)].reject(&:blank?)
+      else
+        includes = []
+        includes << array_to_nested_hash(includes_chain) unless includes_chain.blank?
+        includes << specified_includes if specified_includes
+        includes
+      end
+    end
+
+    def self.node_return_class(node)
+      # rubocop:disable Lint/HandleExceptions, Style/RedundantBegin
+      begin
+        Object.const_get(node.return_type.unwrap.name.gsub(/(^SquareFoot|Edge$|Connection$)/, ''))
+      rescue NameError
+      end
+      # rubocop:enable Lint/HandleExceptions, Style/RedundantBegin
+    end
+
+    def self.node_is_relay_connection?(node)
+      node.return_type.unwrap.name =~ /Connection$/
+    end
+
+    def self.node_returns_active_record?(node)
+      klass = node_return_class(node)
+      klass && klass < ActiveRecord::Base
+    end
+
+    def self.node_predicted_association_name(node)
+      definition = node.definitions[0]
+      specified_includes = definition.metadata[:includes]
+      if specified_includes.is_a?(Symbol)
+        specified_includes
+      else
+        (definition.property || definition.name).to_sym
+      end
+    end
+
+    def self.get_model_association(model, association_name, includes_chain = nil)
+      delegated_model = model_name_to_class(includes_chain.last) unless includes_chain.blank?
+      (delegated_model || model).reflect_on_association(association_name)
+    end
+
+    # get a 1d array of the chain of delegated model names,
+    # so if model A delegates method B to model C, which delegates method B to model D,
+    # delegated_includes_chain(A, :B) => [:C, :D]
+    def self.delegated_includes_chain(base_model, method_name)
+      chain = []
+      method = method_name.to_sym
+      model_name = base_model.instance_variable_get('@delegate_cache').try(:[], method)
+      while model_name
+        chain << model_name
+        model = model_name_to_class(model_name)
+        model_name = model.instance_variable_get('@delegate_cache').try(:[], method)
+      end
+      chain
+    end
+
+    # convert a 1d array into a nested hash
+    # e.g. [:foo, :bar, :baz] => { :foo => { :bar => :baz }}
+    def self.array_to_nested_hash(arr)
+      arr.reverse.inject { |acc, item| { item => acc } }
+    end
+
+    # convert a model name into a class variable,
+    # e.g. :search_parameters -> SearchParameters
+    def self.model_name_to_class(model_name)
+      begin
+        model = model_name.to_s.camelize.constantize
+      rescue NameError
+        model = model_name.to_s.singularize.camelize.constantize
+      end
+      model
+    end
+  end
+end

data/lib/graphql_includable/edge.rb

@@ -0,0 +1,55 @@
+module GraphQLIncludable
+  class Edge < GraphQL::Relay::Edge
+    def edge
+      join_chain = joins_along_edge
+      edge_class_name = join_chain.shift
+      edge_class = str_to_class(edge_class_name)
+
+      root_node = { class_to_str(parent.class).to_s.singularize => parent }
+      terminal_node = { class_to_str(node.class).singularize => node }
+      join_chain.reverse.each do |rel_name|
+        terminal_node = { rel_name.to_s.pluralize => terminal_node }
+      end
+      search_hash = root_node.merge(terminal_node)
+
+      @edge ||= edge_class.includes(*join_chain.map { |s| s.to_s.singularize }).find_by(search_hash)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if edge.respond_to?(method_name)
+        edge.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing(method_name, include_private = false)
+      edge.respond_to?(method_name) || super
+    end
+
+    private
+
+    def str_to_class(str)
+      str.to_s.singularize.camelize.constantize
+    rescue
+    end
+
+    def class_to_str(klass)
+      klass.name.pluralize.downcase
+    end
+
+    def joins_along_edge
+      join_chain = []
+      starting_class = parent.class
+      node_relationship_name = class_to_str(node.class)
+      while starting_class
+        reflection = starting_class.reflect_on_association(node_relationship_name)
+        association_name = reflection&.options&.try(:[], :through)
+        join_chain << association_name if association_name
+        starting_class = str_to_class(association_name)
+        node_relationship_name = node_relationship_name.singularize
+      end
+      join_chain
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Dan Rouse
@@ -20,6 +20,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/graphql_includable.rb
+- lib/graphql_includable/concern.rb
+- lib/graphql_includable/edge.rb
 homepage: https://github.com/thesquarefoot/graphql_includable
 licenses:
 - MIT