hq-graphql 2.0.9 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf94ca5592ce063239e928dbfb76d339c44762c3c89efe709cbbee157228a1d5
-  data.tar.gz: 8a5b48518fd85b87917d81dc10b75be7031552b010216ff956e3d7e9fefada0c
+  metadata.gz: 8851537c95e46beea01cd929ec57a5c29a0649eeb059e7f35b5bef1fe71f6da3
+  data.tar.gz: 31008afafa861554a0327285681191a4107c83faf7d3c790f402fe88056d2ca6
 SHA512:
-  metadata.gz: 2a742fb51ad7ac2c4fa2f44c02b144a97e7e87fb9bb93c58035a23420c89550bfc895f376d372b71ee1445fdf8db91bf38e16eae8d7cea3c91dfeda9e5a2f69d
-  data.tar.gz: d17914db4d42d8b480917d3b720220cbdcad9d5d5a88f47d1e4b7c0b1f1d8db69138560e5838be40047f42a003bb82d56c07ede142da433b541048fba1d5dc56
+  metadata.gz: f63e936bed969d901e14265ac4fe284d4ef18838cf27c6f4c5a2575d6b0c07e3e4d533e0ea2e8a402777351b98b3d2c0fd07b021781bfb9e618518a0b60d7988
+  data.tar.gz: 76b08ade067128ab0a4d96449751481413c8a6e714ae9d69c73817a5692468dee0f279d3c13456f504f145ee6f713418714b258b23540193eed48b4d0278e3e8

data/lib/hq/graphql.rb

@@ -28,14 +28,24 @@ module HQ
       config.default_scope.call(scope, context)
     end
 
-    def self.resource_lookup(klass)
-      config.resource_lookup.call(klass)
+    def self.extract_class(klass)
+      config.extract_class.call(klass)
+    end
+
+    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
@@ -48,21 +58,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/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

@@ -2,10 +2,19 @@
 
 module HQ
   module GraphQL
-    class Config < Struct.new(:authorize, :authorize_field, :default_scope, :resource_lookup, keyword_init: true)
+    class Config < Struct.new(
+      :authorize,
+      :authorize_field,
+      :default_scope,
+      :extract_class,
+      :resource_lookup,
+      :use_experimental_associations,
+      keyword_init: true
+    )
       def initialize(
         default_scope: ->(scope, _context) { scope },
-        resource_lookup: ->(klass) { "::Resources::#{klass}".safe_constantize },
+        extract_class: ->(klass) { klass.to_s.gsub(/^Resources|Resource$/, "") },
+        resource_lookup: ->(klass) { "::Resources::#{klass}Resource".safe_constantize || "::Resources::#{klass}".safe_constantize },
         **options
       )
         super

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,36 @@ 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)
+          # 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
+          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,50 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    module ObjectAssociation
+      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
+
+      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
+
+      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
+    end
+  end
+end

data/lib/hq/graphql/paginated_association_loader.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "hq/graphql/types"
+
+module HQ
+  module GraphQL
+    class PaginatedAssociationLoader < ::GraphQL::Batch::Loader
+      def self.for(*args, scope: nil, **kwargs)
+        if scope
+          raise TypeError, "scope must be an ActiveRecord::Relation" unless scope.is_a?(::ActiveRecord::Relation)
+          executor = ::GraphQL::Batch::Executor.current
+          loader_key = loader_key_for(*args, **kwargs, scope: scope.to_sql)
+          executor.loader(loader_key) { new(*args, **kwargs, scope: scope) }
+        else
+          super
+        end
+      end
+
+      def initialize(model, association_name, internal_association: false, limit: nil, offset: nil, scope: nil, sort_by: nil, sort_order: nil)
+        @model                = model
+        @association_name     = association_name
+        @internal_association = internal_association
+        @limit                = [0, limit].max if limit
+        @offset               = [0, offset].max if offset
+        @scope                = scope
+        @sort_by              = sort_by || :updated_at
+        @sort_order           = normalize_sort_order(sort_order)
+
+        validate!
+      end
+
+      def load(record)
+        raise TypeError, "#{@model} loader can't load association for #{record.class}" unless record.is_a?(@model)
+        super
+      end
+
+      def cache_key(record)
+        record.send(primary_key)
+      end
+
+      def perform(records)
+        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.
+            #
+            # > SELECT * FROM addresses WHERE addresses.user_id IN ($1, $2, ..., $N) ORDER BY addresses.created_at DESC;
+            # ...becomes
+            # > SELECT DISTINCT a_top.*
+            # > FROM addresses
+            # > INNER JOIN LATERAL (
+            # >   SELECT inner.*
+            # >   FROM addresses inner
+            # >   WHERE inner.user_id = addresses.user_id
+            # >   ORDER BY inner.created_at DESC
+            # >   LIMIT 1
+            # > ) 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")
+
+            inside_scope = default_scope.
+              select(inner_table[::Arel.star]).
+              from(inner_table).
+              where(inner_table[association_key].eq(association_table[association_key])).
+              reorder(arel_order(inner_table)).
+              limit(@limit).
+              offset(@offset)
+
+            outside_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))
+          else
+            default_scope.
+              reorder(arel_order(association_class.arel_table)).
+              where(association_key => records.map { |r| join_value(r) })
+          end
+
+        results = scope.to_a
+        records.each do |record|
+          fulfill(record, association_value(record, results)) unless fulfilled?(record)
+        end
+      end
+
+      private
+
+      def association_key
+        belongs_to? ? association.association_primary_key : association.foreign_key
+      end
+
+      def association_value(record, results)
+        enumerator = has_many? ? :select : :detect
+        results.send(enumerator) { |r| r.send(association_key) == join_value(record) }
+      end
+
+      def join_key
+        belongs_to? ? association.foreign_key : association.association_primary_key
+      end
+
+      def join_value(record)
+        record.send(join_key)
+      end
+
+      def default_scope
+        scope = association_class
+        scope = association.scopes.reduce(scope, &:merge)
+        scope = association_class.default_scopes.reduce(scope, &:merge)
+        scope = scope.merge(@scope) if @scope
+        scope
+      end
+
+      def belongs_to?
+        association.macro == :belongs_to
+      end
+
+      def has_many?
+        association.macro == :has_many
+      end
+
+      def association
+        if @internal_association
+          Types[@model].reflect_on_association(@association_name)
+        else
+          @model.reflect_on_association(@association_name)
+        end
+      end
+
+      def association_class
+        association.klass
+      end
+
+      def primary_key
+        @model.primary_key
+      end
+
+      def arel_order(table)
+        table[@sort_by].send(@sort_order)
+      end
+
+      def normalize_sort_order(input)
+        if input.to_s.casecmp("asc").zero?
+          :asc
+        else
+          :desc
+        end
+      end
+
+      def validate!
+        raise ArgumentError, "No association #{@association_name} on #{@model}" unless association
+      end
+    end
+  end
+end

data/lib/hq/graphql/resource.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
-require "hq/graphql/resource/mutation"
+require "hq/graphql/enum/sort_by"
+require "hq/graphql/field_extension/paginated_arguments"
+require "hq/graphql/input_object"
+require "hq/graphql/object"
+require "hq/graphql/resource/auto_mutation"
+require "hq/graphql/scalars"
 
 module HQ
   module GraphQL
     module Resource
       def self.included(base)
         super
-        ::HQ::GraphQL.types << base
+        ::HQ::GraphQL.resources << base
         base.include Scalars
         base.include ::GraphQL::Types
         base.extend ClassMethods
       end
 
       module ClassMethods
+        include AutoMutation
+
         attr_writer :graphql_name, :model_name
 
         def scope(context)
@@ -37,7 +44,7 @@ module HQ
         end
 
         def model_name
-          @model_name || name.demodulize
+          @model_name || ::HQ::GraphQL.extract_class(self)
         end
 
         def model_klass
@@ -60,6 +67,10 @@ module HQ
           @query_klass ||= build_graphql_object
         end
 
+        def sort_fields_enum
+          @sort_fields_enum || ::HQ::GraphQL::Enum::SortBy
+        end
+
         protected
 
         def default_scope(&block)
@@ -71,155 +82,25 @@ module HQ
         end
 
         def mutations(create: true, copy: true, update: true, destroy: true)
-          scoped_graphql_name = graphql_name
-          scoped_model_name = model_name
-          scoped_self = self
-
-          if create
-            create_mutation = ::HQ::GraphQL::Resource::Mutation.build(model_name, action: :create, graphql_name: "#{scoped_graphql_name}Create") do
-              define_method(:resolve) do |**args|
-                resource = scoped_self.new_record(context)
-                resource.assign_attributes(args[:attributes].format_nested_attributes)
-                if resource.save
-                  {
-                    resource: resource,
-                    errors: {},
-                  }
-                else
-                  {
-                    resource: nil,
-                    errors: errors_from_resource(resource)
-                  }
-                end
-              end
-
-              lazy_load do
-                argument :attributes, ::HQ::GraphQL::Inputs[scoped_model_name], required: true
-              end
-            end
-
-            mutation_klasses["create_#{scoped_graphql_name.underscore}"] = create_mutation
-          end
-
-          if copy
-            copy_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :copy,
-              graphql_name: "#{scoped_graphql_name}Copy",
-              require_primary_key: true,
-              nil_klass: true
-            ) do
-              define_method(:resolve) do |**args|
-                resource = scoped_self.find_record(args, context)
-
-                if resource
-                  copy = resource.copy
-                  if copy.save
-                    {
-                      resource: copy,
-                      errors: {},
-                    }
-                  else
-                    {
-                      resource: copy,
-                      errors: errors_from_resource(copy)
-                    }
-                  end
-                else
-                  {
-                    resource: nil,
-                    errors: { resource: "Unable to find #{scoped_graphql_name}" }
-                  }
-                end
-              end
-            end
-
-            mutation_klasses["copy_#{scoped_graphql_name.underscore}"] = copy_mutation
-          end
-
-          if update
-            update_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :update,
-              graphql_name: "#{scoped_graphql_name}Update",
-              require_primary_key: true
-            ) do
-              define_method(:resolve) do |**args|
-                resource = scoped_self.find_record(args, context)
-
-                if resource
-                  resource.assign_attributes(args[:attributes].format_nested_attributes)
-                  if resource.save
-                    {
-                      resource: resource,
-                      errors: {},
-                    }
-                  else
-                    {
-                      resource: nil,
-                      errors: errors_from_resource(resource)
-                    }
-                  end
-                else
-                  {
-                    resource: nil,
-                    errors: { resource: "Unable to find #{scoped_graphql_name}" }
-                  }
-                end
-              end
-
-              lazy_load do
-                argument :attributes, ::HQ::GraphQL::Inputs[scoped_model_name], required: true
-              end
-            end
-
-            mutation_klasses["update_#{scoped_graphql_name.underscore}"] = update_mutation
-          end
-
-          if destroy
-            destroy_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :destroy,
-              graphql_name: "#{scoped_graphql_name}Destroy",
-              require_primary_key: true
-            ) do
-              define_method(:resolve) do |**attrs|
-                resource = scoped_self.find_record(attrs, context)
-
-                if resource
-                  if resource.destroy
-                    {
-                      resource: resource,
-                      errors: {},
-                    }
-                  else
-                    {
-                      resource: nil,
-                      errors: errors_from_resource(resource)
-                    }
-                  end
-                else
-                  {
-                    resource: nil,
-                    errors: { resource: "Unable to find #{scoped_graphql_name}" }
-                  }
-                end
-              end
-            end
-
-            mutation_klasses["destroy_#{scoped_graphql_name.underscore}"] = destroy_mutation
-          end
+          mutation_klasses["create_#{graphql_name.underscore}"] = build_create if create
+          mutation_klasses["copy_#{graphql_name.underscore}"] = build_copy if copy
+          mutation_klasses["update_#{graphql_name.underscore}"] = build_update if update
+          mutation_klasses["destroy_#{graphql_name.underscore}"] = build_destroy if destroy
         end
 
         def query(**options, &block)
           @query_klass = build_graphql_object(**options, &block)
         end
 
+        def sort_fields(*fields)
+          self.sort_fields_enum = fields
+        end
+
         def def_root(field_name, is_array: false, null: true, &block)
-          graphql = self
+          resource = self
           resolver = -> {
             Class.new(::GraphQL::Schema::Resolver) do
-              type = is_array ? [graphql.query_klass] : graphql.query_klass
+              type = is_array ? [resource.query_klass] : resource.query_klass
               type type, null: null
               class_eval(&block) if block
             end
@@ -229,7 +110,7 @@ module HQ
           }
         end
 
-        def root_query(find_one: true, find_all: true, pagination: false, per_page_max: 250)
+        def root_query(find_one: true, find_all: true, pagination: true, limit_max: 250)
           field_name = graphql_name.underscore
           scoped_self = self
 
@@ -248,18 +129,22 @@ module HQ
 
           if find_all
             def_root field_name.pluralize, is_array: true, null: false do
-              argument :page, Integer, required: false
-              argument :per_page, Integer, required: false
+              extension FieldExtension::PaginatedArguments, klass: scoped_self.model_klass if pagination
 
-              define_method(:resolve) do |page: nil, per_page: nil, **_attrs|
+              define_method(:resolve) do |limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
                 scope = scoped_self.scope(context).all
 
-                if pagination || page || per_page
-                  page ||= 0
-                  limit = [per_page_max, *per_page].min
-                  scope = scope.limit(limit).offset(page * limit)
+                if pagination || page || limit
+                  offset = [0, *offset].max
+                  limit = [[limit_max, *limit].min, 0].max
+                  scope = scope.limit(limit).offset(offset)
                 end
 
+                sort_by ||= :updated_at
+                sort_order ||= :desc
+                # There should be no risk for SQL injection since an enum is being used for both sort_by and sort_order
+                scope = scope.reorder(sort_by => sort_order)
+
                 scope
               end
             end
@@ -291,6 +176,16 @@ module HQ
             class_eval(&block) if block
           end
         end
+
+        def sort_fields_enum=(fields)
+          @sort_fields_enum ||= Class.new(::HQ::GraphQL::Enum::SortBy).tap do |c|
+            c.graphql_name "#{graphql_name}Sort"
+          end
+
+          Array(fields).each do |field|
+            @sort_fields_enum.value field.to_s.classify, value: field
+          end
+        end
       end
     end
   end

data/lib/hq/graphql/resource/auto_mutation.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "hq/graphql/inputs"
+require "hq/graphql/mutation"
+require "hq/graphql/types"
+
+module HQ
+  module GraphQL
+    module Resource
+      module AutoMutation
+        def build_create
+          scoped_self = self
+
+          build_mutation(action: :create) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.new_record(context)
+              resource.assign_attributes(args[:attributes].format_nested_attributes)
+              if resource.save
+                {
+                  resource: resource,
+                  errors: {},
+                }
+              else
+                {
+                  resource: nil,
+                  errors: errors_from_resource(resource)
+                }
+              end
+            end
+
+            lazy_load do
+              argument :attributes, ::HQ::GraphQL::Inputs[scoped_self.model_name], required: true
+            end
+          end
+        end
+
+        def build_update
+          scoped_self = self
+
+          build_mutation(action: :update, require_primary_key: true) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.find_record(args, context)
+
+              if resource
+                resource.assign_attributes(args[:attributes].format_nested_attributes)
+                if resource.save
+                  {
+                    resource: resource,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: nil,
+                    errors: errors_from_resource(resource)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+
+            lazy_load do
+              argument :attributes, ::HQ::GraphQL::Inputs[scoped_self.model_name], required: true
+            end
+          end
+        end
+
+        def build_copy
+          scoped_self = self
+
+          build_mutation(action: :copy, require_primary_key: true, nil_klass: true) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.find_record(args, context)
+
+              if resource
+                copy = resource.copy
+                if copy.save
+                  {
+                    resource: copy,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: copy,
+                    errors: errors_from_resource(copy)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+          end
+        end
+
+        def build_destroy
+          scoped_self = self
+
+          build_mutation(action: :destroy, require_primary_key: true) do
+            define_method(:resolve) do |**attrs|
+              resource = scoped_self.find_record(attrs, context)
+
+              if resource
+                if resource.destroy
+                  {
+                    resource: resource,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: nil,
+                    errors: errors_from_resource(resource)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+          end
+        end
+
+        def build_mutation(action:, require_primary_key: false, nil_klass: false, &block)
+          gql_name = "#{graphql_name}#{action.to_s.titleize}"
+          scoped_model_name = model_name
+          Class.new(::HQ::GraphQL::Mutation) do
+            graphql_name gql_name
+
+            define_method(:ready?) do |*args|
+              super(*args) && ::HQ::GraphQL.authorized?(action, scoped_model_name, context)
+            end
+
+            lazy_load do
+              field :errors, ::HQ::GraphQL::Types::Object, null: false
+              field :resource, ::HQ::GraphQL::Types[scoped_model_name, nil_klass], null: true
+            end
+
+            instance_eval(&block)
+
+            if require_primary_key
+              lazy_load do
+                klass = scoped_model_name.constantize
+                primary_key = klass.primary_key
+                argument primary_key, ::GraphQL::Types::ID, required: true
+              end
+            end
+
+            def errors_from_resource(resource)
+              resource.errors.to_h.deep_transform_keys { |k| k.to_s.camelize(:lower) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/root_mutation.rb

@@ -7,7 +7,7 @@ module HQ
         super
         base.class_eval do
           lazy_load do
-            ::HQ::GraphQL.types.each do |type|
+            ::HQ::GraphQL.resources.each do |type|
               type.mutation_klasses.each do |mutation_name, klass|
                 field mutation_name, mutation: klass
               end

data/lib/hq/graphql/types.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "hq/graphql/types/object"
+require "hq/graphql/types/uuid"
+
 module HQ
   module GraphQL
     module Types
@@ -39,6 +42,10 @@ module HQ
             ::GraphQL::Types::Float
           when :boolean
             ::GraphQL::Types::Boolean
+          when :date
+            ::GraphQL::Types::ISO8601Date
+          when :datetime
+            ::GraphQL::Types::ISO8601DateTime
           else
             ::GraphQL::Types::String
           end
@@ -64,16 +71,10 @@ module HQ
 
         def find_klass(klass_or_string, method)
           klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
-          type = find_type(klass)
-          type ||= find_type(klass.base_class)
-          type ||= find_type(klass.superclass)
-
-          raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name }) if !type
-          type.send(method)
-        end
+          resource = ::HQ::GraphQL.lookup_resource(klass)
 
-        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.send(method)
         end
       end
     end

data/lib/hq/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hq-graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.9
+  version: 2.1.2
 platform: ruby
 authors:
 - Danny Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-13 00:00:00.000000000 Z
+date: 2020-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -247,19 +247,25 @@ files:
 - lib/hq-graphql.rb
 - lib/hq/graphql.rb
 - lib/hq/graphql/active_record_extensions.rb
+- lib/hq/graphql/association_loader.rb
 - lib/hq/graphql/comparator.rb
 - lib/hq/graphql/config.rb
 - lib/hq/graphql/engine.rb
 - lib/hq/graphql/enum.rb
+- lib/hq/graphql/enum/sort_by.rb
+- lib/hq/graphql/enum/sort_order.rb
 - lib/hq/graphql/field.rb
+- lib/hq/graphql/field_extension/association_loader_extension.rb
+- lib/hq/graphql/field_extension/paginated_arguments.rb
+- lib/hq/graphql/field_extension/paginated_loader.rb
 - lib/hq/graphql/input_object.rb
 - lib/hq/graphql/inputs.rb
-- lib/hq/graphql/loaders.rb
-- lib/hq/graphql/loaders/association.rb
 - lib/hq/graphql/mutation.rb
 - lib/hq/graphql/object.rb
+- lib/hq/graphql/object_association.rb
+- lib/hq/graphql/paginated_association_loader.rb
 - lib/hq/graphql/resource.rb
-- lib/hq/graphql/resource/mutation.rb
+- lib/hq/graphql/resource/auto_mutation.rb
 - lib/hq/graphql/root_mutation.rb
 - lib/hq/graphql/root_query.rb
 - lib/hq/graphql/scalars.rb

data/lib/hq/graphql/loaders.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "hq/graphql/loaders/association"

data/lib/hq/graphql/loaders/association.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    module Loaders
-      class Association < ::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
-end

data/lib/hq/graphql/resource/mutation.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    module Resource
-      module Mutation
-        def self.build(model_name, action:, graphql_name:, require_primary_key: false, nil_klass: false, &block)
-          Class.new(::HQ::GraphQL::Mutation) do
-            graphql_name graphql_name
-
-            define_method(:ready?) do |*args|
-              super(*args) && ::HQ::GraphQL.authorized?(action, model_name, context)
-            end
-
-            lazy_load do
-              field :errors, ::HQ::GraphQL::Types::Object, null: false
-              field :resource, ::HQ::GraphQL::Types[model_name, nil_klass], null: true
-            end
-
-            instance_eval(&block)
-
-            if require_primary_key
-              lazy_load do
-                klass = model_name.constantize
-                primary_key = klass.primary_key
-                argument primary_key, ::GraphQL::Types::ID, required: true
-              end
-            end
-
-            def errors_from_resource(resource)
-              resource.errors.to_h.deep_transform_keys { |k| k.to_s.camelize(:lower) }
-            end
-          end
-        end
-      end
-    end
-  end
-end