graphql-filters 1.1.5 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4c44c55c15ade9472e7683e8929ac05e69df73da70a670888ba6882799c336e
-  data.tar.gz: ca4865a5a2b629d531ef7e3ef93f899330be5cd0b3854f998fd8ff01d985afd9
+  metadata.gz: af871adf4f20074267e23317255e81bff397756f724200e340d7d1dc878adb23
+  data.tar.gz: eaa5d6246257da87995933a8fd56ef0666a6b4e29babc24e34079fcc786f45c0
 SHA512:
-  metadata.gz: 4975b8a331db108674f279c08863382164ccc2df2e004bf435e8d6ee428a499ae7c2e963dca6c34876dd8f175843590ba1b7ca7ec6351c7d5ae5f1e39df9d2c2
-  data.tar.gz: 8ffcbcd8615883bc5a9f35757443006bc08debc157015f414724f4aff45b978de35adc8a8687575c12eb677f4183c1ce8b16e44d54fa8c2d5a3b8275ec234a2b
+  metadata.gz: 8b2aa98387e913285068058dde306b188f90a4c921a9939e41d1542e90e725572d9bd6b9b2cc2425dc88d4f3beec84b10a44171041eb79b69472bf816e799875
+  data.tar.gz: b4934e3e62c1b4c79fc37da84ad14d879b136934e0615d8030c508b8daf5c338789c941995ee515c42274d9e279e206fb5d6159bc560b39469dc324fedd79193

data/CHANGELOG.md

@@ -8,6 +8,22 @@
 ### Bug fixes
 )-->
 
+## 1.1.7 2026-07-22
+
+### New features
+
+- Added `GraphQL::Filters::Error` as the common base for gem domain errors.
+
+### Bug fixes
+
+- Invalid string match syntax now raises an explicit error `GraphQL::Filters::InputTypes::StringComparisonInputType::InvalidMatchError` for invalid string match filters. instead of returning `nil`; unsupported versions and options no longer raise a generic `RuntimeError`.
+
+## 1.1.6 2026-06-03
+
+### Bug fixes
+
+- Fixed through associations breaking nested filters.
+
 ## 1.1.5 2025-08-18
 
 ### Bug fixes

data/README.md

@@ -92,6 +92,7 @@ query {
         }
       }
     }
+  }
 }
 ```
 
@@ -99,6 +100,9 @@ Notice that eager loading is outside the scope of this gem, so without anything
 
 Each input type is generated based on the respective type: scalar and enum types allow for basic comparisons like equality and inclusion, while object types let you build complex queries that mix and match comparisons on their fields. List types let you make `any`, `all`, and `none` queries based on a nested filter. Support for null-checked filters is planned for future development.
 
+> [!NOTE]
+> Active Storage classes don't play well with GraphQL Filters. You should disable filters for their respective fields using `filter: false`. A cleaner handling of these cases is planned for future development.
+
 ### Underlying models
 
 GraphQL Filters relies on the assumption that every object type exists on top of an Active Record model. A field of type `PokemonType` will always be resolved to an instance of `Pokemon`, and its fields will match (at least loosely) the attributes of the model. This assumption allows the gem to generate appropriate subqueries for nested filters.
@@ -155,9 +159,15 @@ The best way to know what comparators you can use with each field is to open the
 `matches` is available for the `String` type. Its value is a string in the format `<version>/<pattern>/<options>`.
 
 - At the moment, `<version>` can only be `v1`, but extensions are planned for future development.
-- For version `v1`, `<pattern>` will match a `.` with any one character and a `*` with zero or more characters. To match any literal character you can prefix it with `\​`.
+- For version `v1`, `<pattern>` will match a `.` with any one character and a `*` with zero or more characters. To match any literal character you can prefix it with `\`.
 - For version `v1`, `<options>` can be empty, or be `i`, which will make the match case insensitive.
 
+> [!NOTE]
+> This is *not* a regex engine, just a simple wildcard matcher.
+
+Malformed match syntax, unsupported pattern versions, and unsupported options raise
+`GraphQL::Filters::InputTypes::StringComparisonInputType::InvalidMatchError`.
+
 #### List comparisons
 
 `any`, `all`, and `none` are available for any list, take a comparator for the type of the elements of the list, and match, respectively, if at least one, all, or none, of the elements of the list match the nested comparator.
@@ -236,6 +246,163 @@ field :name, String, null: false, filter: {enabled: false}
  
   The type the filters for this field need to be based on, if it's different from the field's own type (for example, a field thet returns a connection will need to be filtered based on the connection's node type). Can also be set calling the `filtered_type` on a resolver/mutation if the field is associated with one.
 
+### API usage examples
+
+To get all pokémon whose main color is blue:
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      fields: {
+        mainColor: { equals: "blue" }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all pokémon whose main color is either blue or red:
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      fields: {
+        mainColor: { in: ["blue", "red"] }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all pokémon whose name begins with 's':
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      fields: {
+        name: { match: "v1/s*/i" }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all pokémon whose base friendship is 70 or whose catch rate is more than 100:
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      or: [
+        {
+          fields: {
+            baseFriendship: { equals: 70 }
+          }
+        }
+        {
+          fields: {
+            catchRate: { greaterThanOrEqualsTo: 100 }
+          }
+        }
+      ]
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all pokémon that evolve from Eevee:
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      fields: {
+        preEvolution: {
+          fields: {
+            name: { equals: "Eevee" }
+          }
+        }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all pokémon catchable in the Kanto route 1:
+
+```graphql
+query{
+  pokemons(
+    filter: {
+      fields: {
+        routes: {
+          any: {
+            fields: {
+              name: { equals: "1" }
+              region: {
+                fields: {
+                  name: { equals: "Kanto" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
+To get all routes in Kanto where you can catch a water type pokémon (this is the example at the top of the page):
+
+```graphql
+query {
+  routes(
+    filter: {
+      fields: {
+        region: {
+          fields: {
+            name: { equals: "Kanto" }
+          }
+        },
+        catchablePokemon: {
+          any: {
+            fields: {
+              pokemon: {
+                types: {
+                  any: {
+                    fields: {
+                      name: { equals: "Water"}
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ){
+  ...
+  }
+}
+```
+
 ## Plans for future development
 
 - A finer grain support for non-nullable fields.

data/lib/graphql/filters/error.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Filters
+    class Error < StandardError; end
+  end
+end

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

@@ -55,7 +55,18 @@ module GraphQL
 
                   scope.and nested_query
                 else
-                  scope.where association_name => nested_query
+                  reflection = scope.klass.reflect_on_association association_name
+
+                  if reflection.through_reflection?
+                    through_reflection = reflection.through_reflection
+                    scope.where(
+                      through_reflection.name => through_reflection.klass.where(
+                        reflection.source_reflection.name => nested_query
+                      )
+                    )
+                  else
+                    scope.where association_name => nested_query
+                  end
                 end
               end
             end

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

@@ -4,6 +4,8 @@ module GraphQL
   module Filters
     module InputTypes
       class StringComparisonInputType < BaseScalarComparisonInputType[GraphQL::Types::String]
+        class InvalidMatchError < GraphQL::Filters::Error; end
+
         argument :match,
                  String,
                  prepare: lambda { |value, _context|
@@ -19,43 +21,45 @@ module GraphQL
         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
+            match_data = expression.match %r{\Av(?<version>\d+)/(?<full_pattern>.*)\z}
+            raise InvalidMatchError, 'Invalid match filter syntax. Expected v1/<v1_pattern>.' unless match_data
 
-              resolve_v1 column_node, match_data[:full_pattern]
-            end
+            raise InvalidMatchError, 'The only supported version of pattern is v1' if match_data[:version].to_i != 1
+
+            resolve_v1 column_node, match_data[:full_pattern]
           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)
+            match_data = full_pattern.match %r{\A(?<pattern>.*?)/(?<options>.*)\z}
+            raise InvalidMatchError, 'Invalid match filter syntax for version v1. Expected v1/<pattern>/<options>.' unless match_data
 
-              if options.present? && options != [:i]
-                raise 'The only supported option is \'i\' for case insensitive matching'
-              end
+            options = match_data[:options].chars.map(&:to_sym)
 
-              case_sensitive = !options.include?(:i)
+            if options.present? && options != [:i]
+              raise InvalidMatchError, 'The only supported option is \'i\' for case insensitive matching'
+            end
 
-              characters = match_data[:pattern].chars
-              pattern = ''
+            case_sensitive = !options.include?(:i)
 
-              while characters.present?
-                char = characters.shift
+            characters = match_data[:pattern].chars
+            pattern = ''
 
-                pattern << case char
-                           when '\\'
-                             ActiveRecord::Base.sanitize_sql_like characters.shift
-                           when '*'
-                             '%'
-                           when '.'
-                             '_'
-                           else
-                             ActiveRecord::Base.sanitize_sql_like char
-                           end
-              end
+            while characters.present?
+              char = characters.shift
 
-              column_node.matches pattern, nil, case_sensitive
+              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

data/lib/graphql/filters/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Filters
-    VERSION = '1.1.5'.freeze
+    VERSION = '1.1.7'.freeze
   end
 end

data/lib/graphql/filters.rb

@@ -21,6 +21,7 @@ end
 
 # These need to be here, after the definition of GraphQL::Filters
 
+require_relative 'filters/error'
 require_relative 'filters/activerecord_patch'
 require_relative 'filters/dsl'
 require_relative 'filters/filterable'

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-filters
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.7
 platform: ruby
 authors:
 - Moku S.r.l.
 - Riccardo Agatea
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -112,6 +111,7 @@ files:
 - lib/graphql/filters/dsl/graphql/schema/scalar.rb
 - lib/graphql/filters/dsl/graphql/types/numeric.rb
 - lib/graphql/filters/dsl/graphql/types/string.rb
+- lib/graphql/filters/error.rb
 - lib/graphql/filters/filterable.rb
 - lib/graphql/filters/input_types/base_comparison_input_type.rb
 - lib/graphql/filters/input_types/base_list_comparison_input_type.rb
@@ -131,7 +131,6 @@ metadata:
   homepage_uri: https://github.com/moku-io/graphql-filters
   source_code_uri: https://github.com/moku-io/graphql-filters
   changelog_uri: https://github.com/moku-io/graphql-filters/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -146,8 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Provide a fully typed interface to filter lists in a GraphQL API.
 test_files: []