hq-graphql 2.0.10 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbfd2d5dad56008b05618a89354c42ced0ddac3ee44d292b96773303488171d8
-  data.tar.gz: 862fee899d0964af9177327b73ad7befcc200985f4f6323272ebb9d9122f5a5a
+  metadata.gz: 50ee2af7af4309a1fb549c15b88abdb8bda3454eacfdce5136f1997b814c52fb
+  data.tar.gz: 9dc0b893d4ad8bf8a999cba996224488be9c394e55f83ef979460ac19f96c381
 SHA512:
-  metadata.gz: d58e0f041362550a8aea5d3a0f03ca1ba0be02ad034b8c3def9d807f3c7045913c900ee79f3058bdf2d9396388d22a236b3ff6e368fb9d4758fcde60abb92ae5
-  data.tar.gz: 305b4e50bbb1f025aa2a977e45eba2aa63091b322396ac0bcfb2ce3be3f9ba28dd166097fe594982bc705dc701220d4b5b924721eee1ed65bc18387a3c2529ac
+  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
@@ -32,14 +36,20 @@ module HQ
       config.extract_class.call(klass)
     end
 
-    def self.resource_lookup(klass)
-      config.resource_lookup.call(klass)
+    def self.lookup_resource(klass)
+      [klass, klass.base_class, klass.superclass].lazy.map do |k|
+        config.resource_lookup.call(k) || resources.detect { |r| r.model_klass == k }
+      end.reject(&:nil?).first
+    end
+
+    def self.use_experimental_associations?
+      !!config.use_experimental_associations
     end
 
     def self.reset!
       @root_queries = nil
       @enums = nil
-      @types = nil
+      @resources = nil
       ::HQ::GraphQL::Inputs.reset!
       ::HQ::GraphQL::Types.reset!
     end
@@ -52,21 +62,21 @@ module HQ
       @enums ||= Set.new
     end
 
-    def self.types
-      @types ||= Set.new
+    def self.resources
+      @resources ||= Set.new
     end
   end
 end
 
-require "hq/graphql/active_record_extensions"
+require "hq/graphql/association_loader"
 require "hq/graphql/scalars"
 require "hq/graphql/comparator"
 require "hq/graphql/enum"
 require "hq/graphql/inputs"
 require "hq/graphql/input_object"
-require "hq/graphql/loaders"
 require "hq/graphql/mutation"
 require "hq/graphql/object"
+require "hq/graphql/paginated_association_loader"
 require "hq/graphql/resource"
 require "hq/graphql/root_mutation"
 require "hq/graphql/root_query"

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    class AssociationLoader < ::GraphQL::Batch::Loader
+      def initialize(model, association_name)
+        @model = model
+        @association_name = association_name
+        validate
+      end
+
+      def load(record)
+        raise TypeError, "#{@model} loader can't load association for #{record.class}" unless record.is_a?(@model)
+        return Promise.resolve(read_association(record)) if association_loaded?(record)
+        super
+      end
+
+      # We want to load the associations on all records, even if they have the same id
+      def cache_key(record)
+        record.object_id
+      end
+
+      def perform(records)
+        preload_association(records)
+        records.each { |record| fulfill(record, read_association(record)) }
+      end
+
+      private
+
+      def validate
+        unless @model.reflect_on_association(@association_name)
+          raise ArgumentError, "No association #{@association_name} on #{@model}"
+        end
+      end
+
+      def preload_association(records)
+        ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
+      end
+
+      def read_association(record)
+        record.public_send(@association_name)
+      end
+
+      def association_loaded?(record)
+        record.association(@association_name).loaded?
+      end
+    end
+  end
+end

data/lib/hq/graphql/config.rb

@@ -5,9 +5,11 @@ module HQ
     class Config < Struct.new(
       :authorize,
       :authorize_field,
+      :default_object_class,
       :default_scope,
       :extract_class,
       :resource_lookup,
+      :use_experimental_associations,
       keyword_init: true
     )
       def initialize(

data/lib/hq/graphql/enum.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "hq/graphql/types"
+
 module HQ::GraphQL
   class Enum < ::GraphQL::Schema::Enum
     ## Auto generate enums from the database using ActiveRecord

data/lib/hq/graphql/enum/sort_by.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hq/graphql/enum"
+
+module HQ
+  class GraphQL::Enum::SortBy < ::HQ::GraphQL::Enum
+    value "CreatedAt", value: :created_at
+    value "UpdatedAt", value: :updated_at
+  end
+end

data/lib/hq/graphql/enum/sort_order.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "hq/graphql/enum"
+
+module HQ
+  class GraphQL::Enum::SortOrder < ::HQ::GraphQL::Enum
+    value "ASC", value: :asc
+    value "DESC", value: :desc
+  end
+end

data/lib/hq/graphql/field.rb

@@ -3,13 +3,21 @@
 module HQ
   module GraphQL
     class Field < ::GraphQL::Schema::Field
-      attr_reader :authorize_action, :authorize, :klass
+      attr_reader :authorize_action, :authorize
 
       def initialize(*args, authorize_action: :read, authorize: nil, klass: nil, **options, &block)
         super(*args, **options, &block)
         @authorize_action = authorize_action
         @authorize = authorize
-        @klass = klass
+        @klass_or_string = klass
+      end
+
+      def scope(&block)
+        if block
+          @scope = block
+        else
+          @scope
+        end
       end
 
       def authorized?(object, ctx)
@@ -18,14 +26,8 @@ module HQ
           ::HQ::GraphQL.authorize_field(authorize_action, self, object, ctx)
       end
 
-      def resolve_field(object, args, ctx)
-        if klass.present? && !!::GraphQL::Batch::Executor.current && object.object
-          Loaders::Association.for(klass.constantize, original_name).load(object.object).then do
-            super
-          end
-        else
-          super
-        end
+      def klass
+        @klass ||= @klass_or_string.is_a?(String) ? @klass_or_string.constantize : @klass_or_string
       end
     end
   end

data/lib/hq/graphql/field_extension/association_loader_extension.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "hq/graphql/association_loader"
+
+module HQ
+  module GraphQL
+    module FieldExtension
+      class AssociationLoaderExtension < ::GraphQL::Schema::FieldExtension
+        def resolve(object:, **_kwargs)
+          AssociationLoader.for(options[:klass], field.original_name).load(object.object)
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/field_extension/paginated_arguments.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "hq/graphql/enum/sort_by"
+require "hq/graphql/enum/sort_order"
+
+module HQ
+  module GraphQL
+    module FieldExtension
+      class PaginatedArguments < ::GraphQL::Schema::FieldExtension
+        def apply
+          field.argument :offset, Integer, required: false
+          field.argument :limit, Integer, required: false
+          field.argument :sort_order, Enum::SortOrder, required: false
+
+          resource = ::HQ::GraphQL.lookup_resource(options[:klass])
+          enum = resource ? resource.sort_fields_enum : ::HQ::GraphQL::Enum::SortBy
+          field.argument :sort_by, enum, required: false
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/field_extension/paginated_loader.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "hq/graphql/paginated_association_loader"
+
+module HQ
+  module GraphQL
+    module FieldExtension
+      class PaginatedLoader < ::GraphQL::Schema::FieldExtension
+        def resolve(object:, arguments:, **_options)
+          limit       = arguments[:limit]
+          offset      = arguments[:offset]
+          sort_by     = arguments[:sort_by]
+          sort_order  = arguments[:sort_order]
+          scope       = field.scope.call(**arguments.except(:limit, :offset, :sort_by, :sort_order)) if field.scope
+          loader      = PaginatedAssociationLoader.for(
+            klass,
+            association,
+            internal_association: internal_association,
+            scope:                scope,
+            limit:                limit,
+            offset:               offset,
+            sort_by:              sort_by,
+            sort_order:           sort_order
+          )
+
+          loader.load(object.object)
+        end
+
+        private
+
+        def association
+          options[:association]
+        end
+
+        def internal_association
+          options[:internal_association]
+        end
+
+        def klass
+          options[:klass]
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/input_object.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "hq/graphql/active_record_extensions"
+require "hq/graphql/inputs"
+require "hq/graphql/types"
+
 module HQ
   module GraphQL
     class InputObject < ::GraphQL::Schema::InputObject

data/lib/hq/graphql/inputs.rb

@@ -24,14 +24,10 @@ module HQ
 
         def klass_for(klass_or_string)
           klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
-          type = find_type(klass)
+          resource = ::HQ::GraphQL.lookup_resource(klass)
 
-          raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name }) if !type
-          type.input_klass
-        end
-
-        def find_type(klass)
-          ::HQ::GraphQL.resource_lookup(klass) || ::HQ::GraphQL.types.detect { |t| t.model_klass == klass }
+          raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name }) if !resource
+          resource.input_klass
         end
       end
     end

data/lib/hq/graphql/object.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
+require "hq/graphql/active_record_extensions"
+require "hq/graphql/field"
+require "hq/graphql/field_extension/association_loader_extension"
+require "hq/graphql/field_extension/paginated_arguments"
+require "hq/graphql/field_extension/paginated_loader"
+require "hq/graphql/object_association"
+require "hq/graphql/types"
+
 module HQ
   module GraphQL
     class Object < ::GraphQL::Schema::Object
       include Scalars
-      include ::HQ::GraphQL::ActiveRecordExtensions
+      include ActiveRecordExtensions
+      extend ObjectAssociation
 
-      field_class ::HQ::GraphQL::Field
+      field_class Field
 
       def self.authorize_action(action)
         self.authorized_action = action
@@ -28,8 +37,15 @@ module HQ
           end
 
           model_associations.each do |association|
+            next if resource_reflections[association.name.to_s]
             field_from_association(association, auto_nil: auto_nil)
           end
+
+          resource_reflections.values.each do |resource_reflection|
+            reflection = resource_reflection.reflection(model_klass)
+            next unless reflection
+            field_from_association(reflection, auto_nil: auto_nil, internal_association: true, &resource_reflection.block)
+          end
         end
       end
 
@@ -46,21 +62,33 @@ module HQ
           @authorized_action ||= :read
         end
 
-        def field_from_association(association, auto_nil:)
-          type = ::HQ::GraphQL::Types[association.klass]
-          name = association.name
+        def field_from_association(association, auto_nil:, internal_association: false, &block)
+          association_klass = association.klass
+          name              = association.name
+          klass             = model_klass
+          type              = Types[association_klass]
           case association.macro
           when :has_many
-            field name, [type], null: false, klass: model_name
+            field name, [type], null: false, klass: model_name do
+              if ::HQ::GraphQL.use_experimental_associations?
+                extension FieldExtension::PaginatedArguments, klass: association_klass
+                extension FieldExtension::PaginatedLoader, klass: klass, association: name, internal_association: internal_association
+              else
+                extension FieldExtension::AssociationLoaderExtension, klass: klass
+              end
+              instance_eval(&block) if block
+            end
           else
-            field name, type, null: !auto_nil || !association_required?(association), klass: model_name
+            field name, type, null: !auto_nil || !association_required?(association), klass: model_name do
+              extension FieldExtension::AssociationLoaderExtension, klass: klass
+            end
           end
-        rescue ::HQ::GraphQL::Types::Error
+        rescue Types::Error
           nil
         end
 
         def field_from_column(column, auto_nil:)
-          field column.name, ::HQ::GraphQL::Types.type_from_column(column), null: !auto_nil || column.null
+          field column.name, Types.type_from_column(column), null: !auto_nil || column.null
         end
 
         def association_required?(association)

data/lib/hq/graphql/object_association.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+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
+
+        def initialize(name, scope, options, macro, block)
+          @name = name
+          @scope = scope
+          @options = options
+          @macro = macro
+          @block = block
+        end
+
+        def reflection(model_klass)
+          if macro == :has_many
+            ::ActiveRecord::Associations::Builder::HasMany.create_reflection(model_klass, name, scope, options)
+          elsif macro == :belongs_to
+            ::ActiveRecord::Associations::Builder::BelongsTo.create_reflection(model_klass, name, scope, options)
+          end
+        end
+      end
+
+      class UpdatedReflection
+        attr_reader :name, :block
+
+        def initialize(name, block)
+          @name = name
+          @block = block
+        end
+
+        def reflection(model_klass)
+          model_klass.reflect_on_association(name)
+        end
+      end
+    end
+  end
+end