hq-graphql 2.1.12 → 2.2.3

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hq/graphql/enum/filter_operation"
+
+module HQ
+  module GraphQL
+    module FilterOperations
+      class Operation
+        attr_reader :name, :arel, :check_for_null, :sanitize
+
+        def initialize(name:, arel:, check_for_null: false, sanitize: nil)
+          @name           = name
+          @arel           = arel
+          @check_for_null = check_for_null
+          @sanitize       = sanitize
+        end
+
+        def sanitize_value(value)
+          sanitize ? sanitize.call(value) : value
+        end
+
+        def to_arel(table:, column_name:, value:)
+          sanitized_value = sanitize_value(value)
+
+          if arel.is_a?(Proc)
+            return arel.call(table: table, column_name: column_name, value: sanitized_value)
+          end
+
+          expression = table[column_name].send(arel, sanitized_value)
+
+          if check_for_null
+            expression = expression.or(table[column_name].eq(nil))
+          end
+
+          expression
+        end
+      end
+
+      OPERATIONS = [
+        EQUAL = Operation.new(name: "EQUAL", arel: :eq),
+        NOT_EQUAL = Operation.new(name: "NOT_EQUAL", arel: :not_eq, check_for_null: true),
+        LIKE = Operation.new(name: "LIKE", arel: :matches, sanitize: ->(value) { "%#{ActiveRecord::Base.sanitize_sql_like(value)}%" }),
+        NOT_LIKE = Operation.new(name: "NOT_LIKE", arel: :does_not_match, check_for_null: true, sanitize: ->(value) { "%#{ActiveRecord::Base.sanitize_sql_like(value)}%" }),
+        GREATER_THAN = Operation.new(name: "GREATER_THAN", arel: :gt),
+        LESS_THAN = Operation.new(name: "LESS_THAN", arel: :lt),
+        WITH = Operation.new(
+          name: "WITH",
+          arel: ->(table:, column_name:, value:) do
+            if value.casecmp("t") == 0 || value.casecmp("true") == 0
+              table[column_name].not_eq(nil)
+            else
+              table[column_name].eq(nil)
+            end
+          end
+        )
+      ]
+    end
+  end
+end