graphql-filters 1.0.0

data/lib/graphql/filters/filterable.rb

@@ -0,0 +1,42 @@
+module GraphQL
+  module Filters
+    module Filterable
+      extend ActiveSupport::Concern
+
+      # We need the two inner_type chunks of code because type.list? is true if any of the types in the of_type chain
+      #   is a list, but type.unwrap returns the raw type. I want the filter to be based on the of_type of the list,
+      #   which could be the unwrapped type, but it could also be a non nullable version of that type. The non
+      #   nullability is relevant.
+
+      included do
+        raise 'You can only apply a filter to a list field' unless type.list?
+
+        unless defined?(SearchObject::Base) && include?(SearchObject::Base)
+          raise 'If you don\'t use SearchObject, you must *prepend* Filterable, not *include* it.'
+        end
+
+        inner_type = type
+        inner_type = type.of_type until inner_type.kind == GraphQL::TypeKinds::LIST
+        inner_type = inner_type.of_type
+
+        option :filter, type: inner_type.comparison_input_type do |scope, filter|
+          filter.call scope
+        end
+      end
+
+      prepended do
+        raise 'You can only apply a filter to a list field' unless type.list?
+
+        inner_type = type
+        inner_type = type.of_type while inner_type.kind == GraphQL::TypeKinds::LIST
+        inner_type = inner_type.of_type
+
+        argument :filter, inner_type.comparison_input_type, required: false
+
+        def resolve filter: nil, **kwargs
+          filter.call super(**kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/base_comparison_input_type.rb

@@ -0,0 +1,12 @@
+module GraphQL
+  module Filters
+    module InputTypes
+      class BaseComparisonInputType < Filters.base_input_object_class
+        def self.argument *args, **kwargs, &block
+          kwargs[:required] = false
+          super(*args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/base_list_comparison_input_type.rb

@@ -0,0 +1,23 @@
+require_relative 'base_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class BaseListComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseComparisonInputType do
+            graphql_name "#{value_type.unwrap.graphql_name}ListComparisonInput"
+
+            one_of
+
+            def prepare
+              values.sole
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/base_scalar_comparison_input_type.rb

@@ -0,0 +1,63 @@
+require_relative 'base_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class BaseScalarComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseComparisonInputType do
+            graphql_name "#{value_type.graphql_name}ComparisonInput"
+
+            one_of
+
+            argument :constant,
+                     Types::Boolean,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, _column_name|
+                         if value
+                           scope.all
+                         else
+                           scope.where false
+                         end
+                       }
+                     }
+            argument :equals,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => value)
+                       }
+                     }
+            argument :not_equals,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where.not(column_name => value)
+                       }
+                     }
+            argument :in,
+                     [value_type],
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => value)
+                       }
+                     }
+            argument :not_in,
+                     [value_type],
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where.not(column_name => value)
+                       }
+                     }
+
+            def prepare
+              values.sole
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/fields_comparison_input_type.rb

@@ -0,0 +1,58 @@
+require_relative 'base_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class FieldsComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |object_type, klass|
+          klass.new BaseComparisonInputType do
+            graphql_name "#{object_type.graphql_name}ComparisonInput"
+
+            object_type.fields.each_value do |field_object|
+              next unless field_object.filter_options[:enabled]
+
+              type = field_object.type
+              filter_options = field_object.filter_options
+
+              argument field_object.name,
+                       type.comparison_input_type,
+                       required: false,
+                       prepare: lambda { |field_comparator, _context|
+                         lambda { |scope|
+                           if scope.klass.attribute_names.include? filter_options[:attribute_name]
+                             field_comparator.call scope, filter_options[:attribute_name]
+                           else
+                             field_comparator.call scope, filter_options[:association_name]
+                           end
+                         }
+                       }
+            end
+
+            define_method :prepare do
+              lambda do |scope, association_name=nil|
+                model_class = object_type.model_class
+
+                nested_query = values.reduce model_class.all do |acc, val|
+                  val.call acc
+                end
+
+                if association_name.nil?
+                  unless scope.structurally_compatible? nested_query
+                    raise "the produced nested query on model #{model_class}"\
+                          'is not compatible with the provided scope'
+                  end
+
+                  scope.and nested_query
+                else
+                  scope.where association_name => nested_query
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/list_object_comparison_input_type.rb

@@ -0,0 +1,97 @@
+require_relative 'base_list_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class ListObjectComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseListComparisonInputType[value_type] do
+            raw_type = value_type.unwrap
+
+            argument :constant,
+                     Types::Boolean,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, _column_name=nil|
+                         if value
+                           scope.all
+                         else
+                           scope.where false
+                         end
+                       }
+                     }
+            argument :any,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, association_name|
+                         subquery = field_comparator.call raw_type.model_class.all
+
+                         reflection = scope.reflect_on_association association_name
+
+                         finished_subquery = apply_reflection_to_subquery reflection, scope, subquery
+
+                         scope.where finished_subquery.arel.exists
+                       }
+                     }
+            argument :all,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, association_name|
+                         subquery = field_comparator.call raw_type.model_class.all
+
+                         reflection = scope.reflect_on_association association_name
+
+                         finished_subquery = apply_reflection_to_subquery reflection, scope, subquery.invert_where
+
+                         scope.where.not finished_subquery.arel.exists
+                       }
+                     }
+            argument :none,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, association_name|
+                         subquery = field_comparator.call raw_type.model_class.all
+
+                         reflection = scope.reflect_on_association association_name
+
+                         finished_subquery = apply_reflection_to_subquery reflection, scope, subquery
+
+                         scope.where.not finished_subquery.arel.exists
+                       }
+                     }
+
+            class << self
+            private
+
+              def apply_reflection_to_subquery reflection, scope, subquery
+                unless reflection.is_a? ActiveRecord::Reflection::AbstractReflection
+                  raise 'Lists of objects are only supported through associations at the moment'
+                end
+
+                scope_klass = scope.klass
+                scope_table = scope.table
+                scope_aliased_table = scope_table.alias "other_#{scope_table.name}"
+
+                table_metadata = ActiveRecord::TableMetadata.new scope_klass, scope_aliased_table
+                predicate_builder = ActiveRecord::PredicateBuilder.new table_metadata
+                aliased_relation = ActiveRecord::Relation.new scope_klass,
+                                                              table: scope_aliased_table,
+                                                              predicate_builder: predicate_builder
+
+                aliased_primary_key_node = scope_aliased_table[scope.primary_key]
+                scope_primary_key_node = scope_table[scope.primary_key]
+
+                aliased_relation
+                  .joins(reflection.name)
+                  .merge(subquery)
+                  .where(aliased_primary_key_node.eq(scope_primary_key_node))
+                  .select(:id) # Improves performance
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/list_scalar_comparison_input_type.rb

@@ -0,0 +1,134 @@
+require_relative 'base_list_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class ListScalarComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseListComparisonInputType[value_type] do
+            argument :equals,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => value)
+                       }
+                     }
+            argument :not_equals,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where.not(column_name => value)
+                       }
+                     }
+            argument :in,
+                     [value_type],
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => value)
+                       }
+                     }
+            argument :not_in,
+                     [value_type],
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where.not(column_name => value)
+                       }
+                     }
+            argument :subset_of,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         table = scope.table[column_name]
+                         attribute = scope.predicate_builder.build_bind_attribute column_name, value
+                         scope.where table.contained(attribute)
+                       }
+                     }
+            argument :not_subset_of,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         table = scope.table[column_name]
+                         attribute = scope.predicate_builder.build_bind_attribute column_name, value
+                         scope.where.not table.contained(attribute)
+                       }
+                     }
+            argument :superset_of,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         table = scope.table[column_name]
+                         attribute = scope.predicate_builder.build_bind_attribute column_name, value
+                         scope.where table.contains(attribute)
+                       }
+                     }
+            argument :not_superset_of,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         table = scope.table[column_name]
+                         attribute = scope.predicate_builder.build_bind_attribute column_name, value
+                         scope.where.not table.contains(attribute)
+                       }
+                     }
+            argument :any,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, column_name|
+                         sub_scope = create_sub_scope scope, column_name, field_comparator
+                         scope.where sub_scope.arel.exists
+                       }
+                     }
+            argument :all,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, column_name|
+                         sub_scope = create_sub_scope scope, column_name, field_comparator
+                         scope.where.not sub_scope.invert_where.arel.exists
+                       }
+                     }
+            argument :none,
+                     value_type.of_type.comparison_input_type,
+                     prepare: lambda { |field_comparator, _context|
+                       lambda { |scope, column_name|
+                         sub_scope = create_sub_scope scope, column_name, field_comparator
+                         scope.where.not sub_scope.arel.exists
+                       }
+                     }
+
+            class << self
+            private
+
+              def create_sub_scope scope, column_name, field_comparator
+                type_caster = Object.new
+
+                type_caster.define_singleton_method :type_for_attribute do |_name|
+                  scope.klass.type_for_attribute(column_name).subtype
+                end
+
+                type_caster.define_singleton_method :type_cast_for_database do |attr_name, value|
+                  type = type_for_attribute attr_name
+                  type.serialize value
+                end
+
+                table = Arel::Table.new 'temp_table', type_caster: type_caster
+                predicate_builder = ActiveRecord::PredicateBuilder.new ActiveRecord::TableMetadata.new(
+                  ActiveRecord::Base, table
+                )
+                temp_relation = ActiveRecord::Relation.new(ActiveRecord::Base,
+                                                           table: table,
+                                                           predicate_builder: predicate_builder)
+                                  .from(Arel::Nodes::NamedFunction.new 'UNNEST',
+                                                                       [scope.arel_table[column_name]],
+                                                                       'temp_table(value)')
+
+                field_comparator.call temp_relation, 'value'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/numeric_comparison_input_type.rb

@@ -0,0 +1,45 @@
+require_relative 'base_scalar_comparison_input_type'
+require 'arel'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class NumericComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseScalarComparisonInputType[value_type] do
+            argument :greater_than,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where.not(column_name => (..value))
+                       }
+                     }
+            argument :greater_than_or_equals_to,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => (value..))
+                       }
+                     }
+            argument :less_than,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => (...value))
+                       }
+                     }
+            argument :less_than_or_equals_to,
+                     value_type,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, column_name|
+                         scope.where(column_name => (..value))
+                       }
+                     }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/object_comparison_input_type.rb

@@ -0,0 +1,71 @@
+require_relative 'base_comparison_input_type'
+require_relative 'fields_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class ObjectComparisonInputType
+        include CachedClass
+
+        resolve_cache_miss do |value_type, klass|
+          klass.new BaseComparisonInputType do
+            graphql_name "#{value_type.graphql_name}ComplexFilterInput"
+
+            fields_comparison_input_type = FieldsComparisonInputType[value_type]
+
+            define_singleton_method :fields_comparison_input_type do
+              fields_comparison_input_type
+            end
+
+            one_of
+
+            argument :constant,
+                     Types::Boolean,
+                     prepare: lambda { |value, _context|
+                       lambda { |scope, _association_name=nil|
+                         if value
+                           scope.all
+                         else
+                           scope.where false
+                         end
+                       }
+                     }
+            argument :and,
+                     [self],
+                     required: false,
+                     prepare: lambda { |and_arg, _context|
+                       lambda { |scope, association_name=nil|
+                         and_arg.reduce scope do |acc, val|
+                           acc.and val.call(scope, association_name)
+                         end
+                       }
+                     }
+            argument :or,
+                     [self],
+                     required: false,
+                     prepare: lambda { |or_arg, _context|
+                       lambda { |scope, association_name=nil|
+                         or_arg.reduce scope.none do |acc, val|
+                           acc.or val.call(scope, association_name)
+                         end
+                       }
+                     }
+            argument :not,
+                     self,
+                     required: false,
+                     prepare: lambda { |not_arg, _context|
+                       lambda { |scope, association_name=nil|
+                         scope.and(not_arg.call(scope.unscope(:where), association_name).invert_where)
+                       }
+                     }
+            argument :fields, fields_comparison_input_type, required: false
+
+            def prepare
+              values.sole
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/input_types/string_comparison_input_type.rb

@@ -0,0 +1,64 @@
+require_relative 'base_scalar_comparison_input_type'
+
+module GraphQL
+  module Filters
+    module InputTypes
+      class StringComparisonInputType < BaseScalarComparisonInputType[GraphQL::Types::String]
+        argument :match,
+                 String,
+                 prepare: lambda { |value, _context|
+                   lambda { |scope, column_name|
+                     column_node = scope.table[column_name]
+                     scope.where resolve_pattern(column_node, value)
+                   }
+                 }
+
+        class << self
+          alias inspect to_s
+
+        private
+
+          def resolve_pattern column_node, expression
+            expression.match %r{v(?<version>\d)+/(?<full_pattern>.*)} do |match_data|
+              raise 'The only supported version of pattern is v1' if match_data[:version].to_i != 1
+
+              resolve_v1 column_node, match_data[:full_pattern]
+            end
+          end
+
+          def resolve_v1 column_node, full_pattern
+            full_pattern.match %r{(?<pattern>.*?)/(?<options>.*)} do |match_data|
+              options = match_data[:options].chars.map(&:to_sym)
+
+              if options.present? && options != [:i]
+                raise 'The only supported option is \'i\' for case insensitive matching'
+              end
+
+              case_sensitive = !options.include?(:i)
+
+              characters = match_data[:pattern].chars
+              pattern = ''
+
+              while characters.present?
+                char = characters.shift
+
+                pattern << case char
+                           when '\\'
+                             ActiveRecord::Base.sanitize_sql_like characters.shift
+                           when '*'
+                             '%'
+                           when '.'
+                             '_'
+                           else
+                             ActiveRecord::Base.sanitize_sql_like char
+                           end
+              end
+
+              column_node.matches pattern, nil, case_sensitive
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/filters/utility/cached_class.rb

@@ -0,0 +1,74 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/class/attribute'
+
+module GraphQL
+  module Filters
+    module Utility
+      module CachedClass
+        extend ActiveSupport::Concern
+
+        included do
+          next unless is_a? Class
+
+          class_attribute :cache,
+                          default: Hash.new { |h, k|
+                            h[k] = Class.new
+                          },
+                          instance_accessor: false,
+                          instance_predicate: false
+
+          singleton_class.delegate :[], :[]=, to: :cache
+          singleton_class.undef_method :new
+        end
+
+        class CacheClassConstructor
+          attr_reader :key
+          attr_reader :owner
+
+          delegate_missing_to :owner
+
+          def initialize key, owner
+            @key = key
+            @owner = owner
+          end
+
+          def new base_class, &block
+            klass = Class.new base_class
+            owner[key] = klass
+
+            outer_self = self
+
+            klass.define_singleton_method :inspect do
+              "#{outer_self.owner}<#{outer_self.key}>"
+            end
+
+            klass.class_exec(&block)
+            klass
+          end
+        end
+        private_constant :CacheClassConstructor
+
+        class_methods do
+          # Pass this method the block that will be called on a cache miss. The block will receive the `key` that caused
+          #   the miss, and a class constructor `klass`. Use `klass.new` instead of `Class.new` to create the class that
+          #   you want to associate with `key` in the cache. This prevents loops in the case you reference the same key
+          #   during the definition of the class. Notice that the class is first created with `Class.new`, then it is
+          #   associated with `key` in the cache, and only then it is properly defined using `class_exec` and the block
+          #   you passed to `new`, so be careful about what assumptions you make on the classes you pull from the cache
+          #   during a cache miss resolution.
+          def resolve_cache_miss &block
+            cache.default_proc = proc do |h, k|
+              class_constructor = CacheClassConstructor.new k, self
+              result = block.call k, class_constructor
+
+              h[k] = result unless h.key? k
+
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end