graphiti_gql 0.2.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff76a3032a8378019cc0034c48cc1bd33302a8d662515fd722d970e642ee355e
-  data.tar.gz: 532980890cd827d260bceebd5f944eeb999a561cde6df3e14cff5ddbfaa5f146
+  metadata.gz: 84a7ebf615007ac087b7bab32e53b78fc1bbdb7abcd9d65e38beac1ec7e578fc
+  data.tar.gz: d5c625d0e34f750d8fc3bc8c71f39ccabb70aa1c87340978620e965137e15feb
 SHA512:
-  metadata.gz: 8a67a1e359377aa6682b2f23fd0461b2547a05df41c14739d4abf691d879682dd8cd83a4e4deda386855ae6c7a587feb453b2aff5490d2e0d44998955ff6bba9
-  data.tar.gz: f5f83d5859fc24f3215723d3abd7d1105dcefc3f02002853f829a4d954923444df0d1a37c0cbbb736dbb79df9745dd1be1c197c6151b07febb117272eb12e8e7
+  metadata.gz: e8ea8defdb4712239187bcbb14a0d5dbeee9e52bf11a7c32dd747da2eae62247ef66fda15dd63b57886920a895f8215fe7a33b8eb3dc156194b3b2e3fd2f75c6
+  data.tar.gz: 42f885befb9c54a6b915642e40f2d2bb8704571c901c392f2a6fe11196d805113ca7af546ff15db7b336fdceff172ba2c27e9f443381462db26b4b44461eab6b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.2.1)
+    graphiti_gql (0.2.2)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)
       graphql-batch (~> 0.5)
@@ -47,7 +47,7 @@ GEM
       jsonapi-serializable (~> 0.3.0)
     graphiti_errors (1.1.2)
       jsonapi-serializable (~> 0.1)
-    graphql (2.0.7)
+    graphql (2.0.11)
     graphql-batch (0.5.1)
       graphql (>= 1.10, < 3)
       promise.rb (~> 0.7.2)

data/lib/graphiti_gql/active_resource.rb

@@ -0,0 +1,210 @@
+module GraphitiGql
+  module ActiveResource
+    extend ActiveSupport::Concern
+
+    class Node < OpenStruct
+      def initialize(resource, hash)
+        @resource = resource
+        hash.each_pair do |key, value|
+          if value.is_a?(Hash)
+            if (sideload = resource.sideload(key))
+              if value.key?(:edges) 
+                hash[key] = value[:edges].map { |v| Node.new(sideload.resource.class, v[:node]) }
+              else
+                hash[key] = Node.new(sideload.resource.class, value)
+              end
+            end
+          end
+        end
+        super(hash)
+      end
+
+      def decoded_id
+        Base64.decode64(self.id)
+      end
+
+      def int_id
+        decoded_id.to_i
+      end
+    end
+
+    class Proxy
+      def initialize(resource, params, ctx)
+        @resource = resource
+        @ctx = ctx
+        @params = params.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
+        (@params[:sort] || []).each do |sort|
+          sort[:att] = sort[:att].to_s.camelize(:lower)
+          sort[:dir] = sort[:dir].to_s
+        end
+      end
+
+      def to_h(symbolize_keys: true)
+        result = GraphitiGql.run(query, @params, @ctx)
+        result = result.deep_symbolize_keys if symbolize_keys
+        @response = result
+        result
+      end
+
+      def nodes
+        return [] unless data
+        nodes = edges.map { |e| underscore(e[:node]) }
+        nodes.map { |n| Node.new(@resource, n) }
+      end
+      alias :to_a :nodes
+
+      def response
+        @response ||= to_h
+      end
+
+      def data
+        if response.key?(:data)
+          response[:data]
+        else
+          raise "Tried to access 'data', but these errors were returned instead: #{error_messages.join(". ")}."
+        end
+      end
+
+      def errors
+        response[:errors]
+      end
+  
+      def error_messages
+        response[:errors].map { |e| e[:message] }
+      end
+
+      def edges
+        data[data.keys.first][:edges]
+      end
+  
+      def stats
+        underscore(data[data.keys.first][:stats])
+      end
+  
+      def page_info
+        underscore(data[data.keys.first][:pageInfo])
+      end
+
+      def query
+        name = Schema.registry.key_for(@resource)
+        filter_bang = "!" if @resource.filters.values.any? { |f| f[:required] }
+        sortvar = "$sort: [#{name}Sort!]," if @resource.sorts.any?
+
+        if !(fields = @params[:fields])
+          fields = []
+          @resource.attributes.each_pair do |name, config|
+            (fields << name) if config[:readable]
+          end
+        end
+
+        q = %|
+          query #{name} (
+            $filter: #{name}Filter#{filter_bang},
+            #{sortvar}
+            $first: Int,
+            $last: Int,
+            $before: String,
+            $after: String,
+          ) {
+            #{@resource.graphql_entrypoint} (
+              filter: $filter,
+              #{ 'sort: $sort,' if sortvar }
+              first: $first,
+              last: $last,
+              before: $before,
+              after: $after,
+            ) {
+              edges {
+                node {|
+
+        fields.each do |name|
+          q << %|
+                  #{name.to_s.camelize(:lower)}|
+        end
+
+        if @params[:include]
+          includes = Array(@params[:include])
+          # NB HASH (?)
+          includes.each do |inc|
+            sideload = @resource.sideload(inc.to_sym)
+            to_one = [:belongs_to, :has_one, :polymorphic_belongs_to].include?(sideload.type)
+            indent = "    " if !to_one
+            q << %|
+                  #{inc.to_s.camelize(:lower)} {|
+            if !to_one
+              q << %|
+                    edges {
+                      node {|
+            end
+
+            r = @resource.sideload(inc.to_sym).resource
+            r.attributes.each_pair do |name, config|
+              next unless config[:readable]
+              q << %|
+                    #{indent}#{name.to_s.camelize(:lower)}|
+            end
+
+            if to_one
+              q << %|
+                  }|
+            else
+              q << %|
+                      }
+                    }
+                  }|
+            end
+          end
+        end
+  
+        q << %|
+                }
+              }
+              pageInfo {
+                startCursor
+                endCursor
+                hasNextPage
+                hasPreviousPage
+              }|
+
+        if @params[:stats]
+          q << %|
+              stats {|
+          @params[:stats].each_pair do |name, calculations|
+            q << %|
+                #{name.to_s.camelize(:lower)} {|
+            Array(calculations).each do |calc|
+              q << %|
+                  #{calc.to_s.camelize(:lower)}|
+            end
+    
+            q << %|
+                }|
+          end
+          q << %|
+              }|          
+        end
+
+        q << %|
+            }
+          }
+        |
+
+        q
+      end
+
+      private
+
+      def underscore(hash)
+        hash.deep_transform_keys { |k| k.to_s.underscore.to_sym }
+      end
+    end
+
+    class_methods do
+      def gql(params = {}, ctx = {})
+        Proxy.new(self, params, ctx)
+      end
+    end
+  end
+end
+
+Graphiti::Resource.send(:include, GraphitiGql::ActiveResource)

data/lib/graphiti_gql/engine.rb

@@ -9,9 +9,18 @@ module GraphitiGql
       GraphitiGql.schema!
     end
 
+    module ControllerContext
+      def graphql_context
+        ctx = { controller: self }
+        ctx[:current_user] = current_user if respond_to?(:current_user)
+        ctx
+      end
+    end
+
     initializer "graphiti_gql.define_controller" do
       require "#{Rails.root}/app/controllers/application_controller"
       app_controller = GraphitiGql.config.application_controller || ::ApplicationController
+      app_controller.send(:include, ControllerContext)
 
       # rubocop:disable Lint/ConstantDefinitionInBlock(Standard)
       class GraphitiGql::ExecutionController < app_controller
@@ -20,9 +29,15 @@ module GraphitiGql
           variables = params[:variables] || {}
           result = GraphitiGql.run params[:query],
             params[:variables],
-            { current_user: current_user }
+            graphql_context
           render json: result
         end
+
+        private
+
+        def default_context
+          defined?(:current_user)
+        end
       end
     end
   end

data/lib/graphiti_gql/graphiti_hax.rb

@@ -11,6 +11,27 @@ module GraphitiGql
       end
     end
 
+    def selections
+      return @selections if @selections
+      lookahead = context[:current_arguments]
+        .keyword_arguments[:lookahead]
+      nodes = lookahead.selection(:nodes)
+      if !nodes.selected?
+        nodes = lookahead
+          .selection(:edges)
+          .selection(:node)
+      end
+
+      if !nodes.selected?
+        nodes = lookahead
+      end
+
+      @selections = nodes
+        .selections
+        .map(&:name).map { |name| name.to_s.underscore.to_sym }
+      @selections
+    end
+
     class_methods do
       def attribute(*args)
         super(*args).tap do
@@ -159,7 +180,11 @@ module GraphitiGql
   end
 
   _in = definition.constructor do |input|
-    Time.zone.parse(input)
+    if input.is_a?(ActiveSupport::TimeWithZone)
+      input = input.utc.round(10).iso8601(6)
+    else
+      Time.zone.parse(input)
+    end
   end
 
   # Register it with Graphiti

data/lib/graphiti_gql/loaders/belongs_to.rb

@@ -53,7 +53,8 @@ module GraphitiGql
           end
         else
           params = {filter: {id: {eq: ids.join(",")}}}
-          records = @sideload.resource.class.all(params).data
+          resource = Schema.registry.get(@sideload.resource.class)[:resource]
+          records = resource.all(params).data
           map = records.index_by { |record| record.id }
           ids.each { |id| fulfill(id, map[id]) }
         end

data/lib/graphiti_gql/loaders/has_many.rb

@@ -1,12 +1,12 @@
 module GraphitiGql
   module Loaders
     class HasMany < Many
-      def assign(ids, proxy)
+      def assign(parent_records, proxy)
         records = proxy.data
         map = records.group_by { |record| record.send(@sideload.foreign_key) }
-        ids.each do |id|
-          data = [map[id] || [], proxy]
-          fulfill(id, data)
+        parent_records.each do |pr|
+          data = [map[pr.send(@sideload.primary_key)] || [], proxy]
+          fulfill(pr, data)
         end
       end
     end

data/lib/graphiti_gql/loaders/has_one.rb

@@ -0,0 +1,15 @@
+module GraphitiGql
+  module Loaders
+    class HasOne < Many
+      def assign(parent_records, proxy)
+        records = proxy.data
+        parent_records.each do |pr|
+          corresponding = records.find do |r|
+            r.send(@sideload.foreign_key) == pr.send(@sideload.primary_key)
+          end
+          fulfill(pr, corresponding)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti_gql/loaders/many.rb

@@ -6,6 +6,8 @@ module GraphitiGql
           PolymorphicHasMany.for(sideload, params)
         elsif sideload.type == :many_to_many
           ManyToMany.for(sideload, params)
+        elsif sideload.type == :has_one
+          HasOne.for(sideload, params)
         else
           HasMany.for(sideload, params)
         end
@@ -16,13 +18,26 @@ module GraphitiGql
         @params = params
       end
 
-      def perform(ids)
-        raise ::Graphiti::Errors::UnsupportedPagination if paginating? && ids.length > 1
-        raise Errors::UnsupportedStats if requesting_stats? && ids.length > 1 && !can_group?
+      def perform(parent_records)
+        raise ::Graphiti::Errors::UnsupportedPagination if paginating? && parent_records.length > 1
+        raise Errors::UnsupportedStats if requesting_stats? && parent_records.length > 1 && !can_group?
 
-        build_params(ids)
-        proxy = @sideload.resource.class.all(@params)
-        assign(ids, proxy)
+        ids = parent_records.map do |pr|
+          pk = pr.send(@sideload.primary_key)
+          if @sideload.polymorphic_as
+            hash = {}
+            hash[@sideload.foreign_key] = pk
+            hash[:"#{@sideload.polymorphic_as}_type"] = pr.class.name
+            hash
+          else
+            pk
+          end
+        end
+
+        build_params(ids, parent_records)
+        resource = Schema.registry.get(@sideload.resource.class)[:resource]
+        proxy = resource.all(@params)
+        assign(parent_records, proxy)
       end
 
       def assign(ids, proxy)
@@ -31,7 +46,7 @@ module GraphitiGql
 
       private
 
-      def build_params(ids)
+      def build_params(ids, parent_records)
         @params[:filter] ||= {}
 
         if @sideload.polymorphic_as
@@ -59,6 +74,10 @@ module GraphitiGql
           @params[:page] ||= {}
           @params[:page][:size] = 999
         end
+
+        if @sideload.params_proc
+          @sideload.params_proc.call(@params, parent_records)
+        end
       end
 
       def paginating?

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -1,16 +1,16 @@
 module GraphitiGql
   module Loaders
     class ManyToMany < Many
-      def assign(ids, proxy)
+      def assign(parent_records, proxy)
         thru = @sideload.foreign_key.keys.first
         fk = @sideload.foreign_key[thru]
         add_join_table_magic(proxy)
         records = proxy.data
-        ids.each do |id|
+        parent_records.each do |pr|
           corresponding = records.select do |record|
-            record.send(:"_edge_#{fk}") == id
+            record.send(:"_edge_#{fk}") == pr.send(@sideload.primary_key)
           end
-          fulfill(id, [corresponding, proxy])
+          fulfill(pr, [corresponding, proxy])
         end
       end
 

data/lib/graphiti_gql/loaders/polymorphic_has_many.rb

@@ -1,15 +1,18 @@
 module GraphitiGql
   module Loaders
     class PolymorphicHasMany < Many
-      def assign(ids, proxy)
+      def assign(parent_records, proxy)
         records = proxy.data
-        ids.each do |id|
+        parent_records.each do |pr|
           corresponding = records.select do |record|
-            record.send("#{@sideload.polymorphic_as}_type") == id[:"#{@sideload.polymorphic_as}_type"] &&
-              record.send(@sideload.foreign_key) == id[@sideload.foreign_key]
+            child_ft = record.send("#{@sideload.polymorphic_as}_type")
+            child_fk = record.send(@sideload.foreign_key)
+            parent_ft = pr.class.name
+            parent_fk = pr.send(@sideload.primary_key)
+            child_ft == parent_ft && child_fk == parent_fk
           end
           data = [corresponding || [], proxy]
-          fulfill(id, data)
+          fulfill(pr, data)
         end
       end
     end

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

@@ -29,7 +29,7 @@ module GraphitiGql
           name = Registry.instance.key_for(@resource)
           stat_graphql_name = "#{name}Stats"
           return Registry.instance[stat_graphql_name][:type] if Registry.instance[stat_graphql_name]
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
           klass.graphql_name(stat_graphql_name)
           @resource.stats.each_pair do |name, config|
             calc_class = build_calc_class(stat_graphql_name, name, config.calculations.keys)
@@ -41,7 +41,7 @@ module GraphitiGql
     
         def build_calc_class(stat_graphql_name, stat_name, calculations)
           name = "#{stat_graphql_name}#{stat_name}Calculations"
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
           klass.graphql_name(name)
           calculations.each do |calc|
             klass.field calc, Float, null: false

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

@@ -12,32 +12,31 @@ module GraphitiGql
         end
 
         def apply(type)
-          field = type.field @sideload.name,
-            @sideload_type.connection_type,
-            null: false,
+          opts = {
+            null: has_one?,
             connection: false,
-            extensions: [RelayConnectionExtension],
             extras: [:lookahead]
+          }
+          opts[:extensions] = [RelayConnectionExtension] unless has_one?
+          field_type = has_one? ? @sideload_type : @sideload_type.connection_type
+          field = type.field @sideload.name,
+            field_type,
+            **opts
           ListArguments.new(@sideload.resource.class, @sideload).apply(field)
           _sideload = @sideload
           type.define_method(@sideload.name) do |**arguments|
             Util.is_readable_sideload!(_sideload)
             params = Util.params_from_args(arguments)
-            pk = object.send(_sideload.primary_key)
-            id = if _sideload.polymorphic_as
-              hash = {}
-              hash[_sideload.foreign_key] = pk
-              hash[:"#{_sideload.polymorphic_as}_type"] = object.class.name
-              id = hash
-            else
-              id = pk
-            end
-            Loaders::Many.factory(_sideload, params).load(id)
+            Loaders::Many.factory(_sideload, params).load(object)
           end
         end
 
         private
 
+        def has_one?
+          @sideload.type == :has_one
+        end
+
         def customized_edge?
           @sideload.type == :many_to_many && @sideload.class.edge_resource
         end

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

@@ -19,7 +19,9 @@ module GraphitiGql
             if _sideload.type == :has_one
               id = object.send(_sideload.primary_key)
               params = { filter: { _sideload.foreign_key => { eq: id } } }
-              return _sideload.resource.class.all(params).data[0]
+
+              resource = Schema.registry.get(@sideload.resource.class)[:resource]
+              return resource.all(params).data[0]
             end
 
             lookahead = arguments[:lookahead]

data/lib/graphiti_gql/schema/query.rb

@@ -3,9 +3,8 @@ module GraphitiGql
     class Query
       def initialize(resources, existing_query: nil)
         @resources = resources
-        @query_class = Class.new(existing_query || ::GraphQL::Schema::Object)
+        @query_class = Class.new(existing_query || Schema.base_object)
         @query_class.graphql_name "Query"
-        @query_class.field_class ::GraphQL::Schema::Field
       end
 
       def build
@@ -32,7 +31,7 @@ module GraphitiGql
 
       def add_relationships
         each_relationship do |type, sideload_type, sideload|
-          if [:has_many, :many_to_many].include?(sideload.type)
+          if [:has_many, :many_to_many, :has_one].include?(sideload.type)
             Fields::ToMany.new(sideload, sideload_type).apply(type)
           else
             Fields::ToOne.new(sideload, sideload_type).apply(type)

data/lib/graphiti_gql/schema/resource_type.rb

@@ -68,7 +68,7 @@ module GraphitiGql
             Registry.instance[registry_name][:type]
           end
         else
-          klass = Class.new(GraphQL::Schema::Object)
+          klass = Class.new(Schema.base_object)
         end
 
         klass

data/lib/graphiti_gql/schema.rb

@@ -32,6 +32,21 @@ module GraphitiGql
       end
     end
 
+    def self.base_object
+      klass = Class.new(GraphQL::Schema::Object)
+      # TODO make this config maybe
+      if defined?(ActionView)
+        klass.send(:include, ActionView::Helpers::TranslationHelper)
+        klass.class_eval do
+          def initialize(*)
+            super
+            @virtual_path = "."
+          end
+        end
+      end
+      klass
+    end
+
     def self.registry
       Registry.instance
     end

data/lib/graphiti_gql/spec_helper.rb

@@ -2,149 +2,62 @@ module GraphitiGql
   module SpecHelper
     extend ActiveSupport::Concern
 
-    class Node < OpenStruct
-      def decoded_id
-        Base64.decode64(self.id)
-      end
-
-      def int_id
-        decoded_id.to_i
-      end
-    end
-
-    class Util
-      def self.underscore(hash)
-        hash.deep_transform_keys { |k| k.to_s.underscore.to_sym }
-      end
-    end
-
-    def query
-      name = Schema.registry.key_for(resource)
-      q = %|
-        query #{name} (
-          $filter: #{name}Filter,
-          $sort: [#{name}Sort!],
-          $first: Int,
-          $last: Int,
-          $before: String,
-          $after: String,
-        ) {
-          #{resource.graphql_entrypoint} (
-            filter: $filter,
-            sort: $sort,
-            first: $first,
-            last: $last,
-            before: $before,
-            after: $after,
-          ) {
-            edges {
-              node {|
-
-      fields.each do |name|
-        q << %|
-                #{name.to_s.camelize(:lower)}|
-      end
+    included do
+      extend Forwardable
+      def_delegators :result,
+        :page_info,
+        :errors,
+        :error_messages,
+        :nodes,
+        :stats
+
+      if defined?(RSpec)
+        let(:params) do
+          fields = []
+          resource.attributes.each_pair do |name, config|
+            (fields << name) if config[:readable]
+          end
+          { fields: fields }
+        end
+        let(:resource) { described_class }
+        let(:ctx) { {} }
 
-      q << %|
-              }
-            }
-            pageInfo {
-              startCursor
-              endCursor
-              hasNextPage
-              hasPreviousPage
-            }|
-  
-      if params[:stats]
-        q << %|
-            stats {|
-        params[:stats].each_pair do |name, calculations|
-          q << %|
-              #{name.to_s.camelize(:lower)} {|
-          Array(calculations).each do |calc|
-            q << %|
-                #{calc.to_s.camelize(:lower)}|
+        def self.only_fields(*fields)
+          before do
+            fields.each { |f| params[:fields].select! { |p| p == f } }
           end
-  
-          q << %|
-              }|
         end
-        q << %|
-            }|
-      end
-  
-      q << %|
-          }
-        }
-      |
-  
-      q
-    end
 
-    def run
-      lambda do
-        gql_params = params.deep_transform_keys { |key| key.to_s.camelize(:lower).to_sym }
-        (gql_params[:sort] || []).each do |sort|
-          sort[:att] = sort[:att].to_s.camelize(:lower)
-          sort[:dir] = sort[:dir].to_s
+        def self.except_fields(*fields)
+          before do
+            fields.each { |f| params[:fields].reject! { |p| p == f } }
+          end
         end
-        GraphitiGql.run(query, gql_params, ctx).deep_symbolize_keys
       end
     end
 
-    def run!
-      @response = run.call
-    end
-
-    def response
-      @response ||= run!
-    end
-
-    def errors
-      response[:errors]
-    end
-
-    def error_messages
-      response[:errors].map { |e| e[:message] }
-    end
-
-    def nodes
-      return [] unless data
-      nodes = edges.map { |e| Util.underscore(e[:node]) }
-      nodes.map { |n| ::GraphitiGql::SpecHelper::Node.new(n) }
-    end
-
-    def data
-      if response.key?(:data)
-        response[:data]
+    def gql_datetime(timestamp, precise = false)
+      if precise
+        timestamp.utc.round(10).iso8601(6)
       else
-        raise "Tried to access 'data', but these errors were returned instead: #{error_messages.join(". ")}."
+        DateTime.parse(timestamp.to_s).iso8601
       end
     end
 
-    def edges
-      data[data.keys.first][:edges]
-    end
-
-    def stats
-      Util.underscore(data[data.keys.first][:stats])
+    def run
+      lambda do
+        proxy = resource.gql(params, ctx)
+        proxy.to_h
+        proxy
+      end
     end
 
-    def page_info
-      Util.underscore(data[data.keys.first][:pageInfo])
+    def run!
+      @result = run.call
     end
 
-    included do
-      let(:params) { {} }
-      let(:resource) { described_class }
-      let(:ctx) { {} }
-      let(:fields) do
-        fields = []
-        resource.attributes.each_pair do |name, config|
-          (fields << name) if config[:readable]
-        end
-        fields
-      end
+    def result
+      @result ||= run!
     end
   end
 end

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.1"
+  VERSION = "0.2.4"
 end

data/lib/graphiti_gql.rb

@@ -9,6 +9,7 @@ require "graphiti_gql/loaders/has_many"
 require "graphiti_gql/loaders/many_to_many"
 require "graphiti_gql/loaders/polymorphic_has_many"
 require "graphiti_gql/loaders/belongs_to"
+require "graphiti_gql/loaders/has_one"
 require "graphiti_gql/response_shim"
 require "graphiti_gql/schema"
 require "graphiti_gql/schema/connection"
@@ -24,6 +25,7 @@ require "graphiti_gql/schema/fields/to_many"
 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/engine" if defined?(Rails)
 
 module GraphitiGql
@@ -64,6 +66,9 @@ module GraphitiGql
   end
 
   def self.run(query_string, variables = {}, context = {})
+    if context.empty? && Graphiti.context[:object]
+      context = Graphiti.context[:object]
+    end
     Graphiti.with_context(context) do
       result = schema.execute query_string,
         variables: variables,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.4
 platform: ruby
 authors:
 - Lee Richmond
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-23 00:00:00.000000000 Z
+date: 2022-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -108,7 +108,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
-description:
+description: 
 email:
 - richmolj@gmail.com
 executables: []
@@ -137,11 +137,13 @@ files:
 - config/routes.rb
 - graphiti_gql.gemspec
 - lib/graphiti_gql.rb
+- lib/graphiti_gql/active_resource.rb
 - lib/graphiti_gql/engine.rb
 - lib/graphiti_gql/errors.rb
 - lib/graphiti_gql/graphiti_hax.rb
 - lib/graphiti_gql/loaders/belongs_to.rb
 - lib/graphiti_gql/loaders/has_many.rb
+- lib/graphiti_gql/loaders/has_one.rb
 - lib/graphiti_gql/loaders/many.rb
 - lib/graphiti_gql/loaders/many_to_many.rb
 - lib/graphiti_gql/loaders/polymorphic_has_many.rb
@@ -167,7 +169,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://www.graphiti.dev
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -182,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: GraphQL support for Graphiti
 test_files: []