hq-graphql 2.0.10 → 2.1.3

data/lib/hq/graphql/paginated_association_loader.rb

@@ -0,0 +1,193 @@
+# 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)
+        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.
+            #
+            # > 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
+            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(lateral_join_table[target_join_key].eq(from_table[target_join_key])).
+              reorder(arel_order(inner_table)).
+              limit(@limit).
+              offset(@offset)
+
+            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(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
+            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, target_value(record, results)) unless fulfilled?(record)
+        end
+      end
+
+      private
+
+      def source_join_key
+        belongs_to? ? association.foreign_key : association.association_primary_key
+      end
+
+      def source_value(record)
+        record.send(source_join_key)
+      end
+
+      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 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
+        scope = association_class
+        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
+
+      def belongs_to?
+        association.macro == :belongs_to
+      end
+
+      def has_many?
+        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)
+        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)
@@ -52,12 +59,24 @@ 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)
+        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 query_klass
-          @query_klass ||= build_graphql_object
+        def sort_fields_enum
+          @sort_fields_enum || ::HQ::GraphQL::Enum::SortBy
         end
 
         protected
@@ -71,155 +90,29 @@ 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
+          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
 
-          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
+        def query(**options, &block)
+          @query_object_options = [options, block]
+        end
 
-            mutation_klasses["destroy_#{scoped_graphql_name.underscore}"] = destroy_mutation
-          end
+        def query_class(klass)
+          @query_class = klass
         end
 
-        def query(**options, &block)
-          @query_klass = build_graphql_object(**options, &block)
+        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_object] : resource.query_object
               type type, null: null
               class_eval(&block) if block
             end
@@ -229,7 +122,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 +141,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
@@ -271,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
@@ -291,6 +189,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