jpie 2.1.2 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d80d347b9e33b07e48e743d38c6e8dce2423888c49f8b727b52c3f093b835d45
-  data.tar.gz: befcf097a0471378554ec98e328546be5426d812ac48ea2428da42b71221b783
+  metadata.gz: ff291316aa0dff52e52421edfb945d6c450224761af9552da4cf80c5d5939385
+  data.tar.gz: d20184a0ff94d93da07a167088fdd5ea12346698e5324554a9ee5b4e232784f6
 SHA512:
-  metadata.gz: b01847d08978c2df2e270e36e231bbf21cfc93824a1c9519c2b982d819777050a21df3252183819f218c4d44b420f8161f9857c5add05900a663f11be87405b6
-  data.tar.gz: 8c89e6f2502308dddf7b72edffd8e58603bf664b7b6401ab9b7d100ad55024f25f2df46791b45d0097b6647a1de1fda7ef17363cc8ec83fd6f8e3691e2598302
+  metadata.gz: 5ef0a9f42b050d26a21545044b985d5deb9cd3417e073e5ec26d9fc462f954c687c547fd850f1a93b3bd7567d0d1b24418f289b61373792a5f6b7005af90885c
+  data.tar.gz: fa80175057fb038cc79ec2c3ee5fa01ac33758c72fd4f618369cd245f8dd3a4c2a2c8c7612ed2ff49f49374514aafb27abab55c801866821a92ae502582c2970

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (2.1.2)
+    jpie (2.1.3)
       actionpack (~> 8.1, >= 8.1.0)
       pg_query (>= 4)
       prosopite (>= 1)

data/lib/json_api/controllers/concerns/resource_actions/filter_validation.rb

@@ -21,26 +21,15 @@ module JSONAPI
         check_filter_parts(parts, @resource_class, model_class)
       end
 
-      def check_filter_parts(parts, res_cls, mod_cls, allow_related: false)
+      def check_filter_parts(parts, res_cls, mod_cls)
         return false if parts.empty?
-        return single_filter_valid?(parts.first, res_cls, mod_cls, allow_related) if parts.length == 1
+        return single_filter_valid?(parts.first, res_cls) if parts.length == 1
 
         check_nested_filter(parts, res_cls, mod_cls)
       end
 
-      def single_filter_valid?(name, res_cls, mod_cls, allow_related)
-        return true if res_cls.permitted_filters.map(&:to_s).include?(name)
-        return false unless allow_related
-
-        related_column_valid?(name, mod_cls)
-      end
-
-      def related_column_valid?(name, mod_cls)
-        col = parse_column_filter(name)
-        return true if col && mod_cls.column_for_attribute(col[:column])
-        return true if mod_cls.column_names.include?(name)
-
-        mod_cls.respond_to?(name.to_sym)
+      def single_filter_valid?(name, res_cls)
+        res_cls.permitted_filters.map(&:to_s).include?(name)
       end
 
       def check_nested_filter(parts, res_cls, mod_cls)
@@ -59,7 +48,7 @@ module JSONAPI
         rel_res = JSONAPI::Resource.resource_for_model(rel_mod)
         return false unless rel_res
 
-        check_filter_parts(parts, rel_res, rel_mod, allow_related: true)
+        check_filter_parts(parts, rel_res, rel_mod)
       end
 
       def filter_rel_allowed?(res_cls, rel)

data/lib/json_api/support/concerns/condition_building.rb

@@ -13,8 +13,6 @@ module JSONAPI
       end
 
       def normalize_filter_value_for_model(model, column, raw_value)
-        return nil unless column
-
         value = raw_value.is_a?(Array) ? raw_value.first : raw_value
         return nil if value.nil?
 
@@ -39,6 +37,19 @@ module JSONAPI
         lower_attr.matches(pattern.downcase)
       end
 
+      def apply_column_filter(scope, model, filter_name, raw_value)
+        column_filter = parse_column_filter(filter_name)
+        return nil unless column_filter
+        return nil unless model.column_names.include?(column_filter[:column])
+
+        column = model.column_for_attribute(column_filter[:column])
+        value = normalize_filter_value_for_model(model, column, raw_value)
+        return nil unless value
+
+        condition = build_condition(model, column, value, column_filter[:operator])
+        condition ? apply_condition(scope, condition) : nil
+      end
+
       def apply_condition(scope, condition)
         scope.where(condition)
       end

data/lib/json_api/support/concerns/nested_filters.rb

@@ -81,40 +81,12 @@ module JSONAPI
       def apply_filter_on_model(scope, target_model, target_resource, filter_name, filter_value)
         return scope if empty_filter_value?(filter_value)
 
-        apply_column_operator_filter(scope, target_model, filter_name, filter_value) ||
-          apply_direct_column_filter(scope, target_model, filter_name, filter_value) ||
+        apply_column_filter(scope, target_model, filter_name, filter_value) ||
           apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value) ||
           scope
       end
 
-      def apply_column_operator_filter(scope, target_model, filter_name, filter_value)
-        column_filter = parse_column_filter(filter_name)
-        return nil unless column_filter
-
-        column = target_model.column_for_attribute(column_filter[:column])
-        return nil unless column
-
-        value = normalize_filter_value_for_model(target_model, column, filter_value)
-        return nil unless value
-
-        condition = build_condition(target_model, column, value, column_filter[:operator])
-        condition ? apply_condition(scope, condition) : nil
-      end
-
-      def apply_direct_column_filter(scope, target_model, filter_name, filter_value)
-        return nil unless target_model.column_names.include?(filter_name)
-
-        scope.where(target_model.table_name => { filter_name => filter_value })
-      end
-
-      def apply_scope_method_filter(scope, target_model, target_resource, filter_name, filter_value)
-        if target_model.respond_to?(filter_name.to_sym)
-          return try_scope_method(scope, target_model, filter_name,
-                                  filter_value,)
-        end
-
-        return nil unless target_resource
-        return nil unless target_resource.permitted_filters.map(&:to_s).include?(filter_name)
+      def apply_scope_method_filter(scope, target_model, _target_resource, filter_name, filter_value)
         return nil unless target_model.respond_to?(filter_name.to_sym)
 
         try_scope_method(scope, target_model, filter_name, filter_value)

data/lib/json_api/support/concerns/regular_filters.rb

@@ -19,36 +19,8 @@ module JSONAPI
       def apply_regular_filter(scope, filter_name, filter_value)
         return scope if empty_filter_value?(filter_value)
 
-        column_filter = parse_column_filter(filter_name)
-        if column_filter
-          apply_column_filter(scope, column_filter, filter_value)
-        else
+        apply_column_filter(scope, model_class, filter_name, filter_value) ||
           apply_scope_fallback(scope, filter_name, filter_value)
-        end
-      end
-
-      def apply_column_filter(scope, column_filter, raw_value)
-        condition = build_column_condition(column_filter, raw_value)
-        condition ? apply_condition(scope, condition) : scope
-      rescue StandardError => e
-        log_filter_error(column_filter, column_filter[:operator], e)
-        scope
-      end
-
-      def build_column_condition(column_filter, raw_value)
-        column = model_class.column_for_attribute(column_filter[:column])
-        return nil unless column
-
-        value = normalize_filter_value_for_model(model_class, column, raw_value)
-        return nil if value.nil?
-
-        build_condition(model_class, column, value, column_filter[:operator])
-      end
-
-      def log_filter_error(column_filter, operator, error)
-        return unless defined?(Rails.logger)
-
-        Rails.logger.warn("Filter error for #{column_filter[:column]}_#{operator}: #{error.class} - #{error.message}")
       end
 
       def apply_scope_fallback(scope, filter_name, filter_value)

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "2.1.2"
+  VERSION = "2.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.1.3
 platform: ruby
 authors:
 - Emil Kampp