graphiti_gql 0.2.25 → 0.2.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae5d9ce0fe34ef8d53204f8c292b5d09cb58c821ec413804a169e3a562061ad2
-  data.tar.gz: 02fc540e3203efe6311fba2d30c3b8b75308103cffe4b5df1f01b29dac804e74
+  metadata.gz: ffc7f76831ea15375482b1ec32d6fe090b19c9ebdac1ea081805dfcf32497072
+  data.tar.gz: 3ac75bdef55c8cf63de7e2f9554dbc0e58f1f5a7a23ba591cbfac9891a9b8118
 SHA512:
-  metadata.gz: e01483c436cbc15cb0c80598725a16440ba0254242554c9a2401c4dd72ca5cd4b847941fe3d02da7a4d023640b7ca20824e2537a04654dc2d46c192e53885863
-  data.tar.gz: 13478f1634bcb76c13cf9aef90c036fb5636a55c72643db21e854cca9679c4c735e848c6245e73d2194374fa54ee34eecda4cc17240f5cbe491acf14a0ef9db9
+  metadata.gz: e51aca16a756ed7f0e053fda559e07831433ae0e37a6ab40908468a07bfa93eb48c12abd045ea93dbdc8dc8b716ff5abb190347b88d089b13305d2fd7a6ac818
+  data.tar.gz: 53e611a009a2277cfc0bc7318710a537fd02c06760921716e149bfa8cebbbeb3607c3b409e8830460be1e80ba41b66c366507f1057c2215ee7fb7ffc79b77653

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.2.25)
+    graphiti_gql (0.2.27)
       activemodel (> 6.0, < 8.0)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)

data/lib/graphiti_gql/engine.rb

@@ -2,11 +2,20 @@ module GraphitiGql
   class Engine < ::Rails::Engine
     isolate_namespace GraphitiGql
 
-    # TODO improvable?
     config.to_prepare do
-    # initializer "graphiti_gql.generate_schema" do
       Dir.glob("#{Rails.root}/app/resources/**/*").each { |f| require(f) }
       GraphitiGql.schema!
+
+      log_level = ENV.fetch('GRAPHITI_LOG_LEVEL', '1').to_i
+      log_activerecord = false
+      if log_level == -1 && defined?(ActiveRecord)
+        log_level = 0
+        log_activerecord = true
+      end
+      Graphiti.logger.level = log_level
+      if GraphitiGql.config.log
+        GraphitiGql::LogSubscriber.subscribe!(activerecord: log_activerecord)
+      end
     end
   end
 end

data/lib/graphiti_gql/exception_handler.rb

@@ -0,0 +1,52 @@
+module GraphitiGql
+  class ExceptionHandler
+    attr_reader :error, :context, :field
+    class_attribute :registry, :log, :notify, :default_message, :default_code
+
+    self.registry = {}
+    self.default_message = "We're sorry, something went wrong."
+    self.default_code = 500
+
+    def self.register_exception(err, opts)
+      registry[err] = opts
+    end
+
+    register_exception Graphiti::Errors::RecordNotFound, code: 404
+    register_exception Graphiti::Errors::SingularSideload, code: 400
+    register_exception Graphiti::Errors::InvalidAttributeAccess, code: 403
+    register_exception GraphitiGql::Errors::UnsupportedLast, code: 400
+
+    def initialize(err, obj, args, ctx, field)
+      @error = err
+      @obj = obj
+      @args = args
+      @context = ctx
+      @field = field
+      @config = get_config(err)
+    end
+
+    def notify
+      # noop
+    end
+
+    def log
+      # noop
+    end
+
+    def handle
+      notify if @config[:notify] != false
+      log if @config[:log] != false
+
+      message = @config[:message] ? err.message : default_message
+      code = @config[:code] || default_code
+      raise GraphQL::ExecutionError.new(message, extensions: { code: code })
+    end
+
+    private
+
+    def get_config(error)
+      registered = registry.find { |e, _| error.is_a?(e) }
+      registered ? registered[1] : {}
+    end
+  end
+end

data/lib/graphiti_gql/graphiti_hax.rb

@@ -131,7 +131,7 @@ module GraphitiGql
 
       def value_object(name, opts = {})
         opts[:array] ||= false
-        opts[:null] ||= true
+        opts[:null] = true if opts[:null] != false
         config[:value_objects][name] = Graphiti::ValueObjectAssociation.new(
           name,
           parent_resource_class: self,
@@ -143,6 +143,12 @@ module GraphitiGql
           deprecation_reason: opts[:deprecation_reason]
         )
       end
+
+      def all(*args)
+        params = args[0]
+        Graphiti.broadcast("resource.all", { params: params, resource: self })
+        super
+      end
     end
   end
   Graphiti::Resource.send(:prepend, ResourceExtras)
@@ -438,6 +444,7 @@ module GraphitiGql
 
     def resolve(*args)
       results = super
+      raise Graphiti::Errors::InvalidResolve unless results.is_a?(Array)
       results.reverse! if @query.hash[:reverse]
       results
     end
@@ -458,6 +465,24 @@ module GraphitiGql
   end
 end
 
+class Graphiti::Errors::InvalidResolve < Graphiti::Errors::Base
+  def message
+    "Resource#resolve must always return an array"
+  end
+end
+
+class Graphiti::Errors::InvalidValueObject < Graphiti::Errors::Base
+  def initialize(resource, name, value)
+    @resource = resource
+    @name = name
+    @value = value
+  end
+
+  def message
+    "#{@resource} - value object '#{@name}' configured with array: true but returned non-array: #{@value.inspect}"
+  end
+end
+
 class Graphiti::ValueObjectAssociation
   attr_reader :name,
     :parent_resource_class,
@@ -500,4 +525,21 @@ class Graphiti::ValueObjectAssociation
     instance.parent = parent
     instance
   end
+end
+
+module Graphiti
+  def self.debug(msg, color = :white, bold = false)
+    log(msg, color, bold, level: :debug)
+  end
+
+  def self.info(msg, color = :white, bold = false)
+    log(msg, color, bold, level: :info)
+  end
+
+  def self.log(msg, color = :white, bold = false, level: nil)
+    return unless ::GraphitiGql.config.log
+    colored = ActiveSupport::LogSubscriber.new.send(:color, msg, color, bold)
+    level ||= :debug
+    logger.send(level, colored)
+  end
 end

data/lib/graphiti_gql/loaders/belongs_to.rb

@@ -10,6 +10,7 @@ module GraphitiGql
       end
 
       def perform(ids)
+        Graphiti.broadcast("association", { sideload: @sideload })
         # process nils
         ids.each { |id| fulfill(id, nil) if id.nil? }
         ids.compact!

data/lib/graphiti_gql/loaders/many.rb

@@ -19,6 +19,7 @@ module GraphitiGql
       end
 
       def perform(parent_records)
+        Graphiti.broadcast("association", { sideload: @sideload })
         raise ::Graphiti::Errors::UnsupportedPagination if paginating? && parent_records.length > 1
         raise Errors::UnsupportedStats if requesting_stats? && parent_records.length > 1 && !can_group?
 

data/lib/graphiti_gql/log_subscriber.rb

@@ -0,0 +1,174 @@
+# TODO: remove OG graphiti debugger
+module GraphitiGql
+  class LogSubscriber
+    def self.subscribe!(activerecord: false)
+      instance = LogSubscriber.new
+      instance.subscribe!('resolve', :on_data)
+      instance.subscribe!('schema.before_execute', :on_schema_before_execute)
+      instance.subscribe!('schema.execute', :on_schema_execute)
+      instance.subscribe!('resource.all', :on_resource_all)
+      instance.subscribe!('association', :on_association)
+      instance.subscribe!('before_stats', :on_before_stats)
+      instance.subscribe!('after_stats', :on_after_stats)
+      if activerecord
+        ActiveSupport::Notifications
+          .subscribe("sql.active_record", instance.method(:on_activerecord))
+      end
+    end
+
+    def initialize
+      @chunks = {}
+    end
+
+    def subscribe!(name, method_name)
+      ActiveSupport::Notifications
+        .subscribe("#{name}.graphiti", method(method_name))
+    end
+
+    def on_data(name, start, stop, id, payload)
+      @resolving = false
+      if payload[:exception]
+        @error_on_resolve = true
+        return
+      end
+
+      num_results = payload[:results].length
+      klasses = payload[:results].map(&:class).map(&:name).uniq
+      color = num_results == 0 ? :yellow : :green
+      add_chunk("#{indent}   #{num_results} #{"result".pluralize(num_results)} of #{"type".pluralize(klasses.length)} #{klasses.to_sentence}", color, true)
+
+      took = ((stop - start) * 1000.0).round(2)
+      add_chunk("#{indent}   Took: #{took}ms", :magenta, true)
+    end
+
+    def on_schema_before_execute(name, start, stop, id, payload)
+      Graphiti.debug(payload[:query].strip_heredoc, :white, true)
+      unless payload[:variables].empty?
+        Graphiti.debug("✨ Variables: #{payload[:variables].inspect}", :yellow, true)
+      end
+      unless payload[:context].empty?
+        Graphiti.debug("✨ Context: #{payload[:context].inspect}", :blue, true)
+      end
+      Graphiti.debug(%|💡 Debug tip! Override Resource#resolve:
+
+class YourResource < ApplicationResource
+  # ... code ...
+  def resolve(scope)
+    debugger
+    # if activerecord, call scope.to_sql/scope.to_a
+    super
+  end
+end|, :white, true)
+      Graphiti.debug("🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠 Executing! 🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠🚀🤠", :white, true)
+    end
+
+    def on_schema_execute(name, start, stop, id, payload)
+      if payload[:exception] || (response_errors = payload[:result]["errors"])
+        indent = indent(path: @last_association_path)
+        add_chunk("#{indent}❌🚨❌🚨❌🚨❌ ERROR! ❌🚨❌🚨❌🚨❌", :red, true, path: @last_association_path)
+        if @error_on_resolve
+          add_chunk("#{indent}This error occurred while executing the above query, so it's likely not caused by Graphiti itself. Maybe bad SQL? Try running again and putting a debugger in this Resource's #resolve, or try to run the query independent of Graphiti/GraphQL.",
+            :red, true, path: @last_association_path)
+        end
+        flush_chunks(@chunks)
+        if response_errors
+          Graphiti.info("❌🚨 Response contained errors!", :red, true)
+          response_errors.each do |err|
+            Graphiti.info("#{err['extensions']['code']} - #{err['message']}", :red, true)
+            Graphiti.info("#{err['path'].join(".")}", :red, false)
+          end
+        end
+      else
+        flush_chunks(@chunks)
+        took = ((stop - start) * 1000.0).round(2)
+        Graphiti.info("✅ Completed successfully in #{took}ms", :magenta, true)
+      end
+    end
+
+    def on_resource_all(name, start, stop, id, payload)
+      @resolving = true
+      params = payload[:params].inspect
+      resource = payload[:resource].name
+      if thin_path.length == 1
+        add_chunk("Query.#{thin_path.first}", :yellow, true)
+      end
+      add_chunk("#{indent}\\_ #{resource}.all(#{params})", :cyan, true)
+    end
+
+    def on_association(name, start, stop, id, payload)
+      @last_association_path = thin_path
+      sideload = payload[:sideload]
+      add_chunk("#{indent}🔗 #{sideload.type} :#{sideload.name}", :white, true)
+    end
+
+    def on_before_stats(name, start, stop, id, payload)
+      @stats = true
+      add_chunk("#{indent}🔢 Calculating Statistics...", :yellow, true)
+    end
+
+    def on_after_stats(name, start, stop, id, payload)
+      @stats = false
+      took = ((stop - start) * 1000.0).round(2)
+      add_chunk("#{indent}🔢 Done! Took #{took}ms", :yellow, true)
+    end
+
+    def on_activerecord(name, start, stop, id, payload)
+      if @resolving || @stats
+        sql = payload[:sql]
+        unless sql.starts_with?('SHOW ')
+          add_chunk("#{indent}#{sql}", :blue, true)
+        end
+      end
+    end
+
+    private
+
+    def flush_chunks(chunks)
+      chunks.each_pair do |_, value|
+        value[:lines].each do |line|
+          Graphiti.info(line[:text], line[:color], line[:bold])
+        end
+        flush_chunks(value.except(:lines))
+      end
+    end
+
+    def add_chunk(text, color, bold, path: nil)
+      path ||= thin_path
+      current_chunks = @chunks
+      path.each_with_index do |subpath, index|
+        last = index == path.length - 1
+        line = { text: text, color: color, bold: bold }
+        if current_chunks.key?(subpath)
+          if last
+            current_chunks[subpath][:lines] << line
+          else
+            current_chunks = current_chunks[subpath]
+          end
+        else
+          current_chunks[subpath] ||= { lines: [] }
+          current_chunks[subpath][:lines] << line
+        end
+      end
+    end
+
+    def thin_path
+      path = Graphiti.context[:object][:current_path]
+      path.reject do |p|
+        p.is_a?(Integer) ||
+          p == "nodes" ||
+          p == "node" ||
+          p == "edges"
+      end
+    end
+
+    def indent(path: nil)
+      path ||= thin_path
+      "   " * [path.length - 1, 0].max
+    end
+
+    def current_path
+      path = Graphiti.context[:object][:current_path].join(".")
+      "Query.#{path}"
+    end
+  end
+end

data/lib/graphiti_gql/schema/fields/stats.rb

@@ -9,16 +9,19 @@ module GraphitiGql
         def apply(type)
           type.field :stats, build_stat_class, null: false
           type.define_method :stats do
+            Graphiti.broadcast('before_stats', {})
             # Process grouped (to-many relationship) stats
-            stats = object.proxy.stats.deep_dup
-            stats.each_pair do |attr, calc|
-              calc.each_pair do |calc_name, value|
-                if value.is_a?(Hash)
-                  stats[attr][calc_name] = value[parent.id]
+            Graphiti.broadcast('after_stats', {}) do
+              stats = object.proxy.stats.deep_dup
+              stats.each_pair do |attr, calc|
+                calc.each_pair do |calc_name, value|
+                  if value.is_a?(Hash)
+                    stats[attr][calc_name] = value[parent.id]
+                  end
                 end
               end
+              stats
             end
-            stats
           end
           type
         end

data/lib/graphiti_gql/schema/list_arguments.rb

@@ -54,6 +54,8 @@ module GraphitiGql
           end
         end
         @resource.filters.each_pair do |name, config|
+          next if config[:schema] == false
+
           attr_type = generate_filter_attribute_type(type_name, name, config)
           required = !!config[:required] || required_via_group.include?(name)
           klass.argument name.to_s.camelize(:lower),

data/lib/graphiti_gql/schema/resource_type.rb

@@ -44,12 +44,14 @@ module GraphitiGql
             end
 
             result = vo_resource_class.all({ parent: object }).to_a
-            if result.is_a?(Array) && !_array
-              result = result.first
-            end
-            if result == object || result == [object]
+            default_behavior = result == [object]
+            result = result.first if !_array
+            if default_behavior
               method_name = vo_association.alias.presence || name
               result = object.send(method_name)
+              if _array && !result.is_a?(Array)
+                raise Graphiti::Errors::InvalidValueObject.new(resource, name, result)
+              end
             end
             result
           end

data/lib/graphiti_gql/schema.rb

@@ -101,6 +101,14 @@ module GraphitiGql
       klass.connections.add(ResponseShim, Connection)
       klass.connections.add(Array, ToManyConnection)
       klass.orphan_types [GraphQL::Types::JSON]
+      klass.rescue_from(Exception) do |err, obj, args, ctx, field|
+        if GraphitiGql.config.error_handling
+          handler = GraphitiGql.config.exception_handler
+          handler.new(err, obj, args, ctx, field).handle
+        else
+          raise err
+        end
+      end
       klass
     end
   end

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.25"
+  VERSION = "0.2.28"
 end

data/lib/graphiti_gql.rb

@@ -27,13 +27,27 @@ require "graphiti_gql/schema/fields/to_one"
 require "graphiti_gql/schema/fields/attribute"
 require "graphiti_gql/schema/fields/stats"
 require "graphiti_gql/active_resource"
+require "graphiti_gql/exception_handler"
+require "graphiti_gql/log_subscriber"
 require "graphiti_gql/engine" if defined?(Rails)
 
 module GraphitiGql
   class Error < StandardError; end
 
   class Configuration
-    attr_accessor :application_controller
+    attr_accessor :exception_handler, :error_handling, :logging
+
+    def exception_handler
+      @exception_handler ||= ExceptionHandler
+    end
+
+    def error_handling
+      @error_handling != false
+    end
+
+    def log
+      @log ||= !ENV['GRAPHITI_LOG_LEVEL'].nil?
+    end
   end
 
   def self.schema!
@@ -63,10 +77,20 @@ module GraphitiGql
       context = Graphiti.context[:object]
     end
     Graphiti.with_context(context) do
-      result = schema.execute query_string,
+      payload = {
+        query: query_string,
         variables: variables,
         context: context
-      result.to_h
+      }
+      Graphiti.broadcast("schema.before_execute", payload)
+      Graphiti.broadcast("schema.execute", payload) do
+        result = schema.execute query_string,
+          variables: variables,
+          context: context
+        result_hash = result.to_h
+        payload[:result] = result_hash
+        result_hash
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 0.2.28
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -146,6 +146,7 @@ files:
 - lib/graphiti_gql/active_resource.rb
 - lib/graphiti_gql/engine.rb
 - lib/graphiti_gql/errors.rb
+- lib/graphiti_gql/exception_handler.rb
 - lib/graphiti_gql/graphiti_hax.rb
 - lib/graphiti_gql/loaders/belongs_to.rb
 - lib/graphiti_gql/loaders/has_many.rb
@@ -153,6 +154,7 @@ files:
 - lib/graphiti_gql/loaders/many.rb
 - lib/graphiti_gql/loaders/many_to_many.rb
 - lib/graphiti_gql/loaders/polymorphic_has_many.rb
+- lib/graphiti_gql/log_subscriber.rb
 - lib/graphiti_gql/response_shim.rb
 - lib/graphiti_gql/schema.rb
 - lib/graphiti_gql/schema/connection.rb