hq-graphql 2.1.9 → 2.2.1

data/lib/hq/graphql/ext/enum_extensions.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "hq/graphql/types"
+
+module HQ::GraphQL
+  module Ext
+    module EnumExtensions
+      ## Auto generate enums from the database using ActiveRecord
+      #  This comes in handy when we have constants that we want represented as enums.
+      #
+      # == Example
+      #   Let's assume we're saving data into a user types table
+      #     # select * from user_types;
+      #      id |    name
+      #     --- +-------------
+      #      1  | Admin
+      #      2  | Support User
+      #     (2 rows)
+      #
+      #  ```ruby
+      #    class Enums::UserType < ::HQ::GraphQL::Enum
+      #      with_model
+      #    end
+      #  ```
+      #
+      #  Creates the following enum:
+      #  ```graphql
+      #    enum UserType {
+      #      Admin
+      #      SupportUser
+      #    }
+      #  ```
+      def with_model(
+        klass = default_model_name.safe_constantize,
+        prefix: nil,
+        register: true,
+        scope: nil,
+        strip: /(^[^_a-zA-Z])|([^_a-zA-Z0-9]*)/,
+        value_method: :name
+      )
+        raise ArgumentError.new(<<~ERROR) if !klass
+          `::HQ::GraphQL::Enum.with_model {...}' had trouble automatically inferring the class name.
+          Avoid this by manually passing in the class name: `::HQ::GraphQL::Enum.with_model(#{default_model_name}) {...}`
+        ERROR
+
+        if register
+          ::HQ::GraphQL.enums << klass
+          ::HQ::GraphQL::Types.register(klass, self)
+        end
+
+        lazy_load do
+          records = scope ? klass.instance_exec(&scope) : klass.all
+          records.each do |record|
+            value "#{prefix}#{record.send(value_method).gsub(strip, "")}", value: record
+          end
+        end
+      end
+
+      def lazy_load(&block)
+        @lazy_load ||= []
+        if block
+          ::HQ::GraphQL.lazy_load(self)
+          @lazy_load << block
+        end
+        @lazy_load
+      end
+
+      def lazy_load!
+        lazy_load.shift.call while lazy_load.length > 0
+        @lazy_load = []
+      end
+
+      def default_model_name
+        to_s.sub(/^((::)?\w+)::/, "")
+      end
+    end
+  end
+end
+
+
+::GraphQL::Schema::Enum.extend ::HQ::GraphQL::Ext::EnumExtensions

data/lib/hq/graphql/ext/input_object_extensions.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "hq/graphql/ext/active_record_extensions"
+require "hq/graphql/inputs"
+require "hq/graphql/types"
+
+module HQ
+  module GraphQL
+    module Ext
+      module InputObjectExtensions
+        def self.included(klass)
+          klass.include Scalars
+          klass.include InstanceMethods
+          klass.include ActiveRecordExtensions
+          klass.extend ActiveRecordExtensions
+          klass.extend ClassMethods
+        end
+
+        module InstanceMethods
+          # Recursively format attributes so that they are compatible with `accepts_nested_attributes_for`
+          def format_nested_attributes
+            self.each.inject({}) do |formatted_attrs, (key, value) |
+              if self.class.nested_attributes.include?(key.to_s)
+                formatted_value =
+                  if value.is_a?(Array)
+                    value.map(&:format_nested_attributes)
+                  elsif value
+                    value.format_nested_attributes
+                  end
+
+                formatted_attrs[:"#{key}_attributes"] = formatted_value if formatted_value
+              elsif key.to_s == "x"
+                formatted_attrs[:X] = value
+              else
+                formatted_attrs[key] = value
+              end
+              formatted_attrs
+            end
+          end
+        end
+
+        module ClassMethods
+          #### Class Methods ####
+          def with_model(model_name, attributes: true, associations: false, enums: true, excluded_inputs: [])
+            self.model_name = model_name
+            self.auto_load_attributes = attributes
+            self.auto_load_associations = associations
+            self.auto_load_enums = enums
+
+            lazy_load do
+              excluded_inputs += ::HQ::GraphQL.excluded_inputs
+
+              model_columns.each do |column|
+                argument_from_column(column) unless excluded_inputs.include?(column.name.to_sym)
+              end
+
+              model_associations.each do |association|
+                argument_from_association(association) unless excluded_inputs.include?(association.name.to_sym)
+              end
+
+              argument :X, String, required: false
+            end
+          end
+
+          def nested_attributes
+            @nested_attributes ||= Set.new
+          end
+
+          private
+
+          def argument_from_association(association)
+            is_enum = is_enum?(association)
+            input_or_type = is_enum ? ::HQ::GraphQL::Types[association.klass] : ::HQ::GraphQL::Inputs[association.klass]
+            name = association.name
+            return if argument_exists?(name)
+
+            case association.macro
+            when :has_many
+              argument name, [input_or_type], required: false
+            else
+              argument name, input_or_type, required: false
+            end
+
+            return if is_enum
+
+            if !model_klass.nested_attributes_options.key?(name.to_sym)
+              model_klass.accepts_nested_attributes_for name, allow_destroy: true
+            end
+
+            nested_attributes << name.to_s
+          rescue ::HQ::GraphQL::Inputs::Error
+            nil
+          end
+
+          def argument_from_column(column)
+            name = column.name
+            return if argument_exists?(name)
+            argument name, ::HQ::GraphQL::Types.type_from_column(column), required: false
+          end
+
+          def argument_exists?(name)
+            !!arguments[camelize(name)]
+          end
+        end
+      end
+    end
+  end
+end
+
+::GraphQL::Schema::InputObject.include ::HQ::GraphQL::Ext::InputObjectExtensions

data/lib/hq/graphql/ext/mutation_extensions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    module Ext
+      module MutationExtensions
+        def self.included(klass)
+          klass.include Scalars
+          klass.include ActiveRecordExtensions
+          klass.singleton_class.prepend PrependMethods
+        end
+
+        module PrependMethods
+          def generate_payload_type
+            lazy_load!
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+::GraphQL::Schema::Mutation.include ::HQ::GraphQL::Ext::MutationExtensions

data/lib/hq/graphql/ext/object_extensions.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "hq/graphql/ext/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
+    module Ext
+      module ObjectExtensions
+        def self.included(klass)
+          klass.include Scalars
+          klass.include ActiveRecordExtensions
+          klass.extend ObjectAssociation
+          klass.singleton_class.prepend PrependMethods
+          klass.field_class Field
+        end
+
+        module PrependMethods
+          def authorize_action(action)
+            self.authorized_action = action
+          end
+
+          def authorized?(object, context)
+            super && ::HQ::GraphQL.authorized?(authorized_action, object, context)
+          end
+
+          def with_model(model_name, attributes: true, associations: true, auto_nil: true, enums: true)
+            self.model_name = model_name
+            self.auto_load_attributes = attributes
+            self.auto_load_associations = associations
+            self.auto_load_enums = enums
+
+            lazy_load do
+              model_columns.each do |column|
+                field_from_column(column, auto_nil: auto_nil)
+              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
+
+          private
+          attr_writer :authorized_action
+
+          def authorized_action
+            @authorized_action ||= :read
+          end
+
+          def field_from_association(association, auto_nil:, internal_association: false, &block)
+            association_klass = association.klass
+            name              = association.name.to_s
+            return if field_exists?(name)
+
+            klass = model_klass
+            type  = Types[association_klass]
+
+            case association.macro
+            when :has_many
+              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
+            when :has_one
+              field name, type, null: !auto_nil || !has_presence_validation?(association), klass: model_name do
+                extension FieldExtension::AssociationLoaderExtension, klass: klass
+              end
+            else
+              field name, type, null: !auto_nil || !association_required?(association), klass: model_name do
+                extension FieldExtension::AssociationLoaderExtension, klass: klass
+              end
+            end
+          rescue Types::Error
+            nil
+          end
+
+          def field_from_column(column, auto_nil:)
+            name = column.name
+            return if field_exists?(name)
+
+            field name, Types.type_from_column(column), null: !auto_nil || column.null
+          end
+
+          def field_exists?(name)
+            !!fields[camelize(name)]
+          end
+
+          def association_required?(association)
+            !association.options[:optional] || has_presence_validation?(association)
+          end
+
+          def has_presence_validation?(association)
+            model_klass.validators.any? do |validation|
+              next unless validation.class == ActiveRecord::Validations::PresenceValidator && !(validation.options.include?(:if) || validation.options.include?(:unless))
+              validation.attributes.any? { |a| a.to_s == association.name.to_s }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+::GraphQL::Schema::Object.include ::HQ::GraphQL::Ext::ObjectExtensions

data/lib/hq/graphql/ext/schema_extensions.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    module Ext
+      module SchemaExtensions
+        def self.prepended(klass)
+          klass.alias_method :add_type_and_traverse_without_types, :add_type_and_traverse
+          klass.alias_method :add_type_and_traverse, :add_type_and_traverse_with_types
+        end
+
+        def execute(*args, **options)
+          load_types!
+          super
+        end
+
+        def dump_directory(directory = Rails.root.join("app/graphql"))
+          @dump_directory ||= directory
+        end
+
+        def dump_filename(filename = "#{self.name.underscore}.graphql")
+          @dump_filename ||= filename
+        end
+
+        def dump
+          load_types!
+          ::FileUtils.mkdir_p(dump_directory)
+          ::File.open(::File.join(dump_directory, dump_filename), "w") { |file| file.write(self.to_definition) }
+        end
+
+        def load_types!
+          ::HQ::GraphQL.load_types!
+          return if @add_type_and_traverse_with_types.blank?
+          while (args, options = @add_type_and_traverse_with_types.shift)
+            add_type_and_traverse_without_types(*args, **options)
+          end
+        end
+
+        # Defer adding types until first schema execution
+        # https://github.com/rmosolgo/graphql-ruby/blob/345ebb2e3833909963067d81e0e8378717b5bdbf/lib/graphql/schema.rb#L1792
+        def add_type_and_traverse_with_types(*args, **options)
+          @add_type_and_traverse_with_types ||= []
+          @add_type_and_traverse_with_types.push([args, options])
+        end
+      end
+    end
+  end
+end
+
+::GraphQL::Schema.singleton_class.prepend ::HQ::GraphQL::Ext::SchemaExtensions

data/lib/hq/graphql/field.rb

@@ -20,7 +20,7 @@ module HQ
         end
       end
 
-      def authorized?(object, ctx)
+      def authorized?(object, _args, ctx)
         super &&
           (!authorize || authorize.call(object, ctx)) &&
           ::HQ::GraphQL.authorize_field(authorize_action, self, object, ctx)

data/lib/hq/graphql/paginated_association_loader.rb

@@ -17,6 +17,7 @@ module HQ
       end
 
       def initialize(model, association_name, internal_association: false, limit: nil, offset: nil, scope: nil, sort_by: nil, sort_order: nil)
+        super()
         @model                = model
         @association_name     = association_name
         @internal_association = internal_association

data/lib/hq/graphql/record_loader.rb

@@ -4,6 +4,7 @@ module HQ
   module GraphQL
     class RecordLoader < ::GraphQL::Batch::Loader
       def initialize(model, column: model.primary_key, where: nil)
+        super()
         @model = model
         @column = column.to_s
         @column_type = model.type_for_attribute(@column)

data/lib/hq/graphql/resource.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require "hq/graphql/ext/input_object_extensions"
+require "hq/graphql/ext/object_extensions"
 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"
 
@@ -60,18 +60,21 @@ module HQ
         end
 
         def nil_query_object
-          @nil_query_object ||= build_graphql_object(name: "#{graphql_name}Copy", auto_nil: false)
+          @nil_query_object ||= const_set(:NilQuery, 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
+            qo =
+              if @query_object_options
+                options, block = @query_object_options
+                @query_object_options = nil
+                build_graphql_object(**options, &block)
+              else
+                build_graphql_object
+              end
+            remove_const(:Query) if const_defined?(:Query, false)
+            const_set(:Query, qo)
           end
         end
 
@@ -79,6 +82,20 @@ module HQ
           @sort_fields_enum || ::HQ::GraphQL::Enum::SortBy
         end
 
+        def const_missing(constant_name)
+          constant_name = constant_name.to_sym
+          case constant_name
+          when :Query
+            query_object
+          when :NilQuery
+            nil_query_object
+          when :Input
+            input_klass
+          else
+            super
+          end
+        end
+
         protected
 
         def default_scope(&block)
@@ -108,14 +125,22 @@ module HQ
           self.sort_fields_enum = fields
         end
 
+        def excluded_inputs(*fields)
+          @excluded_inputs = fields
+        end
+
         def def_root(field_name, is_array: false, null: true, &block)
           resource = self
           resolver = -> {
-            Class.new(::GraphQL::Schema::Resolver) do
+            klass = Class.new(::GraphQL::Schema::Resolver) do
               type = is_array ? [resource.query_object] : resource.query_object
               type type, null: null
               class_eval(&block) if block
             end
+
+            constant_name = "#{field_name.to_s.classify}Resolver"
+            resource.send(:remove_const, constant_name) if resource.const_defined?(constant_name, false)
+            resource.const_set(constant_name, klass)
           }
           ::HQ::GraphQL.root_queries << {
             field_name: field_name, resolver: resolver, model_name: model_name
@@ -168,7 +193,7 @@ module HQ
         def build_graphql_object(name: graphql_name, **options, &block)
           scoped_graphql_name = name
           scoped_model_name = model_name
-          object_class = @query_class || ::HQ::GraphQL.default_object_class || ::HQ::GraphQL::Object
+          object_class = @query_class || ::HQ::GraphQL.default_object_class || ::GraphQL::Schema::Object
           Class.new(object_class) do
             graphql_name scoped_graphql_name
 
@@ -181,18 +206,24 @@ module HQ
         def build_input_object(**options, &block)
           scoped_graphql_name = graphql_name
           scoped_model_name = model_name
-          Class.new(::HQ::GraphQL::InputObject) do
+          scoped_excluded_inputs = @excluded_inputs || []
+
+          input_klass = Class.new(::GraphQL::Schema::InputObject) do
             graphql_name "#{scoped_graphql_name}Input"
 
-            with_model scoped_model_name, **options
+            with_model scoped_model_name, excluded_inputs: scoped_excluded_inputs, **options
 
             class_eval(&block) if block
           end
+
+          remove_const(:Input) if const_defined?(:Input, false)
+          const_set(:Input, input_klass)
         end
 
         def sort_fields_enum=(fields)
           @sort_fields_enum ||= Class.new(::HQ::GraphQL::Enum::SortBy).tap do |c|
             c.graphql_name "#{graphql_name}Sort"
+            const_set(:Sort, c)
           end
 
           Array(fields).each do |field|