graphql_includable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13f8e1de4b38eac1e571c18ecc7ca78dbb16327f
+  data.tar.gz: 8b8318def58be25d950473392715d16f73b0d829
+SHA512:
+  metadata.gz: c105a43187fb8d9db518cce6ca824ef96f17f279303c9a5c459e8708370ded44ee22c593d6b5d183dfb108fbafc442ef0bedf0d343a2eb1eff5f5e67c1dcaf9a
+  data.tar.gz: 2745bfa726da7f5ebc806afcc6c438d532a176f19ca9631894e3a62e9132ec814f4447012532359d2675acc370deb9265903aa6a020f7a16bc191d1a6a2d9318

data/lib/graphql_includable.rb

@@ -0,0 +1,131 @@
+require "graphql"
+require "active_support/concern"
+
+GraphQL::Field.accepts_definitions includes: GraphQL::Define.assign_metadata_key(:includes)
+
+module GraphQLIncludable
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def includes_from_graphql(query_context)
+      generated_includes = GraphQLIncludable.generate_includes_from_graphql(query_context, self.model_name.to_s)
+      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
+
+  private
+
+  def self.generate_includes_from_graphql(query_context, model_name)
+    matching_node = GraphQLIncludable.find_child_node_matching_model_name(query_context.irep_node, model_name)
+    GraphQLIncludable.includes_from_irep_node(matching_node)
+  end
+
+  def self.find_child_node_matching_model_name(node, model_name)
+    matching_node = nil
+    return_type = unwrapped_type(node)
+    if return_type.to_s == model_name
+      matching_node = node
+    elsif node.respond_to? :scoped_children
+      node.scoped_children[return_type].each do |child_name, child_node|
+        matching_node = find_child_node_matching_model_name(child_node, model_name)
+        break if matching_node
+      end
+    end
+    matching_node
+  end
+
+  def self.includes_from_irep_node(node)
+    includes = []
+    nested_includes = {}
+
+    return_type = unwrapped_type(node)
+    return_model = node_return_class(node)
+    return [] unless node && return_type && return_model
+
+    node.scoped_children[return_type].each do |child_name, child_node|
+      child_association_name, explicit_includes = suggested_association_name(child_name, child_node)
+      association, delegated_model_name = find_association(return_model, child_association_name)
+      if association
+        child_includes = includes_from_irep_node(child_node)
+
+        if node_has_active_record_children(child_node) && child_includes.size > 0
+          nested_includes[delegated_model_name || child_association_name] = wrap_delegate(child_includes, delegated_model_name, child_association_name)
+        else
+          includes << wrap_delegate(child_association_name, delegated_model_name)
+        end
+      elsif explicit_includes
+        includes << explicit_includes
+      end
+    end
+
+    includes << nested_includes if nested_includes.size > 0
+    includes
+  end
+
+  def self.node_has_active_record_children(node)
+    node.scoped_children[unwrapped_type(node)].each do |child_return_name, child_node|
+      node_returns_active_record?(child_node)
+    end
+  end
+
+  def self.node_return_class(node)
+    begin
+      Object.const_get(unwrapped_type(node).name)
+    rescue NameError
+    end
+  end
+
+  def self.node_returns_active_record?(node)
+    klass = node_return_class(node)
+    klass && klass < ActiveRecord::Base
+  end
+
+  # return raw contents, or contents wrapped in a hash (for delegated associations)
+  def self.wrap_delegate(contents, delegate, delegate_key = delegate)
+    return contents unless delegate
+
+    obj = {}
+    obj[delegate_key] = contents
+    obj
+  end
+
+  # unwrap GraphQL ListType and NonNullType wrappers
+  def self.unwrapped_type(node)
+    type = node.return_type
+    type = type.of_type while type.respond_to? :of_type
+    type
+  end
+
+  # find a valid association on return_model, following method delegation
+  def self.find_association(return_model, child_name)
+    delegated_model = return_model.instance_variable_get('@delegate_cache').try(:[], child_name.to_sym)
+    association_model = delegated_model ? return_model.reflect_on_association(delegated_model).klass : return_model
+    association = association_model.reflect_on_association(child_name)
+
+    [association, delegated_model]
+  end
+
+  # find the association to look for based on a field definition
+  # precedence is `includes` key, then `property` key, then the field name
+  def self.suggested_association_name(name, node)
+    includes_metadata = node.definitions[0].metadata[:includes]
+
+    assoc_name = node.definitions[0].property || name
+    assoc_name = includes_metadata if includes_metadata && includes_metadata.is_a?(Symbol)
+
+    [assoc_name.to_sym, includes_metadata]
+  end
+
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: graphql_includable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dan Rouse
+- Josh Vickery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-28 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- dan.rouse@squarefoot.com
+- jvickery@squarefoot.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/graphql_includable.rb
+homepage: https://github.com/thesquarefoot/graphql_includable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: An ActiveSupport::Concern for GraphQL Ruby to eager-load query data
+test_files: []