graphiti 1.0.beta.5 → 1.0.beta.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fc7ed80afd6a4d3805e1243f5dcf1ab6c39cec1
-  data.tar.gz: 5f9d051ad124fc3e452cbf51bb6f31e70ea9b36f
+  metadata.gz: ebbb1dbc7d5e33d3fe8411ea7f184cb1c1a42b72
+  data.tar.gz: 5d94a4b97e8aa526abcc342adfe12ae124df549c
 SHA512:
-  metadata.gz: 523c8d39c68fcdaca2a52e49fb34161e7dcb08b94a524fa2eca22a3a85a679eb1312e2f2603e14ee6534a2a1ab4a856cdce6c9a50a8aacd7a7262b5e843ec25e
-  data.tar.gz: ee10e629146235de49f01d8c86e7700a2afce5e64baf6fb85ed07b05d01d5e103c061072acba09963c66acf648f9773e21019c4c62ee485d2396834db40f424e
+  metadata.gz: 60cd65ff706feace9b10d691b13f55cf716c0fdef0563b75ce9ad8a34579d553824a3417eba67bfd6ac84ff02e70356537a5f63001e71bf1a54bcf16cba6d216
+  data.tar.gz: 15055313e91f05705ef372721e720c34556c7a4b82e11e122b167d16fca063feac398513a5b89141e3a8c8618c8f9e056037d5101a49de29cbb5355a13ae7bf5

data/graphiti.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   # Pinning this version until backwards-incompatibility is addressed
   spec.add_dependency 'jsonapi-serializable', '~> 0.3.0'
   spec.add_dependency 'dry-types', '~> 0.13'
-  spec.add_dependency 'graphiti_errors', '~> 1.0.alpha.2'
+  spec.add_dependency 'graphiti_errors', '~> 1.0.beta.1'
   spec.add_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_dependency 'activesupport', ['>= 4.1', '< 6']
 
@@ -32,5 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "database_cleaner"
   spec.add_development_dependency "activemodel", ['>= 4.1', '< 6']
-  spec.add_development_dependency "graphiti_spec_helpers", '>= 1.0.alpha.1'
+  spec.add_development_dependency "graphiti_spec_helpers", '>= 1.0.beta.3'
 end

data/lib/graphiti.rb

@@ -68,6 +68,7 @@ require "graphiti/extensions/extra_attribute"
 require "graphiti/extensions/boolean_attribute"
 require "graphiti/extensions/temp_id"
 require "graphiti/serializer"
+require "graphiti/debugger"
 
 if defined?(ActiveRecord)
   require 'graphiti/adapters/active_record'
@@ -127,6 +128,34 @@ module Graphiti
     @resources ||= []
   end
 
+  def self.broadcast(name, payload)
+    name = "graphiti.#{name}"
+    ActiveSupport::Notifications.instrument(name, payload) do
+      yield payload if block_given?
+    end
+  end
+
+  def self.logger
+    @logger ||= stdout_logger
+  end
+
+  def self.stdout_logger
+    logger = Logger.new($stdout)
+    logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+    logger
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.log(msg, color = :white, bold = false)
+    colored = ActiveSupport::LogSubscriber.new.send(:color, msg, color, bold)
+    logger.debug(colored)
+  end
+
   # When we add a sideload, we need to do configuration, such as
   # adding the relationship to the Resource's serializer.
   # However, the sideload's Resource class may not be loaded yet.

data/lib/graphiti/base.rb

@@ -57,7 +57,11 @@ module Graphiti
     def proxy(base = nil, opts = {})
       base ||= jsonapi_resource.base_scope
       scope_opts = opts.slice :sideload_parent_length,
-        :default_paginate, :after_resolve
+        :default_paginate,
+        :after_resolve,
+        :sideload,
+        :parent,
+        :params
       scope = jsonapi_scope(base, scope_opts)
       ResourceProxy.new jsonapi_resource,
         scope,

data/lib/graphiti/configuration.rb

@@ -13,6 +13,8 @@ module Graphiti
     attr_accessor :schema_path
     attr_accessor :links_on_demand
     attr_accessor :typecast_reads
+    attr_accessor :debug
+    attr_accessor :debug_models
 
     # Set defaults
     # @api private
@@ -22,14 +24,28 @@ module Graphiti
       @respond_to = [:json, :jsonapi, :xml]
       @links_on_demand = false
       @typecast_reads = true
+      self.debug = ENV.fetch('GRAPHITI_DEBUG', true)
+      self.debug_models = ENV.fetch('GRAPHITI_DEBUG_MODELS', false)
 
       if defined?(::Rails)
         @schema_path = "#{::Rails.root}/public/schema.json"
+        self.debug = ::Rails.logger.level.zero?
+        Graphiti.logger = ::Rails.logger
       end
     end
 
     def schema_path
       @schema_path ||= raise('No schema_path defined! Set Graphiti.config.schema_path to save your schema.')
     end
+
+    def debug=(val)
+      @debug = val
+      Debugger.enabled = val
+    end
+
+    def debug_models=(val)
+      @debug_models = val
+      Debugger.debug_models = val
+    end
   end
 end

data/lib/graphiti/debugger.rb

@@ -0,0 +1,194 @@
+# This could definitely use some refactoring love, but I have no time ATM
+# The code is pretty self-contained; we're just listening to notifications
+# and taking action.
+module Graphiti
+  class Debugger
+    class << self
+      attr_accessor :enabled, :chunks, :debug_models, :preserve, :pry
+    end
+    self.chunks = []
+
+    class << self
+      def on_data(name, start, stop, id, payload)
+        took = ((stop-start)*1000.0).round(2)
+        params = scrub_params(payload[:params])
+
+        if payload[:exception]
+          on_data_exception(payload, params)
+        else
+          if payload[:sideload]
+            on_sideload_data(payload, params, took)
+          else
+            on_primary_data(payload, params, took)
+          end
+        end
+      end
+
+      def on_data_exception(payload, params)
+        unless payload[:exception_object].instance_variable_get(:@__graphiti_debug)
+          add_chunk do |logs, json|
+            logs << ["\n=== Graphiti Debug ERROR", :red, true]
+            if sideload = payload[:sideload]
+              logs << ["#{sideload.parent_resource.class}: Sideload \"#{sideload.name}\"", :red, true]
+              json[:parent_resource] = sideload.parent_resource.class.name
+              json[:sideload] = sideload.name
+            end
+            if params
+              query = "#{payload[:resource].class.name}.all(#{JSON.pretty_generate(params)}).data"
+              logs << [query, :cyan, true]
+              logs << ["The error occurred when running the above query. Copy/paste it into a rake task or Rails console session to reproduce. Keep in mind you may have to set context.", :yellow, true]
+              json[:query] = query
+            else
+              query = "This sideload is done manually via .scope - no debug information available."
+              logs << [query, :cyan, true]
+              json[:query] = query
+            end
+            logs << "\n\n"
+            payload[:exception_object].instance_variable_set(:@__graphiti_debug, json)
+          end
+        end
+      end
+
+      def results(raw_results)
+        raw_results.map { |r| "[#{r.class.name}, #{r.id.inspect}]" }.join(', ')
+      end
+
+      def on_sideload_data(payload, params, took)
+        sideload = payload[:sideload]
+        results = results(payload[:results])
+        add_chunk(payload[:resource], payload[:parent]) do |logs, json|
+          #logs << [" \\_ #{sideload.parent_resource_class} > \"#{sideload.name}\":", :yellow, true]
+          logs << [" \\_ #{sideload.name}", :yellow, true]
+          json[:name] = sideload.name
+          query = "#{payload[:resource].class.name}.all(#{params.inspect})"
+          unless params
+            query = "#{payload[:resource].class.name}: Manual sideload via .scope"
+          end
+          logs << ["    #{query}", :cyan, true]
+          json[:query] = query
+          logs << ["    Returned Models: #{results}"] if debug_models
+          logs << ["    Took: #{took}ms", :magenta, true]
+          json[:took] = took
+        end
+      end
+
+      def on_primary_data(payload, params, took)
+        add_chunk(payload[:resource], payload[:parent]) do |logs, json|
+          logs << [""]
+          logs << ["=== Graphiti Debug", :green, true]
+          title = "Top Level Data Retrieval (+ sideloads):"
+          logs << [title, :green, true]
+          json[:title] = title
+          query = "#{payload[:resource].class.name}.all(#{params.inspect})"
+          logs << [query, :cyan, true]
+          json[:query] = query
+          logs << ["Returned Models: #{results}"] if debug_models
+          logs << ["Took: #{took}ms", :magenta, true]
+          json[:took] = took
+        end
+      end
+
+      def on_render(name, start, stop, id, payload)
+        add_chunk do |logs|
+          took = ((stop-start)*1000.0).round(2)
+          logs << [""]
+          logs << ["=== Graphiti Debug", :green, true]
+          logs << ["Rendering:", :green, true]
+          logs << ["Took: #{took}ms", :magenta, true]
+        end
+      end
+
+      def debug
+        if enabled
+          begin
+            self.chunks = []
+            yield
+          ensure
+            flush
+            self.chunks = [] unless self.preserve
+          end
+        else
+          yield
+        end
+      end
+
+      def to_a
+        debugs = []
+        graph_statements.each do |chunk|
+          debugs << chunk_to_hash(chunk)
+        end
+        debugs
+      end
+
+      def flush
+        Graphiti.broadcast('debug.flush', {}) do |payload|
+          payload[:chunks] = chunks
+          graph_statements.each do |chunk|
+            flush_chunk(chunk)
+          end
+        end
+      end
+
+      private
+
+      def scrub_params(params)
+        params ||= {}
+        params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+        params.reject! { |k,v| [:controller, :action, :format, :debug].include?(k.to_sym) }
+        params.reject! { |k,v| k.to_sym == :include }
+        params.deep_symbolize_keys
+      end
+
+      def add_chunk(resource = nil, parent = nil)
+        logs, json = [], {}
+        yield(logs, json)
+        self.chunks << {
+          resource: resource,
+          parent: parent,
+          logs: logs,
+          json: json,
+          children: []
+        }
+      end
+
+      def graph_statements
+        @chunks.each do |chunk|
+          if parent = chunk[:parent]
+            relevant = chunks.find { |c| c[:resource] == parent }
+            relevant[:children].unshift(chunk)
+          end
+        end
+        @chunks.reject! { |c| !!c[:parent] }
+        @chunks
+      end
+
+      def chunk_to_hash(chunk)
+        hash = {}
+        hash.merge!(chunk[:json])
+        sideloads = []
+        chunk[:children].each do |child_chunk|
+          sideloads << chunk_to_hash(child_chunk)
+        end
+        hash[:sideloads] = sideloads
+        hash
+      end
+
+      def flush_chunk(chunk, depth = 0)
+        chunk[:logs].each do |args|
+          indent = '   ' * depth
+          args[0] = "#{indent}#{args[0]}"
+          Graphiti.log(*args)
+        end
+
+        chunk[:children].each do |child_chunk|
+          flush_chunk(child_chunk, depth + 1)
+        end
+      end
+    end
+
+    ActiveSupport::Notifications.subscribe \
+      'graphiti.data', method(:on_data)
+    ActiveSupport::Notifications.subscribe \
+      'graphiti.render', method(:on_render)
+  end
+end

data/lib/graphiti/query.rb

@@ -22,6 +22,7 @@ module Graphiti
     end
 
     def links?
+      return false if [:json, :xml, 'json', 'xml'].include?(params[:format])
       if Graphiti.config.links_on_demand
         [true, 'true'].include?(@params[:links])
       else
@@ -29,6 +30,10 @@ module Graphiti
       end
     end
 
+    def debug_requested?
+      !!@params[:debug]
+    end
+
     def hash
       @hash ||= {}.tap do |h|
         h[:filter] = filters unless filters.empty?

data/lib/graphiti/rails.rb

@@ -12,6 +12,7 @@ module Graphiti
         include Graphiti::Context
         include GraphitiErrors
         around_action :wrap_context
+        around_action :debug
       end
     end
 
@@ -21,6 +22,12 @@ module Graphiti
       end
     end
 
+    def debug
+      Debugger.debug do
+        yield
+      end
+    end
+
     def jsonapi_context
       self
     end

data/lib/graphiti/railtie.rb

@@ -1,5 +1,10 @@
 module Graphiti
   class Railtie < ::Rails::Railtie
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      load "#{path}/tasks.rb"
+    end
+
     initializer "graphiti.require_activerecord_adapter" do
       config.after_initialize do |app|
         ActiveSupport.on_load(:active_record) do

data/lib/graphiti/renderer.rb

@@ -38,7 +38,7 @@ module Graphiti
     private
 
     def render(renderer)
-      notify do
+      Graphiti.broadcast(:render, records: records, options: options) do
         options[:fields] = proxy.fields
         options[:expose] ||= {}
         options[:expose][:extra_fields] = proxy.extra_fields
@@ -46,25 +46,21 @@ module Graphiti
         options[:include] = proxy.include_hash
         options[:meta] ||= {}
         options[:meta].merge!(stats: proxy.stats) unless proxy.stats.empty?
+        options[:meta][:debug] = Debugger.to_a if debug_json?
+
         renderer.render(records, options)
       end
     end
 
-    # TODO: more generic notification pattern
-    # Likely comes out of debugger work
-    def notify
-      if defined?(ActiveSupport::Notifications)
-        opts = [
-          'render.graphiti',
-          records: records,
-          options: options
-        ]
-        ActiveSupport::Notifications.instrument(*opts) do
-          yield
+    def debug_json?
+      debug = false
+      if Debugger.enabled && proxy.debug_requested?
+        context = proxy.resource.context
+        if context.respond_to?(:allow_graphiti_debug_json?)
+          debug = context.allow_graphiti_debug_json?
         end
-      else
-        yield
       end
+      debug
     end
   end
 end

data/lib/graphiti/resource/interface.rb

@@ -12,6 +12,7 @@ module Graphiti
         # @api private
         def _all(params, opts, base_scope)
           runner = Runner.new(self, params, opts.delete(:query))
+          opts[:params] = params
           runner.proxy(base_scope, opts)
         end
 

data/lib/graphiti/resource_proxy.rb

@@ -4,13 +4,16 @@ module Graphiti
 
     attr_reader :resource, :query, :scope, :payload
 
-    def initialize(resource, scope, query, payload: nil, single: false, raise_on_missing: false)
-      @resource = resource
-      @scope = scope
-      @query = query
-      @payload = payload
-      @single = single
-      @raise_on_missing = raise_on_missing
+    def initialize(resource, scope, query,
+      payload: nil,
+      single: false,
+      raise_on_missing: false)
+        @resource = resource
+        @scope = scope
+        @query = query
+        @payload = payload
+        @single = single
+        @raise_on_missing = raise_on_missing
     end
 
     def single?
@@ -122,6 +125,10 @@ module Graphiti
       query.extra_fields
     end
 
+    def debug_requested?
+      query.debug_requested?
+    end
+
     private
 
     def persist

data/lib/graphiti/scope.rb

@@ -17,7 +17,11 @@ module Graphiti
       if @query.zero_results?
         []
       else
-        resolved = @resource.resolve(@object)
+        resolved = broadcast_data do |payload|
+          payload[:results] = @resource.resolve(@object)
+          payload[:results]
+        end
+        resolved.compact!
         assign_serializer(resolved)
         yield resolved if block_given?
         if @opts[:after_resolve]
@@ -30,6 +34,18 @@ module Graphiti
 
     private
 
+    def broadcast_data
+      opts = {
+        resource: @resource,
+        params: @opts[:params],
+        sideload: @opts[:sideload],
+        parent: @opts[:parent]
+      }
+      Graphiti.broadcast("data", opts) do |payload|
+        yield payload
+      end
+    end
+
     # Used to ensure the resource's serializer is used
     # Not one derived through the usual jsonapi-rb logic
     def assign_serializer(records)
@@ -46,8 +62,9 @@ module Graphiti
 
       @query.sideloads.each_pair do |name, q|
         sideload = @resource.class.sideload(name)
+        _parent = @resource
         resolve_sideload = -> {
-          sideload.resolve(results, q)
+          sideload.resolve(results, q, _parent)
           if concurrent && defined?(ActiveRecord)
             ActiveRecord::Base.clear_active_connections!
           end

data/lib/graphiti/sideload.rb

@@ -141,10 +141,12 @@ module Graphiti
       end
     end
 
-    def load(parents, query)
+    def load(parents, query, graph_parent)
       params = load_params(parents, query)
       params_proc.call(params, parents) if params_proc
       opts = load_options(parents, query)
+      opts[:sideload] = self
+      opts[:parent] = graph_parent
       proxy = resource.class._all(params, opts, base_scope)
       pre_load_proc.call(proxy, parents) if pre_load_proc
       proxy.to_a
@@ -191,23 +193,28 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    def resolve(parents, query)
+    def resolve(parents, query, graph_parent)
       if single? && parents.length > 1
         raise Errors::SingularSideload.new(self, parents.length)
       end
 
       if self.class.scope_proc
-        sideload_scope = fire_scope(parents)
-        sideload_scope = Scope.new sideload_scope,
-          resource,
-          query,
-          sideload_parent_length: parents.length,
-          default_paginate: false
-        sideload_scope.resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
+        Graphiti.broadcast("data", resource_class: resource.class, sideload: self) do |payload|
+          sideload_scope = fire_scope(parents)
+          sideload_scope = Scope.new sideload_scope,
+            resource,
+            query,
+            parent: graph_parent,
+            sideload: self,
+            sideload_parent_length: parents.length,
+            default_paginate: false
+          sideload_scope.resolve do |sideload_results|
+            payload[:results] = sideload_results
+            fire_assign(parents, sideload_results)
+          end
         end
       else
-        load(parents, query)
+        load(parents, query, graph_parent)
       end
     end
 

data/lib/graphiti/sideload/belongs_to.rb

@@ -10,7 +10,7 @@ class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
     end
   end
 
-  def load(parents, query)
+  def load(parents, query, graph_parent)
     if ids_for_parents(parents).empty?
       []
     else

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -78,14 +78,14 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     end
   end
 
-  def resolve(parents, query)
+  def resolve(parents, query, graph_parent)
     parents.group_by(&grouper.field_name).each_pair do |group_name, group|
       next if group_name.nil?
 
       match = ->(c) { c.group_name == group_name.to_sym }
       if sideload = children.values.find(&match)
         query = remove_invalid_sideloads(sideload.resource, query)
-        sideload.resolve(group, query)
+        sideload.resolve(group, query, graph_parent)
       else
         err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
         raise err.new(self, group_name)

data/lib/graphiti/tasks.rb

@@ -0,0 +1,54 @@
+namespace :graphiti do
+  include GraphitiSpecHelpers::Helpers
+
+  def response
+    session.response
+  end
+
+  def session
+    @session ||= ActionDispatch::Integration::Session.new(Rails.application)
+  end
+
+  def setup_rails!
+    Rails.application.eager_load!
+    Rails.application.config.cache_classes = true
+    Rails.application.config.action_controller.perform_caching = false
+  end
+
+  def make_request(path, debug = false)
+    if path.split('/').length == 2
+      path = "#{ApplicationResource.endpoint_namespace}#{path}"
+    end
+    if path.include?('?')
+      path << '&cache=bust'
+    else
+      path << '?cache=bust'
+    end
+    path = "#{path}&debug=true" if debug
+    session.get("#{path}")
+  end
+
+  desc "Execute request without web server."
+  task :request, [:path,:debug] => [:environment] do |_, args|
+    setup_rails!
+    Graphiti.logger = Graphiti.stdout_logger
+    Graphiti::Debugger.preserve = true
+    require 'pp'
+    path, debug = args[:path], args[:debug]
+    puts "Graphiti Request: #{path}"
+    make_request(path, debug)
+    pp json
+    Graphiti::Debugger.flush if debug
+  end
+
+  desc "Execute benchmark without web server."
+  task :benchmark, [:path,:requests] => [:environment] do |_, args|
+    setup_rails!
+    took = Benchmark.ms do
+      args[:requests].to_i.times do
+        make_request(args[:path])
+      end
+    end
+    puts "Took: #{(took / args[:requests].to_f).round(2)}ms"
+  end
+end

data/lib/graphiti/util/serializer_relationships.rb

@@ -35,6 +35,12 @@ module Graphiti
         @serializer.relationship(@sideload.name, &block)
       end
 
+      # If we can't eagerly validate links on app boot, we do it at runtime
+      # To avoid any performance confusion, this caches that lookup
+      def self.validated_link_cache
+        @validated_link_cache ||= []
+      end
+
       private
 
       def block
@@ -49,11 +55,13 @@ module Graphiti
           data { instance_eval(&_data_proc) }
 
           if _link
-            _self.send(:validate_link!) unless _self.send(:eagerly_validate_links?)
+            if _links = @proxy.query.links?
+              _self.send(:validate_link!) unless _self.send(:eagerly_validate_links?)
 
-            if @proxy.query.links?
               link(:related) do
-                ::Graphiti::Util::Link.new(_sl, @object).generate
+                if _links
+                  ::Graphiti::Util::Link.new(_sl, @object).generate
+                end
               end
             end
           end
@@ -103,10 +111,13 @@ module Graphiti
 
       def _validate_link!(sideload)
         action = sideload.type == :belongs_to ? :show : :index
+        cache_key = :"#{@sideload.object_id}-#{action}"
+        return if self.class.validated_link_cache.include?(cache_key)
         prc = Graphiti.config.context_for_endpoint
         unless prc.call(sideload.resource.endpoint[:full_path], action)
           raise Errors::InvalidLink.new(@resource_class, sideload, action)
         end
+        self.class.validated_link_cache << cache_key
       end
 
       def link?

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.beta.5"
+  VERSION = "1.0.beta.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.beta.5
+  version: 1.0.beta.6
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-23 00:00:00.000000000 Z
+date: 2018-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.alpha.2
+        version: 1.0.beta.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.alpha.2
+        version: 1.0.beta.1
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -202,14 +202,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.alpha.1
+        version: 1.0.beta.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.alpha.1
+        version: 1.0.beta.3
 description: 
 email:
 - richmolj@gmail.com
@@ -265,6 +265,7 @@ files:
 - lib/graphiti/cli.rb
 - lib/graphiti/configuration.rb
 - lib/graphiti/context.rb
+- lib/graphiti/debugger.rb
 - lib/graphiti/deserializer.rb
 - lib/graphiti/errors.rb
 - lib/graphiti/extensions/boolean_attribute.rb
@@ -306,6 +307,7 @@ files:
 - lib/graphiti/sideload/polymorphic_belongs_to.rb
 - lib/graphiti/stats/dsl.rb
 - lib/graphiti/stats/payload.rb
+- lib/graphiti/tasks.rb
 - lib/graphiti/types.rb
 - lib/graphiti/util/attribute_check.rb
 - lib/graphiti/util/class.rb