hq-graphql 2.1.12 → 2.2.3

data/lib/hq/graphql/filters.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "hq/graphql/filter_operations"
+require "hq/graphql/util"
+
+module HQ
+  module GraphQL
+    class Filters
+      BOOLEAN_VALUES = ["t", "f", "true", "false"]
+
+      def self.supported?(column)
+        !!Filter.class_from_column(column)
+      end
+
+      attr_reader :filters, :model
+
+      def initialize(filters, model)
+        @filters = Array(filters).map { |filter| Filter.for(filter, table: model.arel_table) }
+        @model = model
+      end
+
+      def validate!
+        filters.each(&:validate)
+        errors = filters.map do |filter|
+          filter.display_error_message
+        end.flatten.uniq
+
+        if errors.any?
+          raise ::GraphQL::ExecutionError, errors.join(", ")
+        end
+      end
+
+      def to_scope
+        filters.reduce(model.all) do |s, filter|
+          s.where(filter.to_arel)
+        end
+      end
+
+      class Filter
+        include ActiveModel::Validations
+        include FilterOperations
+
+        def self.for(filter, **options)
+          class_from_column(filter.field).new(filter, **options)
+        end
+
+        def self.class_from_column(column)
+          case column.type
+          when :boolean
+            BooleanFilter
+          when :date, :datetime
+            DateFilter
+          when :decimal, :integer
+            NumericFilter
+          when :string, :text
+            StringFilter
+          when :uuid
+            UuidFilter
+          end
+        end
+
+        def self.validate_operations(*operations)
+          valid_operations = operations + [WITH]
+          validates :operation, inclusion: {
+            in: valid_operations,
+            message: "only supports the following operations: #{valid_operations.map(&:name).join(", ")}"
+          }
+        end
+
+        def self.validate_value(**options)
+          validates :value, **options, unless: ->(filter) { filter.operation == WITH }
+        end
+
+        validate :validate_boolean_values, if: ->(filter) { filter.operation == WITH }
+
+        attr_reader :table, :column, :operation, :value
+
+        def initialize(filter, table:)
+          @table = table
+          @column = filter.field
+          @operation = filter.operation
+          @value = filter.value
+        end
+
+        def display_error_message
+          return unless errors.any?
+          messages = errors.messages.values.join(", ")
+          "#{column.name.camelize(:lower)} (type: #{column.type}, operation: #{operation.name}, value: \"#{value}\"): #{messages}"
+        end
+
+        def to_arel
+          operation.to_arel(table: table, column_name: column.name, value: value)
+        end
+
+        def validate_boolean_values
+          is_valid = BOOLEAN_VALUES.any? { |v| value.casecmp(v) == 0 }
+          return if is_valid
+          errors.add(:value, "WITH operation only supports boolean values (#{BOOLEAN_VALUES.join(", ")})")
+        end
+      end
+
+      class BooleanFilter < Filter
+        validate_operations
+
+        def to_arel
+          arel = super
+
+          if value.casecmp("f") == 0 || value.casecmp("false") == 0
+            arel = arel.or(table[column.name].eq(false))
+          end
+
+          arel
+        end
+      end
+
+      class DateFilter < Filter
+        validate_operations GREATER_THAN, LESS_THAN
+        validate :validate_iso8601
+
+        def validate_iso8601
+          is_valid = begin
+            DateTime.iso8601(value)
+            true
+          rescue ArgumentError
+            false
+          end
+
+          return if is_valid
+
+          today = Date.today
+          errors.add(:value, "only supports ISO8601 values (\"#{today.iso8601}\", \"#{today.to_datetime.iso8601}\")")
+        end
+      end
+
+      class NumericFilter < Filter
+        validate_operations GREATER_THAN, LESS_THAN, EQUAL, NOT_EQUAL
+        validate_value numericality: { message: "only supports numerical values" }
+      end
+
+      class StringFilter < Filter
+        validate_operations EQUAL, NOT_EQUAL, LIKE, NOT_LIKE
+      end
+
+      class UuidFilter < Filter
+        validate_operations EQUAL, NOT_EQUAL
+        validate_value format: { with: HQ::GraphQL::Util::UUID_FORMAT, message: "only supports UUID values (e.g. 00000000-0000-0000-0000-000000000000)" }
+      end
+    end
+  end
+end

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,12 @@
 # frozen_string_literal: true
 
+require "hq/graphql/ext/enum_extensions"
+require "hq/graphql/ext/input_object_extensions"
+require "hq/graphql/ext/object_extensions"
+require "hq/graphql/enum/filter_operation"
 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/filters"
 require "hq/graphql/resource/auto_mutation"
 require "hq/graphql/scalars"
 
@@ -60,18 +63,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 +85,59 @@ 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
+          when :FilterInput
+            filter_input
+          when :FilterFields
+            filter_fields_enum
+          else
+            super
+          end
+        end
+
+        def filter_input
+          @filter_input ||= begin
+            scoped_self = self
+
+            input_class = Class.new(::GraphQL::Schema::InputObject) do
+              graphql_name "#{scoped_self.graphql_name}FilterInput"
+
+              argument :field, scoped_self.filter_fields_enum, required: true
+              argument :operation, Enum::FilterOperation, required: true
+              argument :value, String, required: true
+            end
+
+            const_set(:FilterInput, input_class)
+          end
+        end
+
+        def filter_fields_enum
+          @filter_fields_enum ||= begin
+            scoped_self = self
+
+            enum_class = Class.new(::GraphQL::Schema::Enum) do
+              graphql_name "#{scoped_self.graphql_name}FilterFields"
+
+              lazy_load do
+                scoped_self.model_klass.columns.sort_by(&:name).each do |column|
+                  next unless HQ::GraphQL::Filters.supported?(column)
+                  value column.name.camelize(:lower), value: column
+                end
+              end
+            end
+
+            const_set(:FilterFields, enum_class)
+          end
+        end
+
         protected
 
         def default_scope(&block)
@@ -115,11 +174,15 @@ module HQ
         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
@@ -146,9 +209,13 @@ module HQ
           if find_all
             def_root field_name.pluralize, is_array: true, null: false do
               extension FieldExtension::PaginatedArguments, klass: scoped_self.model_klass if pagination
+              argument :filters, [scoped_self.filter_input], required: false
+
+              define_method(:resolve) do |filters: nil, limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
+                filters_scope = ::HQ::GraphQL::Filters.new(filters, scoped_self.model_klass)
+                filters_scope.validate!
 
-              define_method(:resolve) do |limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
-                scope = scoped_self.scope(context).all
+                scope = scoped_self.scope(context).all.merge(filters_scope.to_scope)
 
                 if pagination || page || limit
                   offset = [0, *offset].max
@@ -172,7 +239,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
 
@@ -187,18 +254,22 @@ module HQ
           scoped_model_name = model_name
           scoped_excluded_inputs = @excluded_inputs || []
 
-          Class.new(::HQ::GraphQL::InputObject) do
+          input_klass = Class.new(::GraphQL::Schema::InputObject) do
             graphql_name "#{scoped_graphql_name}Input"
 
             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|

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require "hq/graphql/ext/mutation_extensions"
 require "hq/graphql/inputs"
-require "hq/graphql/mutation"
 require "hq/graphql/types"
 
 module HQ
@@ -130,15 +130,16 @@ module HQ
         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
+
+          klass = Class.new(::GraphQL::Schema::Mutation) do
             graphql_name gql_name
 
-            define_method(:ready?) do |*args|
-              super(*args) && ::HQ::GraphQL.authorized?(action, scoped_model_name, context)
+            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 :errors, ::GraphQL::Types::JSON, null: false
               field :resource, ::HQ::GraphQL::Types[scoped_model_name, nil_klass], null: true
             end
 
@@ -156,6 +157,8 @@ module HQ
               resource.errors.to_h.deep_transform_keys { |k| k.to_s.camelize(:lower) }
             end
           end
+
+          const_set(gql_name, klass)
         end
       end
     end

data/lib/hq/graphql/root_mutation.rb

@@ -2,7 +2,7 @@
 
 module HQ
   module GraphQL
-    class RootMutation < ::HQ::GraphQL::Object
+    class RootMutation < ::GraphQL::Schema::Object
       def self.inherited(base)
         super
         base.class_eval do

data/lib/hq/graphql/root_query.rb

@@ -2,13 +2,13 @@
 
 module HQ
   module GraphQL
-    class RootQuery < ::HQ::GraphQL::Object
+    class RootQuery < ::GraphQL::Schema::Object
       def self.inherited(base)
         super
         base.class_eval do
           lazy_load do
-            ::HQ::GraphQL.root_queries.each do |field_name:, resolver:, model_name:|
-              field field_name, resolver: resolver.call, klass: model_name
+            ::HQ::GraphQL.root_queries.each do |query|
+              field query[:field_name], resolver: query[:resolver].call, klass: query[:model_name]
             end
           end
         end

data/lib/hq/graphql/scalars.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require "hq/graphql/types/object"
 require "hq/graphql/types/uuid"
 
 module HQ
   module GraphQL
     module Scalars
-      Object = ::HQ::GraphQL::Types::Object
       UUID = ::HQ::GraphQL::Types::UUID
     end
   end

data/lib/hq/graphql/types.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "hq/graphql/types/object"
 require "hq/graphql/types/uuid"
 
 module HQ
@@ -35,7 +34,7 @@ module HQ
           when :uuid
             ::HQ::GraphQL::Types::UUID
           when :json, :jsonb
-            ::HQ::GraphQL::Types::Object
+            ::GraphQL::Types::JSON
           when :integer
             ::GraphQL::Types::Int
           when :decimal

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "hq/graphql/util"
+
 module HQ
   module GraphQL
     module Types
@@ -18,16 +20,12 @@ module HQ
           private
 
           def validate_and_return_uuid(value)
-            if validate_uuid(value)
+            if ::HQ::GraphQL::Util.validate_uuid(value)
               value
             else
               raise ::GraphQL::CoercionError, "#{value.inspect} is not a valid UUID"
             end
           end
-
-          def validate_uuid(value)
-            !!value.to_s.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
-          end
         end
       end
     end