graphiti-activegraph 1.3.1 → 1.3.3

data/lib/graphiti/active_graph/scoping/filter.rb

@@ -1,49 +1,49 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Filter
-      include Filterable
-      include Internal::SortingAliases
-      include Extensions::QueryDsl::Performer
-
-      attr_reader :scope
-
-      def apply
-        super
-        apply_query_dsl
-      end
-
-      def each_filter
-        filter_param.each_pair do |param_name, param_value|
-          filter = find_filter!(param_name)
-
-          normalize_param(filter, param_value).each do |operator, value|
-            operator = operator.to_s.gsub("!", "not_").to_sym
-
-            # dynamic filters errors for validating and typecasting value below
-            # so they are skipped here without validation or typecast
-            filter_map = filter.values[0]
-            if filter_map[:dynamic_filter]
-              yield filter, operator, value
-              next
-            end
-            validate_operator(filter, operator)
-
-            type = ::Graphiti::Types[filter_map[:type]]
-            unless type[:canonical_name] == :hash || !value.is_a?(String)
-              value = parse_string_value(filter_map, value)
-            end
-
-            check_deny_empty_filters!(resource, filter, value)
-            value = parse_string_null(filter_map, value)
-            validate_singular(resource, filter, value)
-            value = coerce_types(filter_map, param_name.to_sym, value)
-            validate_allowlist(resource, filter, value)
-            validate_denylist(resource, filter, value)
-            value = value[0] if filter_map[:single]
-            yield filter, operator, value
-          end
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Filter
+      include Filterable
+      include Internal::SortingAliases
+      include Extensions::QueryDsl::Performer
+
+      attr_reader :scope
+
+      def apply
+        super
+        apply_query_dsl
+      end
+
+      def each_filter
+        filter_param.each_pair do |param_name, param_value|
+          filter = find_filter!(param_name)
+
+          normalize_param(filter, param_value).each do |operator, value|
+            operator = operator.to_s.gsub("!", "not_").to_sym
+
+            # dynamic filters errors for validating and typecasting value below
+            # so they are skipped here without validation or typecast
+            filter_map = filter.values[0]
+            if filter_map[:dynamic_filter]
+              yield filter, operator, value
+              next
+            end
+            validate_operator(filter, operator)
+
+            type = ::Graphiti::Types[filter_map[:type]]
+            unless type[:canonical_name] == :hash || !value.is_a?(String)
+              value = parse_string_value(filter_map, value)
+            end
+
+            check_deny_empty_filters!(resource, filter, value)
+            value = parse_string_null(filter_map, value)
+            validate_singular(resource, filter, value)
+            value = coerce_types(filter_map, param_name.to_sym, value)
+            validate_allowlist(resource, filter, value)
+            validate_denylist(resource, filter, value)
+            value = value[0] if filter_map[:single]
+            yield filter, operator, value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/filterable.rb

@@ -1,12 +1,12 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Filterable
-      def find_filter!(name)
-        val = resource.filters[name] || {
-          operators: {}, type: :string, single: false, dynamic_filter: true
-        }
-        {name => val}
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Filterable
+      def find_filter!(name)
+        val = resource.filters[name] || {
+          operators: {}, type: :string, single: false, dynamic_filter: true
+        }
+        {name => val}
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/include.rb

@@ -1,48 +1,48 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    # Handles sideloading via scoping instead of sideloading query as in original jsonapi_suite
-    # This avoids extra queries for fetching sideload
-    class Include < Graphiti::Scoping::Base
-      include Internal::SortingAliases
-
-      def custom_scope
-        nil
-      end
-
-      def apply_standard_scope
-        return scope if normalized_includes.empty? && extra_fields_includes.empty?
-
-        self.scope = resource.handle_includes(scope, normalized_includes, normalized_sorts,
-                                              extra_fields_includes:, with_vars: with_vars_for_sort, paginate: paginate?)
-      end
-
-      private
-
-      attr_accessor :scope
-
-      def query
-        @opts[:query_obj]
-      end
-
-      def extra_fields_includes
-        @extra_fields_includes ||= Internal::ExtraFieldNormalizer.new(@query_hash[:extra_fields]).normalize(resource, normalized_includes)
-      end
-
-      def paginate?
-        Graphiti::Scoping::Paginate.new(@resource, @query_hash, scope, @opts).apply?
-      end
-
-      def normalized_sorts
-        Internal::SortNormalizer.new(scope).normalize(normalized_includes, query.sorts, query.deep_sort)
-      end
-
-      def include_normalizer
-        Internal::IncludeNormalizer
-      end
-
-      def normalized_includes
-        @normalized_includes ||= include_normalizer.new(resource.class, scope, query_hash[:fields]).normalize(query.include_hash)
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    # Handles sideloading via scoping instead of sideloading query as in original jsonapi_suite
+    # This avoids extra queries for fetching sideload
+    class Include < Graphiti::Scoping::Base
+      include Internal::SortingAliases
+
+      def custom_scope
+        nil
+      end
+
+      def apply_standard_scope
+        return scope if normalized_includes.empty? && extra_fields_includes.empty?
+
+        self.scope = resource.handle_includes(scope, normalized_includes, normalized_sorts,
+                                              extra_fields_includes:, with_vars: with_vars_for_sort, paginate: paginate?)
+      end
+
+      private
+
+      attr_accessor :scope
+
+      def query
+        @opts[:query_obj]
+      end
+
+      def extra_fields_includes
+        @extra_fields_includes ||= Internal::ExtraFieldNormalizer.new(@query_hash[:extra_fields]).normalize(resource, normalized_includes)
+      end
+
+      def paginate?
+        Graphiti::Scoping::Paginate.new(@resource, @query_hash, scope, @opts).apply?
+      end
+
+      def normalized_sorts
+        Internal::SortNormalizer.new(scope).normalize(normalized_includes, query.sorts, query.deep_sort)
+      end
+
+      def include_normalizer
+        Internal::IncludeNormalizer
+      end
+
+      def normalized_includes
+        @normalized_includes ||= include_normalizer.new(resource.class, scope, query_hash[:fields]).normalize(query.include_hash)
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/extra_field_normalizer.rb

@@ -1,76 +1,76 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      class ExtraFieldNormalizer
-
-        def initialize(extra_fields)
-          @extra_fields = extra_fields
-          @extra_includes = []
-        end
-
-        def normalize(resource, normalized_includes)
-          return [] if @extra_fields.blank?
-
-          process_extra_fields_for_assoc(resource, [], '')
-          collect_extra_field_paths(resource, normalized_includes) unless normalized_includes.blank?
-          @extra_includes.uniq
-        end
-
-        private
-
-        def collect_extra_field_paths(resource, normalized_includes, parent_path = [])
-          normalized_includes.each do |assoc, nested_assoc|
-            assoc_resource = fetch_assoc_resource(resource, assoc)
-            next unless assoc_resource
-
-            process_extra_fields_for_assoc(assoc_resource, parent_path, assoc)
-            collect_extra_field_paths(assoc_resource, nested_assoc, parent_path + [assoc.to_s]) unless nested_assoc.empty?
-          end
-        end
-
-        def fetch_assoc_resource(resource, assoc)
-          rel_name = Util::Transformers::RelationParam.new(assoc).rel_name_sym
-          resource.class&.sideload_resource_class(rel_name)&.new
-        end
-
-        def process_extra_fields_for_assoc(assoc_resource, parent_path, assoc)
-          return unless @extra_fields.key?(assoc_resource.type)
-
-          Array(@extra_fields[assoc_resource.type]).each do |extra_field|   
-            add_preload_paths_for_extra_field(extra_field_config(assoc_resource, extra_field), parent_path, assoc)
-          end
-        end
-
-        def extra_field_config(assoc_resource, extra_field)
-          assoc_resource.class&.config&.dig(:extra_attributes, extra_field)
-        end
-
-        def add_preload_paths_for_extra_field(config, parent_path, assoc)
-          return unless config && config[:preload].present?
-            
-          flatten_preload_hash(config[:preload]).each do |preload|
-            @extra_includes << construct_preload_path(parent_path, assoc, preload)
-          end
-        end
-
-        def flatten_preload_hash(preload, prefix = [])
-          case preload
-          when Hash
-            preload.flat_map { |k, v| flatten_preload_hash(v, prefix + [k.to_s]) }
-          when Array
-            preload.flat_map { |v| flatten_preload_hash(v, prefix) }
-          else
-            value = preload.to_s
-            return [] if value.empty?
-
-            [(prefix + [value]).join('.')]
-          end
-        end
-
-        def construct_preload_path(parent_path, assoc, preload)
-          (parent_path + [assoc.to_s, preload.to_s]).compact_blank.join('.')
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      class ExtraFieldNormalizer
+
+        def initialize(extra_fields)
+          @extra_fields = extra_fields
+          @extra_includes = []
+        end
+
+        def normalize(resource, normalized_includes)
+          return [] if @extra_fields.blank?
+
+          process_extra_fields_for_assoc(resource, [], '')
+          collect_extra_field_paths(resource, normalized_includes) unless normalized_includes.blank?
+          @extra_includes.uniq
+        end
+
+        private
+
+        def collect_extra_field_paths(resource, normalized_includes, parent_path = [])
+          normalized_includes.each do |assoc, nested_assoc|
+            assoc_resource = fetch_assoc_resource(resource, assoc)
+            next unless assoc_resource
+
+            process_extra_fields_for_assoc(assoc_resource, parent_path, assoc)
+            collect_extra_field_paths(assoc_resource, nested_assoc, parent_path + [assoc.to_s]) unless nested_assoc.empty?
+          end
+        end
+
+        def fetch_assoc_resource(resource, assoc)
+          rel_name = Util::Transformers::RelationParam.new(assoc).rel_name_sym
+          resource.class&.sideload_resource_class(rel_name)&.new
+        end
+
+        def process_extra_fields_for_assoc(assoc_resource, parent_path, assoc)
+          return unless @extra_fields.key?(assoc_resource.type)
+
+          Array(@extra_fields[assoc_resource.type]).each do |extra_field|   
+            add_preload_paths_for_extra_field(extra_field_config(assoc_resource, extra_field), parent_path, assoc)
+          end
+        end
+
+        def extra_field_config(assoc_resource, extra_field)
+          assoc_resource.class&.config&.dig(:extra_attributes, extra_field)
+        end
+
+        def add_preload_paths_for_extra_field(config, parent_path, assoc)
+          return unless config && config[:preload].present?
+            
+          flatten_preload_hash(config[:preload]).each do |preload|
+            @extra_includes << construct_preload_path(parent_path, assoc, preload)
+          end
+        end
+
+        def flatten_preload_hash(preload, prefix = [])
+          case preload
+          when Hash
+            preload.flat_map { |k, v| flatten_preload_hash(v, prefix + [k.to_s]) }
+          when Array
+            preload.flat_map { |v| flatten_preload_hash(v, prefix) }
+          else
+            value = preload.to_s
+            return [] if value.empty?
+
+            [(prefix + [value]).join('.')]
+          end
+        end
+
+        def construct_preload_path(parent_path, assoc, preload)
+          (parent_path + [assoc.to_s, preload.to_s]).compact_blank.join('.')
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/include_normalizer.rb

@@ -1,82 +1,82 @@
-module Graphiti::ActiveGraph
-  module Scoping
-    module Internal
-      class IncludeNormalizer
-        include SparseFieldsEagerloading
-
-        def initialize(resource_class, scope, fields)
-          @scope = scope
-          @resource_class = resource_class
-          @fields = fields
-        end
-
-        def normalize(include_hash)
-          normalize_includes(@scope, include_hash, @resource_class)
-        end
-
-        private
-
-        def normalize_includes(scope, include_hash, resource_class)
-          includes_array = include_hash.map do |key, value|
-            normalize_include(scope, key, value, resource_class)
-          end
-          add_relationships_from_sparse_fields(scope, includes_array)
-          deep_merge_hashes(includes_array.compact).to_h
-        end
-
-        def deep_merge_hashes(includes_array)
-          includes_array.each_with_object({}) do |(key, value), mapping|
-            mapping[key] = mapping[key] ? mapping[key].deep_merge(value) : value
-          end.to_a
-        end
-
-        def normalize_include(scope, key, value, resource_class)
-          rel_name = rel_name_sym(key)
-
-          if scope.associations.key?(rel_name)
-            [key, normalize_includes(scope.send(rel_name), value, find_resource_class(resource_class, rel_name, scope))]
-          elsif (custom_eagerload = resource_class&.custom_eagerload(rel_name))
-            handle_custom_eagerload(scope, custom_eagerload)
-          else
-            include_for_rel(scope, rel_name, value, resource_class)
-          end
-        end
-
-        def handle_custom_eagerload(_scope, custom_eagerload)
-          JSONAPI::IncludeDirective.new(custom_eagerload).to_hash
-        end
-
-        def include_for_rel(scope, key, value, resource_class)
-          return unless association = PathDescriptor.association_for_relationship(scope.associations, rel_name: key.to_s)
-
-          limit_part = Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(value.keys.first).rel_limit
-          association_name = "#{limit_part}#{association.first}".to_sym
-          normalize_include(scope, association_name, next_non_rel_value(value), resource_class_by_rel(resource_class, association, key, scope))
-        end
-
-        def find_resource_class(resource_class, rel_name, scope)
-          target_class_name = scope.associations[rel_name]&.target_class&.model_name
-
-          resource_class&.sideload_resource_class(rel_name) ||
-            resource_class&.sideload_resource_class(target_class_name&.singular&.to_sym)
-        end
-
-        def resource_class_by_rel(resource_class, association, key, scope)
-          # in case of rel resource, for finding custom_eagerload defination
-          # if current resourceClass defination has direct association defined with opposite node of relResource
-          #   then use current resourceClass, (giving direct resourceClass more preference than relResourceClass)
-          # else use relResourceClass
-          find_resource_class(resource_class, association.first, scope) ? resource_class : resource_class&.sideload_resource_class(rel_name_sym(key))
-        end
-
-        def rel_name_sym(key)
-          Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(key).rel_name_sym
-        end
-
-        def next_non_rel_value(value)
-          value.values.first || {}
-        end
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      class IncludeNormalizer
+        include SparseFieldsEagerloading
+
+        def initialize(resource_class, scope, fields)
+          @scope = scope
+          @resource_class = resource_class
+          @fields = fields
+        end
+
+        def normalize(include_hash)
+          normalize_includes(@scope, include_hash, @resource_class)
+        end
+
+        private
+
+        def normalize_includes(scope, include_hash, resource_class)
+          includes_array = include_hash.map do |key, value|
+            normalize_include(scope, key, value, resource_class)
+          end
+          add_relationships_from_sparse_fields(scope, includes_array)
+          deep_merge_hashes(includes_array.compact).to_h
+        end
+
+        def deep_merge_hashes(includes_array)
+          includes_array.each_with_object({}) do |(key, value), mapping|
+            mapping[key] = mapping[key] ? mapping[key].deep_merge(value) : value
+          end.to_a
+        end
+
+        def normalize_include(scope, key, value, resource_class)
+          rel_name = rel_name_sym(key)
+
+          if scope.associations.key?(rel_name)
+            [key, normalize_includes(scope.send(rel_name), value, find_resource_class(resource_class, rel_name, scope))]
+          elsif (custom_eagerload = resource_class&.custom_eagerload(rel_name))
+            handle_custom_eagerload(scope, custom_eagerload)
+          else
+            include_for_rel(scope, rel_name, value, resource_class)
+          end
+        end
+
+        def handle_custom_eagerload(_scope, custom_eagerload)
+          JSONAPI::IncludeDirective.new(custom_eagerload).to_hash
+        end
+
+        def include_for_rel(scope, key, value, resource_class)
+          return unless association = PathDescriptor.association_for_relationship(scope.associations, rel_name: key.to_s)
+
+          limit_part = Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(value.keys.first).rel_limit
+          association_name = "#{limit_part}#{association.first}".to_sym
+          normalize_include(scope, association_name, next_non_rel_value(value), resource_class_by_rel(resource_class, association, key, scope))
+        end
+
+        def find_resource_class(resource_class, rel_name, scope)
+          target_class_name = scope.associations[rel_name]&.target_class&.model_name
+
+          resource_class&.sideload_resource_class(rel_name) ||
+            resource_class&.sideload_resource_class(target_class_name&.singular&.to_sym)
+        end
+
+        def resource_class_by_rel(resource_class, association, key, scope)
+          # in case of rel resource, for finding custom_eagerload defination
+          # if current resourceClass defination has direct association defined with opposite node of relResource
+          #   then use current resourceClass, (giving direct resourceClass more preference than relResourceClass)
+          # else use relResourceClass
+          find_resource_class(resource_class, association.first, scope) ? resource_class : resource_class&.sideload_resource_class(rel_name_sym(key))
+        end
+
+        def rel_name_sym(key)
+          Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(key).rel_name_sym
+        end
+
+        def next_non_rel_value(value)
+          value.values.first || {}
+        end
+      end
+    end
+  end
+end