neo4j 5.2.15 → 6.0.0.alpha.1

data/lib/neo4j/active_node/labels/index.rb

@@ -0,0 +1,87 @@
+module Neo4j::ActiveNode::Labels
+  module Index
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :declared_properties, :indexed_properties
+
+      # Creates a Neo4j index on given property
+      #
+      # This can also be done on the property directly, see Neo4j::ActiveNode::Property::ClassMethods#property.
+      #
+      # @param [Symbol] property the property we want a Neo4j index on
+      #
+      # @example
+      #   class Person
+      #      include Neo4j::ActiveNode
+      #      property :name
+      #      index :name
+      #    end
+      def index(property)
+        Neo4j::Session.on_next_session_available do |_|
+          declared_properties.index_or_fail!(property, id_property_name)
+          schema_create_operation(:index, property)
+        end
+      end
+
+      # Creates a neo4j constraint on this class for given property
+      #
+      # @example
+      #   Person.constraint :name, type: :unique
+      def constraint(property, constraints = {type: :unique})
+        Neo4j::Session.on_next_session_available do
+          declared_properties.constraint_or_fail!(property, id_property_name)
+          schema_create_operation(:constraint, property, constraints)
+        end
+      end
+
+      # @param [Symbol] property The name of the property index to be dropped
+      def drop_index(property, options = {})
+        Neo4j::Session.on_next_session_available do
+          declared_properties[property].unindex! if declared_properties[property]
+          schema_drop_operation(:index, property, options)
+        end
+      end
+
+      # @param [Symbol] property The name of the property constraint to be dropped
+      # @param [Hash] constraint The constraint type to be dropped.
+      def drop_constraint(property, constraint = {type: :unique})
+        Neo4j::Session.on_next_session_available do
+          declared_properties[property].unconstraint! if declared_properties[property]
+          schema_drop_operation(:constraint, property, constraint)
+        end
+      end
+
+      def index?(property)
+        mapped_label.indexes[:property_keys].include?([property])
+      end
+
+      def constraint?(property)
+        mapped_label.unique_constraints[:property_keys].include?([property])
+      end
+
+      private
+
+      def schema_create_operation(type, property, options = {})
+        new_schema_class(type, property, options).create!
+      end
+
+      def schema_drop_operation(type, property, options = {})
+        new_schema_class(type, property, options).drop!
+      end
+
+      def new_schema_class(type, property, options)
+        case type
+        when :index
+          Neo4j::Schema::ExactIndexOperation
+        when :constraint
+          Neo4j::Schema::UniqueConstraintOperation
+        else
+          fail "Unknown Schema Operation class #{type}"
+        end.new(mapped_label_name, property, options)
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/persistence.rb

@@ -40,7 +40,7 @@ module Neo4j::ActiveNode
     # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
     # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
     def save!(*args)
-      fail RecordInvalidError, self unless save(*args)
+      save(*args) or fail(RecordInvalidError, self) # rubocop:disable Style/AndOr
     end
 
     # Creates a model with values matching those of the instance attributes and returns its id.
@@ -130,8 +130,9 @@ module Neo4j::ActiveNode
 
       def find_or_create(find_attributes, set_attributes = {})
         on_create_attributes = set_attributes.merge(on_create_props(find_attributes))
+        on_match_attributes =  set_attributes.merge(on_match_props)
         neo4j_session.query.merge(n: {self.mapped_label_names => find_attributes})
-          .on_create_set(n: on_create_attributes)
+          .on_create_set(n: on_create_attributes).on_match_set(n: on_match_attributes)
           .pluck(:n).first
       end
 

data/lib/neo4j/active_node/query.rb

@@ -68,7 +68,7 @@ module Neo4j
         # @param [String, Symbol] node_var A string or symbol to use as the starting identifier.
         # @return [Neo4j::ActiveNode::Query::QueryProxy]
         def as(node_var)
-          query_proxy(node: node_var)
+          query_proxy(node: node_var, context: self.name)
         end
       end
     end

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -149,13 +149,9 @@ module Neo4j
         alias_method :order_by, :order
 
         # Cypher string for the QueryProxy's query. This will not include params. For the full output, see <tt>to_cypher_with_params</tt>.
-        def to_cypher(*args)
-          query.to_cypher(*args)
-        end
+        delegate :to_cypher, to: :query
 
-        def print_cypher
-          query.print_cypher
-        end
+        delegate :print_cypher, to: :query
 
         # Returns a string of the cypher query with return objects and params
         # @param [Array] columns array containing symbols of identifiers used in the query
@@ -167,7 +163,7 @@ module Neo4j
 
         # To add a relationship for the node for the association on this QueryProxy
         def <<(other_node)
-          @start_object._persisted_obj ? create(other_node, {}) : defer_create(other_node, {}, :<<)
+          @start_object._persisted_obj ? create(other_node, {}) : defer_create(other_node)
           self
         end
 
@@ -288,7 +284,9 @@ module Neo4j
         end
 
         def _session
-          @session || (@model && @model.neo4j_session)
+          (@session || (@model && @model.neo4j_session)).tap do |session|
+            fail 'No session found!' if session.nil?
+          end
         end
 
         def _association_arrow(properties = {}, create = false)
@@ -337,7 +335,7 @@ module Neo4j
 
         def build_deeper_query_proxy(method, args)
           new_link.tap do |new_query_proxy|
-            Link.for_args(@model, method, args).each { |link| new_query_proxy._add_links(link) }
+            Link.for_args(@model, method, args, association).each { |link| new_query_proxy._add_links(link) }
           end
         end
       end

data/lib/neo4j/active_node/query/query_proxy_eager_loading.rb

@@ -45,7 +45,6 @@ module Neo4j
 
             query.optional_match("#{identity}#{association.arrow_cypher}#{association_name}")
               .where(association.target_where_clause)
-              .break
           end
         end
       end

data/lib/neo4j/active_node/query/query_proxy_link.rb

@@ -55,7 +55,7 @@ module Neo4j
                     elsif key == model.id_property_name && value.is_a?(Neo4j::ActiveNode)
                       value.id
                     else
-                      model.declared_property_manager.value_for_db(key, value)
+                      converted_value(model, key, value)
                     end
 
               new(:where, ->(v, _) { {v => {key => val}} })
@@ -72,9 +72,11 @@ module Neo4j
             end
 
             # We don't accept strings here. If you want to use a string, just use where.
-            def for_rel_where_clause(arg, _)
+            def for_rel_where_clause(arg, _, association)
               arg.each_with_object([]) do |(key, value), result|
-                result << new(:where, ->(_, rel_var) { {rel_var => {key => value}} })
+                rel_class = association.relationship_class if association.relationship_class
+                val =  rel_class ? converted_value(rel_class, key, value) : value
+                result << new(:where, ->(_, rel_var) { {rel_var => {key => val}} })
               end
             end
 
@@ -82,9 +84,11 @@ module Neo4j
               [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => arg} })]
             end
 
-            def for_args(model, clause, args)
+            def for_args(model, clause, args, association = nil)
               if [:where, :where_not].include?(clause) && args[0].is_a?(String) # Better way?
                 [for_arg(model, clause, args[0], *args[1..-1])]
+              elsif clause == :rel_where
+                args.map { |arg| for_arg(model, clause, arg, association) }
               else
                 args.map { |arg| for_arg(model, clause, arg) }
               end
@@ -97,6 +101,10 @@ module Neo4j
             rescue NoMethodError
               default
             end
+
+            def converted_value(model, key, value)
+              model.declared_properties.value_for_where(key, value)
+            end
           end
         end
       end

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -32,13 +32,11 @@ module Neo4j
 
         def first_and_last(func, target)
           new_query, pluck_proc = if self.query.clause?(:order)
-                                    new_query = self.query.with(identity)
-                                    pluck_proc = proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }
-                                    [new_query, pluck_proc]
+                                    [self.query.with(identity),
+                                     proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }]
                                   else
-                                    new_query = self.order(order_property).limit(1)
-                                    pluck_proc = proc { |var| var }
-                                    [new_query, pluck_proc]
+                                    [self.order(order_property).limit(1),
+                                     proc { |var| var }]
                                   end
           result = query_with_target(target) do |var|
             final_pluck = pluck_proc.call(var)

data/lib/neo4j/active_node/query/query_proxy_unpersisted.rb

@@ -2,14 +2,10 @@ module Neo4j
   module ActiveNode
     module Query
       module QueryProxyUnpersisted
-        def defer_create(other_nodes, _properties, operator)
-          key = [@association.name, [nil, nil, nil]].hash
-          @start_object.pending_associations[key] = [@association.name, operator]
-          if @start_object.association_proxy_cache[key]
-            @start_object.association_proxy_cache[key] << other_nodes
-          else
-            @start_object.association_proxy_cache[key] = [other_nodes]
-          end
+        def defer_create(other_node)
+          @start_object.pending_associations << @association.name
+
+          @start_object.association_proxy(@association.name).add_to_cache(other_node)
         end
       end
     end

data/lib/neo4j/active_node/unpersisted.rb

@@ -2,7 +2,7 @@ module Neo4j
   module ActiveNode
     module Unpersisted
       def pending_associations
-        @pending_associations ||= {}
+        @pending_associations ||= []
       end
 
       def pending_associations?
@@ -17,34 +17,36 @@ module Neo4j
       def pending_associations_with_nodes
         return unless pending_associations?
         {}.tap do |deferred_nodes|
-          pending_associations.each_pair do |cache_key, (association_name, operator)|
-            nodes_for_creation = self.persisted? ? association_proxy_cache[cache_key].select { |n| !n.persisted? } : association_proxy_cache[cache_key]
-            deferred_nodes[association_name] = [nodes_for_creation, operator]
+          pending_associations.uniq.each do |association_name|
+            nodes_for_creation = association_proxy(association_name)
+            nodes_for_creation = nodes_for_creation.reject(&:persisted?) if self.persisted?
+
+            deferred_nodes[association_name] = nodes_for_creation
           end
         end
       end
 
       # @param [Hash] deferred_nodes A hash created by :pending_associations_with_nodes
       def process_unpersisted_nodes!(deferred_nodes)
-        deferred_nodes.each_pair do |k, (v, o)|
-          save_and_associate_queue(k, v, o)
+        deferred_nodes.each_pair do |k, v|
+          save_and_associate_queue(k, v)
         end
       end
 
 
-      def save_and_associate_queue(association_name, node_queue, operator)
-        association_proc = proc { |node| save_and_associate_node(association_name, node, operator) }
+      def save_and_associate_queue(association_name, node_queue)
+        association_proc = proc { |node| save_and_associate_node(association_name, node) }
         node_queue.each do |element|
           element.is_a?(Array) ? element.each { |node| association_proc.call(node) } : association_proc.call(element)
         end
       end
 
-      def save_and_associate_node(association_name, node, operator)
+      def save_and_associate_node(association_name, node)
         if node.respond_to?(:changed?)
           node.save if node.changed? || !node.persisted?
           fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
         end
-        operator == :<< ? send(association_name).send(operator, node) : send(:"#{association_name}=", node)
+        association_proxy(association_name) << node
       end
     end
   end

data/lib/neo4j/active_node/validations.rb

@@ -37,10 +37,10 @@ module Neo4j
           # TODO: Added as find(:name => nil) throws error
           value = '' if value.nil?
 
-          conditions[attribute] = options[:case_sensitive] ? value : /^#{Regexp.escape(value.to_s)}$/i
+          conditions[attribute] = options[:case_sensitive] ? value : /#{Regexp.escape(value.to_s)}/i
 
           found = record.class.as(:result).where(conditions)
-          found = found.where('ID(result) <> {record_neo_id}').params(record_neo_id: record.neo_id) if record._persisted_obj
+          found = found.where_not(neo_id: record.neo_id) if record._persisted_obj
           found
         end
 

data/lib/neo4j/active_rel.rb

@@ -27,13 +27,16 @@ module Neo4j
       attribute_descriptions = attribute_pairs.join(', ')
       separator = ' ' unless attribute_descriptions.empty?
 
-      cypher_representation = "#{node_cypher_representation(:from)}-[:#{type}]->#{node_cypher_representation(:to)}"
+      cypher_representation = "#{node_cypher_representation(from_node)}-[:#{type}]->#{node_cypher_representation(to_node)}"
       "#<#{self.class.name} #{cypher_representation}#{separator}#{attribute_descriptions}>"
     end
 
-    def node_cypher_representation(direction)
-      node = send(:"#{direction}_node")
-      node.cypher_representation(self.class.send(:"#{direction}_class"))
+    def node_cypher_representation(node)
+      node_class = node.class
+      id_name = node_class.id_property_name
+      labels = ':' + node_class.mapped_label_names.join(':')
+
+      "(#{labels} {#{id_name}: #{node.id.inspect}})"
     end
 
     def neo4j_obj

data/lib/neo4j/active_rel/persistence.rb

@@ -12,7 +12,7 @@ module Neo4j::ActiveRel
     end
 
     def save!(*args)
-      fail RelInvalidError, self unless save(*args)
+      save(*args) or fail(RelInvalidError, self) # rubocop:disable Style/AndOr
     end
 
     def create_model
@@ -60,14 +60,23 @@ module Neo4j::ActiveRel
         type = from_node == node ? :_from_class : :_to_class
         type_class = self.class.send(type)
 
-        next if [:any, false].include?(type_class)
-
-        unless node.class.mapped_label_names.include?(type_class.to_s.constantize.mapped_label_name)
+        unless valid_type?(type_class, node)
           fail ModelClassInvalidError, type_validation_error_message(node, type_class)
         end
       end
     end
 
+    def valid_type?(type_object, node)
+      case type_object
+      when false, :any
+        true
+      when Array
+        type_object.any? { |c| valid_type?(c, node) }
+      else
+        node.class.mapped_label_names.include?(type_object.to_s.constantize.mapped_label_name)
+      end
+    end
+
     def type_validation_error_message(node, type_class)
       "Node class was #{node.class} (#{node.class.object_id}), expected #{type_class} (#{type_class.object_id})"
     end

data/lib/neo4j/active_rel/query.rb

@@ -41,11 +41,17 @@ module Neo4j::ActiveRel
 
       private
 
+      def deprecation_warning!
+        ActiveSupport::Deprecation.warn 'The Neo4j::ActiveRel::Query module has been deprecated and will be removed in a future version of the gem.', caller
+      end
+
       def where_query
+        deprecation_warning!
         Neo4j::Session.query.match("#{cypher_string(:outbound)}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
       end
 
       def all_query
+        deprecation_warning!
         Neo4j::Session.query.match("#{cypher_string}-[r1:`#{self._type}`]->#{cypher_string(:inbound)}")
       end
 
@@ -71,6 +77,8 @@ module Neo4j::ActiveRel
           given_class.constantize
         when Symbol
           given_class.to_s.constantize
+        when Array
+          fail "ActiveRel query methods are being deprecated and do not support Array (from|to)_class options. Current value: #{given_class}"
         else
           given_class
         end

data/lib/neo4j/active_rel/related_node.rb

@@ -4,7 +4,6 @@ module Neo4j::ActiveRel
   # will result in a query to load the node if the node is not already loaded.
   class RelatedNode
     class InvalidParameterError < StandardError; end
-    class UnsetRelatedNodeError < StandardError; end
 
     # ActiveRel's related nodes can be initialized with nothing, an integer, or a fully wrapped node.
     #
@@ -31,41 +30,20 @@ module Neo4j::ActiveRel
 
     # Loads a node from the database or returns the node if already laoded
     def loaded
-      fail NilRelatedNodeError, 'Node not set, cannot load' if @node.nil?
       @node = @node.respond_to?(:neo_id) ? @node : Neo4j::Node.load(@node)
     end
 
-    # @param [String, Symbol, Array] clazz An alternate label to use in the event the node is not present or loaded
-    def cypher_representation(clazz)
-      case
-      when !set?
-        "(#{formatted_label_list(clazz)})"
-      when set? && !loaded?
-        "(Node with neo_id #{@node})"
-      else
-        node_class = self.class
-        id_name = node_class.id_property_name
-        labels = ':' + node_class.mapped_label_names.join(':')
-
-        "(#{labels} {#{id_name}: #{@node.id.inspect}})"
-      end
-    end
-
     # @return [Boolean] indicates whether a node has or has not been fully loaded from the database
     def loaded?
       @node.respond_to?(:neo_id)
     end
 
-    def set?
-      !@node.nil?
-    end
-
     def method_missing(*args, &block)
       loaded.send(*args, &block)
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      loaded if @node.is_a?(Numeric)
+      loaded if @node.is_a?(Integer)
       @node.respond_to?(method_name) ? true : super
     end
 
@@ -75,10 +53,6 @@ module Neo4j::ActiveRel
 
     private
 
-    def formatted_label_list(list)
-      list.is_a?(Array) ? list.join(' || ') : list
-    end
-
     def valid_node_param?(node)
       node.nil? || node.is_a?(Integer) || node.respond_to?(:neo_id)
     end