hq-graphql 2.1.2 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8851537c95e46beea01cd929ec57a5c29a0649eeb059e7f35b5bef1fe71f6da3
-  data.tar.gz: 31008afafa861554a0327285681191a4107c83faf7d3c790f402fe88056d2ca6
+  metadata.gz: 50ee2af7af4309a1fb549c15b88abdb8bda3454eacfdce5136f1997b814c52fb
+  data.tar.gz: 9dc0b893d4ad8bf8a999cba996224488be9c394e55f83ef979460ac19f96c381
 SHA512:
-  metadata.gz: f63e936bed969d901e14265ac4fe284d4ef18838cf27c6f4c5a2575d6b0c07e3e4d533e0ea2e8a402777351b98b3d2c0fd07b021781bfb9e618518a0b60d7988
-  data.tar.gz: 76b08ade067128ab0a4d96449751481413c8a6e714ae9d69c73817a5692468dee0f279d3c13456f504f145ee6f713418714b258b23540193eed48b4d0278e3e8
+  metadata.gz: f4940761bdccfd01c867e21f69ab66a5459d8b151024ebd79679906ea62fa6c5d2208ce311a339ed720021c2b43221e51ebb092de8f4bff87a15bc3e3f07f376
+  data.tar.gz: 00a7683630411f065d954132918b3449ef6aec9419de30702dd43bf99ad34fb8dbaf5ee1ae248759f3029006db3863257fe86a99d7b89a7456123c82d52ef7b3

data/lib/hq/graphql.rb

@@ -8,6 +8,10 @@ require "hq/graphql/config"
 
 module HQ
   module GraphQL
+    class << self
+      delegate :default_object_class, to: :config
+    end
+
     def self.config
       @config ||= ::HQ::GraphQL::Config.new
     end

data/lib/hq/graphql/active_record_extensions.rb

@@ -27,7 +27,7 @@ module HQ
         end
 
         def lazy_load!
-          lazy_load.map(&:call)
+          lazy_load.each(&:call)
           @lazy_load = []
         end
 

data/lib/hq/graphql/config.rb

@@ -5,6 +5,7 @@ module HQ
     class Config < Struct.new(
       :authorize,
       :authorize_field,
+      :default_object_class,
       :default_scope,
       :extract_class,
       :resource_lookup,

data/lib/hq/graphql/object.rb

@@ -63,9 +63,6 @@ module HQ
         end
 
         def field_from_association(association, auto_nil:, internal_association: false, &block)
-          # The PaginationAssociationLoader doesn't support through associations yet
-          return if association.through_reflection? && ::HQ::GraphQL.use_experimental_associations?
-
           association_klass = association.klass
           name              = association.name
           klass             = model_klass

data/lib/hq/graphql/object_association.rb

@@ -3,6 +3,33 @@
 module HQ
   module GraphQL
     module ObjectAssociation
+      def reflect_on_association(association)
+        resource_reflections[association.to_s]&.reflection(model_klass)
+      end
+
+      def update(name, &block)
+        resource_reflections[name.to_s] = UpdatedReflection.new(name, block)
+      end
+
+      def belongs_to(name, scope = nil, **options, &block)
+        add_reflection(name, scope, options, :belongs_to, block)
+      end
+
+      def has_many(name, scope = nil, through: nil, **options, &block)
+        raise TypeError, "has_many through is unsupported" if through
+        add_reflection(name, scope, options, :has_many, block)
+      end
+
+      private
+
+      def resource_reflections
+        @resource_reflections ||= {}
+      end
+
+      def add_reflection(name, scope, options, macro, block)
+        resource_reflections[name.to_s] = ResourceReflection.new(name, scope, options, macro, block)
+      end
+
       class ResourceReflection
         attr_reader :name, :scope, :options, :macro, :block
 
@@ -23,27 +50,17 @@ module HQ
         end
       end
 
-      def reflect_on_association(association)
-        resource_reflections[association.to_s]&.reflection(model_klass)
-      end
-
-      def belongs_to(name, scope = nil, **options, &block)
-        add_reflection(name, scope, options, :belongs_to, block)
-      end
-
-      def has_many(name, scope = nil, through: nil, **options, &block)
-        raise TypeError, "has_many through is unsupported" if through
-        add_reflection(name, scope, options, :has_many, block)
-      end
+      class UpdatedReflection
+        attr_reader :name, :block
 
-      private
-
-      def resource_reflections
-        @resource_reflections ||= {}
-      end
+        def initialize(name, block)
+          @name = name
+          @block = block
+        end
 
-      def add_reflection(name, scope, options, macro, block)
-        resource_reflections[name.to_s] = ResourceReflection.new(name, scope, options, macro, block)
+        def reflection(model_klass)
+          model_klass.reflect_on_association(name)
+        end
       end
     end
   end

data/lib/hq/graphql/paginated_association_loader.rb

@@ -39,7 +39,8 @@ module HQ
       end
 
       def perform(records)
-        scope =
+        values = records.map { |r| source_value(r) }
+        scope  =
           if @limit || @offset
             # If a limit or offset is added, then we need to transform the query
             # into a lateral join so that we can limit on groups of data.
@@ -57,53 +58,71 @@ module HQ
             # > ) a_top ON TRUE
             # > WHERE addresses.user_id IN ($1, $2, ..., $N)
             # > ORDER BY a_top.created_at DESC
-            inner_table       = association_class.arel_table
-            association_table = inner_table.alias("outer")
+            inner_table        = association_class.arel_table
+            lateral_join_table = through_reflection? ? through_association.klass.arel_table : inner_table
+            from_table         = lateral_join_table.alias("outer")
 
             inside_scope = default_scope.
               select(inner_table[::Arel.star]).
               from(inner_table).
-              where(inner_table[association_key].eq(association_table[association_key])).
+              where(lateral_join_table[target_join_key].eq(from_table[target_join_key])).
               reorder(arel_order(inner_table)).
               limit(@limit).
               offset(@offset)
 
-            outside_table = ::Arel::Table.new("top")
+            if through_reflection?
+              # expose the through_reflection key
+              inside_scope = inside_scope.select(lateral_join_table[target_join_key])
+            end
+
+            lateral_table = ::Arel::Table.new("top")
             association_class.
-              select(outside_table[::Arel.star]).distinct.
-              from(association_table).
-              joins("INNER JOIN LATERAL (#{inside_scope.to_sql}) #{outside_table.name} ON TRUE").
-              where(association_table[association_key].in(records.map { |r| join_value(r) })).
-              reorder(arel_order(outside_table))
+              select(lateral_table[::Arel.star]).distinct.
+              from(from_table).
+              where(from_table[target_join_key].in(values)).
+              joins("INNER JOIN LATERAL (#{inside_scope.to_sql}) #{lateral_table.name} ON TRUE").
+              reorder(arel_order(lateral_table))
           else
-            default_scope.
-              reorder(arel_order(association_class.arel_table)).
-              where(association_key => records.map { |r| join_value(r) })
+            scope = default_scope.reorder(arel_order(association_class.arel_table))
+
+            if through_reflection?
+              scope.where(through_association.name => { target_join_key => values }).
+                # expose the through_reflection key
+                select(association_class.arel_table[::Arel.star], through_association.klass.arel_table[target_join_key])
+            else
+              scope.where(target_join_key => values)
+            end
           end
 
         results = scope.to_a
         records.each do |record|
-          fulfill(record, association_value(record, results)) unless fulfilled?(record)
+          fulfill(record, target_value(record, results)) unless fulfilled?(record)
         end
       end
 
       private
 
-      def association_key
-        belongs_to? ? association.association_primary_key : association.foreign_key
+      def source_join_key
+        belongs_to? ? association.foreign_key : association.association_primary_key
       end
 
-      def association_value(record, results)
-        enumerator = has_many? ? :select : :detect
-        results.send(enumerator) { |r| r.send(association_key) == join_value(record) }
+      def source_value(record)
+        record.send(source_join_key)
       end
 
-      def join_key
-        belongs_to? ? association.foreign_key : association.association_primary_key
+      def target_join_key
+        if through_reflection?
+          through_association.foreign_key
+        elsif belongs_to?
+          association.association_primary_key
+        else
+          association.foreign_key
+        end
       end
 
-      def join_value(record)
-        record.send(join_key)
+      def target_value(record, results)
+        enumerator = has_many? ? :select : :detect
+        results.send(enumerator) { |r| r.send(target_join_key) == source_value(record) }
       end
 
       def default_scope
@@ -111,6 +130,14 @@ module HQ
         scope = association.scopes.reduce(scope, &:merge)
         scope = association_class.default_scopes.reduce(scope, &:merge)
         scope = scope.merge(@scope) if @scope
+
+        if through_reflection?
+          source = association_class.arel_table
+          target = through_association.klass.arel_table
+          join   = source.join(target).on(target[association.foreign_key].eq(source[source_join_key]))
+          scope  = scope.joins(join.join_sources)
+        end
+
         scope
       end
 
@@ -122,6 +149,14 @@ module HQ
         association.macro == :has_many
       end
 
+      def through_association
+        association.through_reflection
+      end
+
+      def through_reflection?
+        association.through_reflection?
+      end
+
       def association
         if @internal_association
           Types[@model].reflect_on_association(@association_name)

data/lib/hq/graphql/resource.rb

@@ -59,12 +59,20 @@ module HQ
           @input_klass ||= build_input_object
         end
 
-        def nil_query_klass
-          @nil_query_klass ||= build_graphql_object(name: "#{graphql_name}Copy", auto_nil: false)
-        end
-
-        def query_klass
-          @query_klass ||= build_graphql_object
+        def nil_query_object
+          @nil_query_object ||= build_graphql_object(name: "#{graphql_name}Copy", auto_nil: false)
+        end
+
+        def query_object
+          @query_object ||= begin
+            if @query_object_options
+              options, block = @query_object_options
+              @query_object_options = nil
+              build_graphql_object(**options, &block)
+            else
+              build_graphql_object
+            end
+          end
         end
 
         def sort_fields_enum
@@ -89,7 +97,11 @@ module HQ
         end
 
         def query(**options, &block)
-          @query_klass = build_graphql_object(**options, &block)
+          @query_object_options = [options, block]
+        end
+
+        def query_class(klass)
+          @query_class = klass
         end
 
         def sort_fields(*fields)
@@ -100,7 +112,7 @@ module HQ
           resource = self
           resolver = -> {
             Class.new(::GraphQL::Schema::Resolver) do
-              type = is_array ? [resource.query_klass] : resource.query_klass
+              type = is_array ? [resource.query_object] : resource.query_object
               type type, null: null
               class_eval(&block) if block
             end
@@ -156,7 +168,8 @@ module HQ
         def build_graphql_object(name: graphql_name, **options, &block)
           scoped_graphql_name = name
           scoped_model_name = model_name
-          Class.new(::HQ::GraphQL::Object) do
+          object_class = @query_class || ::HQ::GraphQL.default_object_class || ::HQ::GraphQL::Object
+          Class.new(object_class) do
             graphql_name scoped_graphql_name
 
             with_model scoped_model_name, **options

data/lib/hq/graphql/types.rb

@@ -13,7 +13,7 @@ module HQ
       def self.registry
         @registry ||= Hash.new do |hash, options|
           klass, nil_klass = Array(options)
-          hash[klass] = nil_klass ? nil_query_klass(klass) : klass_for(klass)
+          hash[options] = nil_klass ? nil_query_object(klass) : klass_for(klass)
         end
       end
 
@@ -61,12 +61,12 @@ module HQ
       class << self
         private
 
-        def nil_query_klass(klass_or_string)
-          find_klass(klass_or_string, :nil_query_klass)
+        def nil_query_object(klass_or_string)
+          find_klass(klass_or_string, :nil_query_object)
         end
 
         def klass_for(klass_or_string)
-          find_klass(klass_or_string, :query_klass)
+          find_klass(klass_or_string, :query_object)
         end
 
         def find_klass(klass_or_string, method)

data/lib/hq/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module HQ
   module GraphQL
-    VERSION = "2.1.2"
+    VERSION = "2.1.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hq-graphql
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.1.3
 platform: ruby
 authors:
 - Danny Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-23 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails