graphiti-activegraph 1.3.0 → 1.3.2

data/lib/graphiti/active_graph/deserializer.rb

@@ -1,141 +1,138 @@
-module Graphiti::ActiveGraph
-  class Deserializer < Graphiti::Deserializer
-    include Concerns::PathRelationships
-
-    class Conflict < StandardError
-      attr_reader :key, :path_value, :body_value
-
-      def initialize(key, path_value, body_value)
-        @key = key
-        @path_value = path_value
-        @body_value = body_value
-      end
-
-      def message
-        "Path parameter #{key} with value '#{path_value}' conflicts with payload value '#{body_value}'"
-      end
-    end
-
-    def initialize(payload, env = nil, model = nil, parent_map = nil)
-      super(payload)
-
-      @params = payload
-      @model = model
-      @parent_map = parent_map || {}
-      @env = env
-
-      return unless data.blank? && env && parsable_content?
-
-      raise ArgumentError, "JSON API payload must contain the 'data' key" 
-    end
-
-    def process_relationship_datum(datum)
-      {
-        meta: {
-          jsonapi_type: datum[:type],
-          temp_id: datum[:'temp-id'],
-          method: datum[:method]&.to_sym
-        },
-        attributes: datum[:id] ? { id: datum[:id] } : {},
-        relationships: {}
-      }
-    end
-
-    def meta_params
-      data[:meta] || {}
-    end
-
-    def process_relationships(relationship_hash)
-      {}.tap do |hash|
-        relationship_hash.each_pair do |name, relationship_payload|
-          name = name.to_sym
-          data_payload = relationship_payload[:data]
-          hash[name] = data_payload.nil? ? process_nil_relationship(name) : process_relationship(relationship_payload[:data])
-        end
-      end
-    end
-
-    def relationship?(name)
-      relationships[name.to_sym].present?
-    end
-
-    # change empty relationship as `disassociate` hash so they will be removed
-    def process_nil_relationship(name)
-      attributes = {}
-      method_name = :disassociate
-
-      {
-        meta: {
-          jsonapi_type: name.to_sym,
-          method: method_name
-        },
-        attributes: attributes,
-        relationships: {}
-      }
-    end
-
-    def meta(action: nil)
-      results = super
-      return results if action.present? || @env.nil?
-
-      action = case @env['REQUEST_METHOD']
-               when 'POST' then :create
-               when 'PUT', 'PATCH' then :update
-               when 'DELETE' then :destroy
-               end
-
-      results[:method] = action
-      results
-    end
-
-    def path_map
-      map = @params.select { |key, _| key =~ /_id$/ }.permit!.to_h
-      map = filter_keys(map) { |key| key.gsub(/_id$/, '').to_sym }
-      map = filter_keys(map) { |key| @parent_map[key] || key }
-      map = filter_keys_presence(map) if @model < ActiveGraph::Node
-      map
-    end
-
-    def filter_keys_presence(map)
-      filter_keys(map) { |key| presence(key) || presence(key.to_s.pluralize.to_sym) }
-    end
-
-    def filter_keys(map)
-      map.map { |key, v| [yield(key), v] }.select(&:first).to_h
-    end
-
-    def presence(key)
-      key if @model.associations.include?(key)
-    end
-
-    def detect_conflict(key, path_value, body_value)
-      raise Conflict.new(key, path_value, body_value) if path_value && body_value && body_value != path_value
-    end
-
-    private
-
-    def parsable_content?
-      true
-    end
-
-    def derive_resource_type(rel_name)
-      if @model.include?(ActiveGraph::Node)
-        @model.associations[rel_name].target_class.model_name.plural.to_s
-      else
-        # ApplicationRelationship resource doesn't have #associations or any other method to list all associations
-        # "from_class" and "to_class" methods can contain value "any". Which makes it unreliable to use here
-        # Using "rel_name.to_s.pluralize" as it works in most cases.
-        # User can define a method on controller "" which will override this behaviour
-        derive_resource_type_from_controller(rel_name) || rel_name.to_s.pluralize
-      end
-    end
-
-    def derive_resource_type_from_controller(rel_name)
-      controller_obj.derive_parent_resource_type(rel_name) if controller_obj.respond_to?(:derive_parent_resource_type)
-    end
-
-    def controller_obj
-      @controller_obj ||= Graphiti.context[:object]
-    end
-  end
-end
+module Graphiti::ActiveGraph
+  class Deserializer < Graphiti::Deserializer
+    include Concerns::PathRelationships
+    include Concerns::Relationships
+
+    class Conflict < StandardError
+      attr_reader :key, :path_value, :body_value
+
+      def initialize(key, path_value, body_value)
+        @key = key
+        @path_value = path_value
+        @body_value = body_value
+      end
+
+      def message
+        "Path parameter #{key} with value '#{path_value}' conflicts with payload value '#{body_value}'"
+      end
+    end
+
+    def initialize(payload, env = nil, model = nil, parent_map = nil)
+      super(payload)
+
+      @params = payload
+      @model = model
+      @parent_map = parent_map || {}
+      @env = env
+
+      return unless data.blank? && env && parsable_content?
+
+      raise ArgumentError, "JSON API payload must contain the 'data' key" 
+    end
+
+    def process_relationship_datum(datum)
+      {
+        meta: {
+          jsonapi_type: datum[:type],
+          temp_id: datum[:'temp-id'],
+          method: datum[:method]&.to_sym
+        },
+        attributes: datum[:id] ? { id: datum[:id] } : {},
+        relationships: {}
+      }
+    end
+
+    def meta_params
+      data[:meta] || {}
+    end
+
+    def process_relationships(relationship_hash)
+      {}.tap do |hash|
+        relationship_hash.each_pair do |name, relationship_payload|
+          name = name.to_sym
+          data_payload = relationship_payload[:data]
+          hash[name] = data_payload.nil? ? process_nil_relationship(name) : process_relationship(relationship_payload[:data])
+        end
+      end
+    end
+
+    # change empty relationship as `disassociate` hash so they will be removed
+    def process_nil_relationship(name)
+      attributes = {}
+      method_name = :disassociate
+
+      {
+        meta: {
+          jsonapi_type: name.to_sym,
+          method: method_name
+        },
+        attributes: attributes,
+        relationships: {}
+      }
+    end
+
+    def meta(action: nil)
+      results = super
+      return results if action.present? || @env.nil?
+
+      action = case @env['REQUEST_METHOD']
+               when 'POST' then :create
+               when 'PUT', 'PATCH' then :update
+               when 'DELETE' then :destroy
+               end
+
+      results[:method] = action
+      results
+    end
+
+    def path_map
+      map = @params.select { |key, _| key =~ /_id$/ }.permit!.to_h
+      map = filter_keys(map) { |key| key.gsub(/_id$/, '').to_sym }
+      map = filter_keys(map) { |key| @parent_map[key] || key }
+      map = filter_keys_presence(map) if @model < ActiveGraph::Node
+      map
+    end
+
+    def filter_keys_presence(map)
+      filter_keys(map) { |key| presence(key) || presence(key.to_s.pluralize.to_sym) }
+    end
+
+    def filter_keys(map)
+      map.map { |key, v| [yield(key), v] }.select(&:first).to_h
+    end
+
+    def presence(key)
+      key if @model.associations.include?(key)
+    end
+
+    def detect_conflict(key, path_value, body_value)
+      raise Conflict.new(key, path_value, body_value) if path_value && body_value && body_value != path_value
+    end
+
+    private
+
+    def parsable_content?
+      true
+    end
+
+    def derive_resource_type(rel_name)
+      if @model.include?(ActiveGraph::Node)
+        @model.associations[rel_name].target_class.model_name.plural.to_s
+      else
+        # ApplicationRelationship resource doesn't have #associations or any other method to list all associations
+        # "from_class" and "to_class" methods can contain value "any". Which makes it unreliable to use here
+        # Using "rel_name.to_s.pluralize" as it works in most cases.
+        # User can define a method on controller "" which will override this behaviour
+        derive_resource_type_from_controller(rel_name) || rel_name.to_s.pluralize
+      end
+    end
+
+    def derive_resource_type_from_controller(rel_name)
+      controller_obj.derive_parent_resource_type(rel_name) if controller_obj.respond_to?(:derive_parent_resource_type)
+    end
+
+    def controller_obj
+      @controller_obj ||= Graphiti.context[:object]
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/context.rb

@@ -1,17 +1,17 @@
-module Graphiti::ActiveGraph::Extensions
-  require 'ostruct' if RUBY_PLATFORM != 'java'
-
-  module Context
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def context
-        Thread.current.thread_variable_get(:context) || {}.tap(&method(:context=))
-      end
-
-      def context=(val)
-        Thread.current.thread_variable_set(:context, val)
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph::Extensions
+  require 'ostruct' if RUBY_PLATFORM != 'java'
+
+  module Context
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def context
+        Thread.current.thread_variable_get(:context) || {}.tap(&method(:context=))
+      end
+
+      def context=(val)
+        Thread.current.thread_variable_set(:context, val)
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/grouping/params.rb

@@ -1,52 +1,101 @@
-module Graphiti::ActiveGraph::Extensions::Grouping
-  class Params
-    attr_reader :params, :grouping_criteria_list, :resource_class
-    def initialize(params, resource_class)
-      @params = params
-      @grouping_criteria_list = params.fetch(:group_by, nil)&.split(',') || []
-      @resource_class = resource_class
-    end
-
-    def single_grouping_criteria?
-      grouping_criteria_list.size < 2
-    end
-
-    def grouping_criteria_on_attribute?
-      grouping_criteria_list.any? { |criteria| ends_with_attribute?(resource_class.model, criteria) }
-    end
-
-    def empty?
-      grouping_criteria_list.empty?
-    end
-
-    def ends_with_attribute?(model, criteria)
-      return false if criteria.blank?
-
-      last_segment_attribute?(model, criteria.split('.'))
-    end
-
-    private
-
-    def last_segment_attribute?(model, segments)
-      last_segment = segments.last
-      intermediate_model = traverse_to_last_associated_model(model, segments[0...-1])
-
-      intermediate_model && attribute?(intermediate_model, last_segment)
-    end
-
-    def traverse_to_last_associated_model(model, intermediate_segments)
-      intermediate_segments.each do |segment|
-        return false unless(model = associated_model(model, segment))
-      end
-      model
-    end
-
-    def attribute?(model, segment)
-      model.attribute_names.include?(segment)
-    end
-
-    def associated_model(model, segment)
-      model.associations[segment.to_sym]&.target_class
-    end
-  end
-end
+module Graphiti::ActiveGraph::Extensions::Grouping
+  class Params
+    attr_reader :params, :grouping_criteria_list, :resource_class
+
+    def initialize(params, resource_class)
+      @params = params
+      group_by_string = params.fetch(:group_by, nil)
+      @grouping_criteria_list = split_grouping_criteria(group_by_string)
+      @resource_class = resource_class
+    end
+
+    def single_grouping_criteria?
+      grouping_criteria_list.size < 2
+    end
+
+    def grouping_criteria_on_attribute?
+      grouping_criteria_list.any? { |criteria| ends_with_attribute?(resource_class.model, criteria) }
+    end
+
+    def empty?
+      grouping_criteria_list.empty?
+    end
+
+    def ends_with_attribute?(model, criteria)
+      return false if criteria.blank?
+
+      last_segment_attribute?(model, criteria.split('.'))
+    end
+
+    private
+
+    def last_segment_attribute?(model, segments)
+      last_segment = segments.last
+      intermediate_model = traverse_to_last_associated_model(model, segments[0...-1])
+
+      intermediate_model && attribute?(intermediate_model, last_segment)
+    end
+
+    def traverse_to_last_associated_model(model, intermediate_segments)
+      intermediate_segments.each do |segment|
+        return false unless (model = associated_model(model, segment))
+      end
+      model
+    end
+
+    def attribute?(model, segment)
+      model.attribute_names.include?(segment)
+    end
+
+    def associated_model(model, segment)
+      model.associations[segment.to_sym]&.target_class
+    end
+
+    def split_grouping_criteria(group_by_string)
+      return [] if group_by_string.nil? || group_by_string.empty?
+
+      result = []
+      current = ''
+      depth = 0
+
+      group_by_string.each_char do |char|
+        depth, current = process_char(char, depth, current, result)
+      end
+
+      add_criterion(result, current)
+      handle_mismatched_parentheses(result, depth)
+    end
+
+    def process_char(char, depth, current, result)
+      case char
+      when '(' then [depth + 1, current + char]
+      when ')' then [depth - 1, current + char]
+      when ',' then process_comma(depth, current, result)
+      else [depth, current + char]
+      end
+    end
+
+    def process_comma(depth, current, result)
+      if depth <= 0
+        add_criterion(result, current)
+        [depth, '']
+      else
+        [depth, current + ',']
+      end
+    end
+
+    def add_criterion(result, current)
+      stripped = current.strip
+      result << stripped unless stripped.empty?
+    end
+
+    def handle_mismatched_parentheses(result, final_depth)
+      return result if final_depth <= 0 || result.empty?
+
+      # If we ended with unclosed parentheses, re-split the last segment
+      last_segment = result.pop
+      result.concat(last_segment.split(',').map(&:strip).reject(&:empty?))
+      result
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/query_dsl/performer.rb

@@ -0,0 +1,38 @@
+module Graphiti::ActiveGraph::Extensions::QueryDsl
+  module Performer
+    attr_accessor :with_vars, :skip_arrow_cypher_rels
+
+    def apply_query_dsl
+      query_param = resource.context&.params&.[](:query)
+      query_param.present? ? apply_query_param(query_param) : scope
+    end
+
+    def apply_query_param(query_param)
+      @scope = query_generator.new(query_param, **query_generator_config).tap do |qg|
+        qg.generate_functions_optional_match
+        qg.generate_with_clause_partition_query
+        qg.generate_match_query
+        qg.generate_with_clause_query
+      end.query
+    end
+
+    private
+
+    def query_generator
+      Graphiti::ActiveGraph::Extensions::QueryDsl::QueryGenerator
+    end
+
+    def query_generator_config
+      {
+        query: scope,
+        with_vars_to_carry:,
+        skip_arrow_cypher_rels: skip_arrow_cypher_rels || [],
+        resource: resource.class
+      }
+    end
+
+    def with_vars_to_carry
+      (query ? with_vars_for_sort : []).push(*with_vars).push(*Graphiti.context[:with_vars]).compact
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/query_dsl/query_generator.rb

@@ -0,0 +1,20 @@
+module Graphiti::ActiveGraph::Extensions::QueryDsl
+  class QueryGenerator
+    def initialize(query_param, query:, **config)
+      @query_param = query_param
+      @query = query
+    end
+
+    def generate_functions_optional_match
+    end
+
+    def generate_with_clause_partition_query
+    end
+
+    def generate_match_query
+    end
+
+    def generate_with_clause_query
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/query_params.rb

@@ -1,27 +1,27 @@
-module Graphiti::ActiveGraph::Extensions
-  class QueryParams
-    attr_reader :params, :grouping_extra_params, :resource_class
-
-    def initialize(params, resource_class, grouping_extra_params: {})
-      @params = params
-      @resource_class = resource_class
-      @grouping_extra_params = grouping_extra_params
-    end
-
-    def group_by
-      Grouping::Params.new(params, resource_class)
-    end
-
-    def group_by_params
-      group_by_params_hash unless group_by.empty?
-    end
-
-    def group_by_params_hash
-      { group_by: group_by.grouping_criteria_list }.merge(grouping_extra_params)
-    end
-
-    def extra_field?(type, name)
-      params.dig(:extra_fields, type)&.include?(name.to_s)
-    end
-  end
-end
+module Graphiti::ActiveGraph::Extensions
+  class QueryParams
+    attr_reader :params, :grouping_extra_params, :resource_class
+
+    def initialize(params, resource_class, grouping_extra_params: {})
+      @params = params
+      @resource_class = resource_class
+      @grouping_extra_params = grouping_extra_params
+    end
+
+    def group_by
+      Grouping::Params.new(params, resource_class)
+    end
+
+    def group_by_params
+      group_by_params_hash unless group_by.empty?
+    end
+
+    def group_by_params_hash
+      { group_by: group_by.grouping_criteria_list }.merge(grouping_extra_params)
+    end
+
+    def extra_field?(type, name)
+      params.dig(:extra_fields, type)&.include?(name.to_s)
+    end
+  end
+end

data/lib/graphiti/active_graph/extensions/resources/authorizationable.rb

@@ -1,29 +1,29 @@
-module Graphiti::ActiveGraph::Extensions::Resources
-  module Authorizationable
-    extend ActiveSupport::Concern
-
-    included do
-      class << self
-        attr_reader :authorize_attributes
-      end
-    end
-
-    class_methods do
-      def attribute_authorization
-        @authorize_attributes = true
-      end
-
-      def authorize_attributes?
-        @authorize_attributes
-      end
-
-      def readable_attributes
-        attributes.select { |_attr_name, options_map| options_map[:readable] }
-      end
-
-      def readable_sideloads
-        sideloads.select { |_sideloads_name, sideload_obj| sideload_obj.readable? }
-      end
-    end
-  end
-end
+module Graphiti::ActiveGraph::Extensions::Resources
+  module Authorizationable
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_reader :authorize_attributes
+      end
+    end
+
+    class_methods do
+      def attribute_authorization
+        @authorize_attributes = true
+      end
+
+      def authorize_attributes?
+        @authorize_attributes
+      end
+
+      def readable_attributes
+        attributes.select { |_attr_name, options_map| options_map[:readable] }
+      end
+
+      def readable_sideloads
+        sideloads.select { |_sideloads_name, sideload_obj| sideload_obj.readable? }
+      end
+    end
+  end
+end