hq-graphql 2.1.12 → 2.2.0

data/lib/hq/graphql/input_object.rb

@@ -1,104 +0,0 @@
-# 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
-      include Scalars
-      include ::HQ::GraphQL::ActiveRecordExtensions
-
-      # 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
-
-      #### Class Methods ####
-      def self.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 self.nested_attributes
-        @nested_attributes ||= Set.new
-      end
-
-      def self.to_graphql
-        lazy_load!
-        super
-      end
-
-      class << self
-        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

data/lib/hq/graphql/mutation.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    class Mutation < ::GraphQL::Schema::Mutation
-      include Scalars
-      include ::HQ::GraphQL::ActiveRecordExtensions
-
-      def self.generate_payload_type
-        lazy_load!
-        super
-      end
-    end
-  end
-end

data/lib/hq/graphql/object.rb

@@ -1,120 +0,0 @@
-# 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 ActiveRecordExtensions
-      extend ObjectAssociation
-
-      field_class Field
-
-      def self.authorize_action(action)
-        self.authorized_action = action
-      end
-
-      def self.authorized?(object, context)
-        super && ::HQ::GraphQL.authorized?(authorized_action, object, context)
-      end
-
-      def self.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
-
-      def self.to_graphql
-        lazy_load!
-        super
-      end
-
-      class << self
-        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

data/lib/hq/graphql/schema.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    class Schema < ::GraphQL::Schema
-      class << self
-        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
-          ::FileUtils.mkdir_p(dump_directory)
-          ::File.open(::File.join(dump_directory, dump_filename), "w") { |file| file.write(self.to_definition) }
-        end
-      end
-    end
-  end
-end

data/lib/hq/graphql/types/object.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    module Types
-      class Object < ::GraphQL::Schema::Scalar
-        description "Object"
-
-        def self.coerce_input(value, _context)
-          validate_and_return_object(value)
-        end
-
-        def self.coerce_result(value, _context)
-          validate_and_return_object(value)
-        end
-
-        class << self
-          private
-
-          def validate_and_return_object(value)
-            if validate_object(value)
-              value
-            else
-              raise ::GraphQL::CoercionError, "#{value.inspect} is not a valid Object"
-            end
-          end
-
-          def validate_object(value)
-            value.is_a?(Hash)
-          end
-        end
-      end
-    end
-  end
-end