graphiti_gql 0.2.27 → 0.2.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f6c4549cfff9295d8c6736efb65d443c8f189ca8c333b70ba24a764fa689b53
-  data.tar.gz: 71f1989c21eb48dde565f6523f798c8bd66080b572a51a00579768d29a1e87b9
+  metadata.gz: a02dc0813b461497979a165c77f9116922559c46a54ba26a5130e31832c4bcef
+  data.tar.gz: 60a27d5d31c31a39d062d1a65a2c0278ce3ea6f3cba3c4900ed1332525a54460
 SHA512:
-  metadata.gz: 3879d099e79a23726bf32320d45a999dbfc4b6a7b2fe00982e330a6fc0ffb5cbe0c1940ae03dd18ef542eb26cf47ae9e14684a647dc21529a971e1986aef1184
-  data.tar.gz: d985550be802a4206905cd4980fb5f6c434fb6aad517915602d67c6b7eb6efdab70ee8f699fe7b8dde6e97bc9bee36b5a081525505ae0c6a09aa9bbf84e97129
+  metadata.gz: e2a9a66b5dd624962bfffdc733115f8cf0363846db434bf9dfbe76374cd94dd0b9411ccf2aa93ce543a144ad0505e9f8d1e39bcb34b5593a7f870e17d7f13440
+  data.tar.gz: eb5004a261e6b7b815eb16ab548591c27beda1231e0875103c75d059c885ed2311b7d8c2b4d1a651d08905facdb8478b328eb5f78ec0fb812dab8cfc5f175583

data/Gemfile.lock

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

data/lib/graphiti_gql/active_resource.rb

@@ -37,18 +37,20 @@ module GraphitiGql
       def edge(name, node_id)
         found = @edges[name].empty? ? nil : @edges[name]
         if found && node_id
-          found.find { |f| f.instance_variable_get(:@node_id) == node_id.to_s }
+          found.find do |f|
+            gql_node_id = f.instance_variable_get(:@node_id)
+            gql_node_id == node_id ||
+              gql_node_id == node_id.to_s ||
+              gql_node_id == @resource.gid(node_id)
+          end
         else
           found
         end
       end
 
-      def decoded_id
-        Base64.decode64(self.id)
-      end
-
-      def int_id
-        decoded_id.to_i
+      def _id
+        deserialized = @resource.deserialize_gid(id)
+        deserialized.to_i.to_s == deserialized ? deserialized.to_i : deserialized
       end
     end
 
@@ -77,7 +79,7 @@ module GraphitiGql
           data # fire query
           Node.new(underscore(data[data.keys.first]), @resource)
         else
-          nodes.find { |n| n.id == id.to_s }
+          nodes.find { |n| n.id == id.to_s || n.id == @resource.gid(id) }
         end
       end
 

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/graphiti_hax.rb

@@ -71,13 +71,46 @@ module GraphitiGql
     end
 
     class_methods do
+      def gid(*ids)
+        ids = ids[0] if ids[0].is_a?(Array) && ids.length == 1
+        gids = ids.map { |id| serialize_gid(id) }
+        ids.length == 1 ? gids.first : gids
+      end
+
+      def serialize_gid(id)
+        Base64.encode64("#{graphql_name}/#{id}")
+      end
+
+      def deserialize_gid(gid, integer = true)
+        id = Base64.decode64(gid).split("/").last
+        id.to_i.to_s == id ? id.to_i : id
+      end
+
       def config
         return @config if @config
         super
         @config = @config.merge(value_objects: {}, is_value_object: false)
       end
 
+      def graphql_name
+        @graphql_name ||= begin
+          if name.nil?
+            'Unknown'
+          else
+            name.gsub('Resource', '').gsub('::', '')
+          end
+        end
+      end
+
       def attribute(*args)
+        # new default is :gid, not integer_id
+        if args[0] == :id && args[1] == :integer_id
+          args[1] = :gid
+          opts = args.extract_options!
+          opts[:null] = false
+          args << opts
+        end
+
         super(*args).tap do
           opts = args.extract_options!
           att = config[:attributes][args[0]]
@@ -143,6 +176,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)
@@ -314,6 +353,7 @@ module GraphitiGql
     description: 'Datetime with milliseconds'
   }
 
+  # Support ranges
   [:string, :integer, :float, :datetime, :precise_datetime].each do |kind|
     duped_hash = Graphiti::Util::Hash.deep_dup(Graphiti::Types[:hash])
     type = Graphiti::Types[:"#{kind}_range"] = duped_hash
@@ -328,6 +368,29 @@ module GraphitiGql
     }
   end
 
+  # Support gid
+  gid_going_out = ->(id) {
+    resource.gid(id)
+  }
+
+  gid_coming_in = definition.constructor do |input|
+    if defined?(ApplicationResource)
+      ApplicationResource.deserialize_gid(input)
+    else
+      Graphiti::Resource.deserialize_gid(input)
+    end
+  end
+
+  # Register it with Graphiti
+  Graphiti::Types[:gid] = {
+    params: gid_coming_in,
+    read: gid_going_out,
+    write: gid_coming_in,
+    kind: 'scalar',
+    canonical_name: :gid,
+    description: 'Globally-unique identifier',
+  }
+
   module ActiveRecordAdapterExtras
     extend ActiveSupport::Concern
 
@@ -338,6 +401,8 @@ module GraphitiGql
       alias_method :filter_precise_datetime_gte, :filter_gte
       alias_method :filter_precise_datetime_eq, :filter_eq
       alias_method :filter_precise_datetime_not_eq, :filter_not_eq
+      alias_method :filter_gid_eq, :filter_eq
+      alias_method :filter_gid_not_eq, :filter_not_eq
     end
 
     # TODO: integration specs mysql vs postgres for case sensitivity
@@ -387,11 +452,14 @@ module GraphitiGql
     class << self
       alias :old_default_operators :default_operators
       def default_operators
-        old_default_operators.merge({
-          precise_datetime: numerical_operators,
+        ops = old_default_operators.merge({
+          precise_datetime: numerical_operators - [:not_eq],
           string_enum: [:eq, :not_eq],
           integer_enum: [:eq, :not_eq],
+          gid: [:eq, :not_eq]
         })
+        ops[:datetime] = ops[:datetime] - [:not_eq]
+        ops
       end
     end
   end
@@ -519,4 +587,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

@@ -1,6 +1,10 @@
 module GraphitiGql
   module Loaders
-    class FakeRecord < Struct.new(:id, :type)
+    class FakeRecord < Struct.new(:id, :type, :graphiti_resource)
+      def initialize(*args)
+        super
+        @__graphiti_resource = graphiti_resource
+      end
     end
 
     class BelongsTo < GraphQL::Batch::Loader
@@ -10,6 +14,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!
@@ -20,11 +25,11 @@ module GraphitiGql
             ids.each do |id|
               child = @sideload.children.values.find { |c| c.group_name == id[:type].to_sym }
               type = Schema::Registry.instance.get(child.resource.class, interface: false)[:type]
-              fulfill(id, FakeRecord.new(id[:id], type))
+              fulfill(id, FakeRecord.new(id[:id], type, child.resource))
             end
           else
             type = Schema::Registry.instance.get(@sideload.resource.class)[:type]
-            ids.each { |id| fulfill(id, FakeRecord.new(id, type)) }
+            ids.each { |id| fulfill(id, FakeRecord.new(id, type, @sideload.resource)) }
           end
           return
         end
@@ -39,9 +44,10 @@ module GraphitiGql
           payload.each_pair do |key, value|
             params = { filter: {} }
             klass = @sideload.children.values.find { |c| c.group_name == key.to_sym }
-            params = {
-              filter: { id: { eq: value.join(",") } }
-            }
+            filter_ids = value.map { |id| @sideload.resource.class.gid(id.to_s) }
+            params = @params.merge({
+              filter: { id: { eq: filter_ids } }
+            })
 
             futures << Concurrent::Future.execute do
                { type: key, data: klass.resource.class.all(params).data }
@@ -54,9 +60,10 @@ module GraphitiGql
           end
         else
           resource = Schema.registry.get(@sideload.resource.class)[:resource]
-          params = {}
+          params = @params.deep_dup
           unless resource.singular
-            params[:filter] = {id: { eq: ids.join(",") } }
+            filter_ids = ids.map { |id| @sideload.resource.class.gid(id.to_s) }
+            params[:filter] = {id: { eq: filter_ids } }
           end
           records = resource.all(params).data
           if resource.singular

data/lib/graphiti_gql/loaders/many.rb

@@ -15,10 +15,11 @@ module GraphitiGql
 
       def initialize(sideload, params)
         @sideload = sideload
-        @params = params
+        @params = params.merge(typecast_filters: false)
       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?
 
@@ -33,6 +34,7 @@ module GraphitiGql
             pk
           end
         end
+        ids.compact!
 
         build_params(ids, parent_records)
         resource = Schema.registry.get(@sideload.resource.class)[:resource]
@@ -52,13 +54,16 @@ module GraphitiGql
         if @sideload.polymorphic_as
           type = ids[0][:"#{@sideload.polymorphic_as}_type"]
           foreign_keys = ids.map { |id| id[@sideload.foreign_key] }
+          foreign_keys.map! { |id| @sideload.parent_resource.class.gid(id) }
           @params[:filter][:"#{@sideload.polymorphic_as}_type"] = type
-          @params[:filter][@sideload.foreign_key] = foreign_keys.join(",")
+          @params[:filter][@sideload.foreign_key] = foreign_keys
         elsif @sideload.type == :many_to_many
+          filter_ids = ids.map { |id| @sideload.parent_resource.class.gid(id) }
           fk = @sideload.foreign_key.values.first
-          @params[:filter].merge!(fk => { eq: ids.join(",") })
+          @params[:filter].merge!(fk => { eq: filter_ids })
         elsif !@sideload.parent_resource.class.singular
-          @params[:filter].merge!(@sideload.foreign_key => { eq: ids.join(",") })
+          filter_ids = ids.map { |id| @sideload.parent_resource.class.gid(id) }
+          @params[:filter].merge!(@sideload.foreign_key => { eq: filter_ids })
         end
 
         if @params[:stats]

data/lib/graphiti_gql/log_subscriber.rb

@@ -0,0 +1,177 @@
+# 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
+      stmt = "#{indent}   #{num_results} #{"result".pluralize(num_results)}"
+      stmt << " of #{"type".pluralize(klasses.length)} #{klasses.to_sentence}" if num_results > 0
+      add_chunk(stmt, 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) if err['path']
+          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]
+      return [] unless 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/attribute.rb

@@ -37,7 +37,16 @@ module GraphitiGql
               end
             end
             return if value.nil?
-            Graphiti::Types[_config[:type]][:read].call(value)
+
+            caster = Graphiti::Types[_config[:type]][:read]
+            # Dry::Types can't be instance_exec'd
+            # This dependency has probably served it's purpose and can be
+            # refactored away
+            if caster.is_a?(Proc)
+              instance_exec(value, &caster)
+            else
+              caster.call(value)
+            end
           end
         end
 
@@ -51,7 +60,6 @@ module GraphitiGql
             if !field_type
               canonical_graphiti_type = Graphiti::Types.name_for(@config[:type])
               field_type = GQL_TYPE_MAP[canonical_graphiti_type.to_sym]
-              field_type = String if @name == :id
             end
             field_type = [field_type] if @config[:type].to_s.starts_with?("array_of")
             field_type

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

@@ -12,7 +12,7 @@ module GraphitiGql
             null: true,
             extras: [:lookahead]
           unless @registered[:resource].singular
-            field.argument(:id, String, required: true)
+            field.argument(:id, GraphQL::Types::ID, required: true)
           end
           _registered = @registered
           query.define_method name do |**arguments|

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

@@ -77,7 +77,6 @@ module GraphitiGql
             canonical_graphiti_type = Graphiti::Types
               .name_for(filter_config[:type])
             type = GQL_TYPE_MAP[canonical_graphiti_type]
-            type = String if filter_name == :id
           end
 
           if (allowlist = filter_config[:allow])

data/lib/graphiti_gql/schema/registry.rb

@@ -60,8 +60,7 @@ module GraphitiGql
       private
 
       def key_for_resource(resource)
-        resource.graphql_name ||
-          resource.name.gsub('Resource', '').gsub('::', '')
+        resource.graphql_name
       end
     end
   end

data/lib/graphiti_gql/schema/resource_type.rb

@@ -141,6 +141,17 @@ module GraphitiGql
           klass = Class.new(Schema.base_object)
         end
 
+        klass.define_method :resource do
+          return @resource if @resource
+          resource = object.instance_variable_get(:@__graphiti_resource)
+          resource_class = resource.class
+          if resource_class.polymorphic? && !resource_class.polymorphic_child?
+            resource_class = resource_class.resource_for_model(object)
+          end
+          @resource = resource_class
+          resource_class
+        end
+
         klass
       end
 

data/lib/graphiti_gql/schema.rb

@@ -33,6 +33,7 @@ module GraphitiGql
       integer_id: String,
       string: String,
       uuid: String,
+      gid: GraphQL::Types::ID,
       integer: Integer,
       big_integer: GraphQL::Types::BigInt,
       float: Float,
@@ -68,7 +69,9 @@ module GraphitiGql
     end
 
     def self.base_object
+      return @base_object if @base_object
       klass = Class.new(GraphQL::Schema::Object)
+
       # TODO make this config maybe
       if defined?(ActionView)
         klass.send(:include, ActionView::Helpers::TranslationHelper)
@@ -79,6 +82,7 @@ module GraphitiGql
           end
         end
       end
+      @base_object = klass
       klass
     end
 

data/lib/graphiti_gql/spec_helper.rb

@@ -74,6 +74,9 @@ module GraphitiGql
       resource.gql(params.merge(fields: fields), ctx, q, opts)
     end
 
+    def gid(*ids)
+      resource.gid(*ids)
+    end
 
     def run
       lambda do

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.27"
+  VERSION = "0.2.30"
 end

data/lib/graphiti_gql.rb

@@ -28,13 +28,14 @@ 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 :exception_handler, :error_handling
+    attr_accessor :exception_handler, :error_handling, :logging
 
     def exception_handler
       @exception_handler ||= ExceptionHandler
@@ -43,6 +44,10 @@ module GraphitiGql
     def error_handling
       @error_handling != false
     end
+
+    def log
+      @log ||= !ENV['GRAPHITI_LOG_LEVEL'].nil?
+    end
   end
 
   def self.schema!
@@ -72,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.27
+  version: 0.2.30
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-22 00:00:00.000000000 Z
+date: 2022-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -154,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