neo4j 7.2.3 → 8.0.0.alpha.1

data/lib/neo4j/active_node/node_wrapper.rb

@@ -1,52 +1,54 @@
 require 'active_support/inflector'
+require 'neo4j/core/node'
 
-class Neo4j::Node
-  # The wrapping process is what transforms a raw CypherNode or EmbeddedNode from Neo4j::Core into a healthy ActiveNode (or ActiveRel) object.
-  module Wrapper
-    # this is a plugin in the neo4j-core so that the Ruby wrapper will be wrapped around the Neo4j::Node objects
-    def wrapper
-      found_class = class_to_wrap
-      return self if not found_class
+wrapping_proc = proc do |node|
+  found_class = Neo4j::NodeWrapping.class_to_wrap(node.labels)
+  next node if not found_class
 
-      found_class.new.tap do |wrapped_node|
-        wrapped_node.init_on_load(self, self.props)
-      end
-    end
+  found_class.new.tap do |wrapped_node|
+    wrapped_node.init_on_load(node, node.props)
+  end
+end
+Neo4j::Core::Node.wrapper_callback(wrapping_proc)
 
-    def class_to_wrap
-      load_classes_from_labels
-      Neo4j::ActiveNode::Labels.model_for_labels(labels).tap do |model_class|
-        Neo4j::Node::Wrapper.populate_constants_for_labels_cache(model_class, labels)
-      end
-    end
+module Neo4j
+  module NodeWrapping
+    # Only load classes once for performance
+    CONSTANTS_FOR_LABELS_CACHE = {}
 
-    private
+    class << self
+      def class_to_wrap(labels)
+        load_classes_from_labels(labels)
+        Neo4j::ActiveNode::Labels.model_for_labels(labels).tap do |model_class|
+          populate_constants_for_labels_cache(model_class, labels)
+        end
+      end
 
-    def load_classes_from_labels
-      labels.each { |label| Neo4j::Node::Wrapper.constant_for_label(label) }
-    end
+      private
 
-    # Only load classes once for performance
-    CONSTANTS_FOR_LABELS_CACHE = {}
+      def load_classes_from_labels(labels)
+        labels.each { |label| constant_for_label(label) }
+      end
 
-    def self.constant_for_label(label)
-      CONSTANTS_FOR_LABELS_CACHE[label] || CONSTANTS_FOR_LABELS_CACHE[label] = constantized_label(label)
-    end
+      def constant_for_label(label)
+        CONSTANTS_FOR_LABELS_CACHE[label] || CONSTANTS_FOR_LABELS_CACHE[label] = constantized_label(label)
+      end
 
-    def self.constantized_label(label)
-      "#{association_model_namespace}::#{label}".constantize
-    rescue NameError
-      nil
-    end
+      def constantized_label(label)
+        "#{association_model_namespace}::#{label}".constantize
+      rescue NameError
+        nil
+      end
 
-    def self.populate_constants_for_labels_cache(model_class, labels)
-      labels.each do |label|
-        CONSTANTS_FOR_LABELS_CACHE[label] = model_class if CONSTANTS_FOR_LABELS_CACHE[label].nil?
+      def populate_constants_for_labels_cache(model_class, labels)
+        labels.each do |label|
+          CONSTANTS_FOR_LABELS_CACHE[label] = model_class if CONSTANTS_FOR_LABELS_CACHE[label].nil?
+        end
       end
-    end
 
-    def self.association_model_namespace
-      Neo4j::Config.association_model_namespace_string
+      def association_model_namespace
+        Neo4j::Config.association_model_namespace_string
+      end
     end
   end
 end

data/lib/neo4j/active_node/persistence.rb

@@ -33,8 +33,7 @@ module Neo4j::ActiveNode
     # @param [Symbol, String] name of the attribute to increment
     # @param [Integer, Float] amount to increment
     def concurrent_increment!(attribute, by = 1)
-      query_node = Neo4j::Session.query.match_nodes(n: neo_id)
-      increment_by_query! query_node, attribute, by
+      increment_by_query! query_as(:n), attribute, by
     end
 
     # Persist the object to the database.  Validations and Callbacks are included
@@ -67,7 +66,8 @@ module Neo4j::ActiveNode
     # @param [Array] labels The labels to use for creating the new node.
     # @return [Neo4j::Node] A CypherNode or EmbeddedNode
     def _create_node(node_props, labels = labels_for_create)
-      self.class.neo4j_session.create_node(node_props, labels)
+      query = "CREATE (n:`#{Array(labels).join('`:`')}`) SET n = {props} RETURN n"
+      neo4j_query(query, {props: node_props}, wrap_level: :core_entity).to_a[0].n
     end
 
     # As the name suggests, this inserts the primary key (id property) into the properties hash.
@@ -88,11 +88,15 @@ module Neo4j::ActiveNode
 
     private
 
+    def destroy_query
+      query_as(:n).break.optional_match('(n)-[r]-()').delete(:n, :r)
+    end
+
     # The pending associations are cleared during the save process, so it's necessary to
     # build the processable hash before it begins. If there are nodes and associations that
     # need to be created after the node is saved, a new transaction is started.
     def cascade_save
-      Neo4j::Transaction.run(pending_deferred_creations?) do
+      self.class.run_transaction(pending_deferred_creations?) do
         result = yield
         process_unpersisted_nodes!
         result
@@ -124,19 +128,19 @@ module Neo4j::ActiveNode
         optional_attrs.default = {}
         on_create_attrs, on_match_attrs, set_attrs = optional_attrs.values_at(*options)
 
-        neo4j_session.query.merge(n: {self.mapped_label_names => match_attributes})
-          .on_create_set(on_create_clause(on_create_attrs))
-          .on_match_set(on_match_clause(on_match_attrs))
-          .break.set(n: set_attrs)
-          .pluck(:n).first
+        new_query.merge(n: {self.mapped_label_names => match_attributes})
+                 .on_create_set(on_create_clause(on_create_attrs))
+                 .on_match_set(on_match_clause(on_match_attrs))
+                 .break.set(n: set_attrs)
+                 .pluck(:n).first
       end
 
       def find_or_create(find_attributes, set_attributes = {})
         on_create_attributes = set_attributes.reverse_merge(find_attributes.merge(self.new(find_attributes).props_for_create))
 
-        neo4j_session.query.merge(n: {self.mapped_label_names => find_attributes})
-          .on_create_set(n: on_create_attributes)
-          .pluck(:n).first
+        new_query.merge(n: {self.mapped_label_names => find_attributes})
+                 .on_create_set(n: on_create_attributes)
+                 .pluck(:n).first
       end
 
       # Finds the first node with the given attributes, or calls create if none found
@@ -149,8 +153,18 @@ module Neo4j::ActiveNode
         find_by(attributes) || create!(attributes, &block)
       end
 
+      def find_or_initialize_by(attributes)
+        find_by(attributes) || new(attributes).tap { |o| yield(o) if block_given? }
+      end
+
       def load_entity(id)
-        Neo4j::Node.load(id)
+        query = query_base_for(id, :n).return(:n)
+        result = neo4j_query(query).first
+        result && result.n
+      end
+
+      def query_base_for(neo_id, var = :n)
+        Neo4j::ActiveBase.new_query.match(var).where(var => {neo_id: neo_id})
       end
 
       private

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

@@ -54,7 +54,8 @@ module Neo4j
         end
 
         def inspect
-          "#<QueryProxy #{@context} CYPHER: #{self.to_cypher.inspect}>"
+          formatted_nodes = Neo4j::ActiveNode::NodeListFormatter.new(to_a)
+          "#<QueryProxy #{@context} #{formatted_nodes.inspect}>"
         end
 
         attr_reader :start_object, :query_proxy
@@ -65,7 +66,7 @@ module Neo4j
         def identity
           @node_var || _result_string
         end
-        alias_method :node_identity, :identity
+        alias node_identity identity
 
         # The relationship identifier most recently used by the QueryProxy chain.
         attr_reader :rel_var
@@ -144,10 +145,10 @@ module Neo4j
           define_method(method) { |*args| build_deeper_query_proxy(method.to_sym, args) }
         end
         # Since there are rel_where and rel_order methods, it seems only natural for there to be node_where and node_order
-        alias_method :node_where, :where
-        alias_method :node_order, :order
-        alias_method :offset, :skip
-        alias_method :order_by, :order
+        alias node_where where
+        alias node_order order
+        alias offset skip
+        alias 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>.
         delegate :to_cypher, to: :query
@@ -186,7 +187,8 @@ module Neo4j
         #
         # @return [QueryProxy] A new QueryProxy
         def branch(&block)
-          fail LocalJumpError, 'no block given' if block.nil?
+          fail LocalJumpError, 'no block given' if !block
+
           instance_eval(&block).query.proxy_as(self.model, identity)
         end
 
@@ -200,7 +202,7 @@ module Neo4j
           fail 'Can only create relationships on associations' if !@association
           other_nodes = _nodeify!(*other_nodes)
 
-          Neo4j::Transaction.run do
+          Neo4j::ActiveBase.run_transaction do
             other_nodes.each do |other_node|
               other_node.save unless other_node.neo_id
 
@@ -291,7 +293,7 @@ module Neo4j
         end
 
         def _query
-          _session.query(context: @context)
+          Neo4j::ActiveBase.new_query(context: @context)
         end
 
         # TODO: Refactor this. Too much happening here.

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

@@ -10,7 +10,7 @@ module Neo4j
               record.association_proxy(with_associations_spec[index]).cache_result(eager_records)
             end
 
-            block.call(record)
+            yield(record)
           end
         end
 
@@ -23,7 +23,7 @@ module Neo4j
             model.associations[association_name]
           end
 
-          if invalid_association_names.size > 0
+          if !invalid_association_names.empty?
             fail "Invalid associations: #{invalid_association_names.join(', ')}"
           end
 
@@ -52,8 +52,8 @@ module Neo4j
           association = model.associations[association_name]
 
           base_query.optional_match("(#{identity})#{association.arrow_cypher}(#{association_name})")
-            .where(association.target_where_clause)
-            .with(identity, "collect(#{association_name}) AS #{association_name}_collection", *with_associations_return_clause(previous_with_variables))
+                    .where(association.target_where_clause)
+                    .with(identity, "collect(#{association_name}) AS #{association_name}_collection", *with_associations_return_clause(previous_with_variables))
         end
       end
     end

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

@@ -75,6 +75,7 @@ module Neo4j
         def pluck(*args)
           transformable_attributes = (model ? model.attribute_names : []) + %w(uuid neo_id)
           arg_list = args.map do |arg|
+            arg = Neo4j::ActiveNode::Query::QueryProxy::Link.converted_key(model, arg)
             if transformable_attributes.include?(arg.to_s)
               {identity => arg}
             else

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

@@ -12,11 +12,7 @@ module Neo4j
           end
 
           def args(var, rel_var)
-            if @arg.respond_to?(:call)
-              @arg.call(var, rel_var)
-            else
-              [@arg] + @args
-            end
+            @arg.respond_to?(:call) ? @arg.call(var, rel_var) : [@arg, @args].flatten
           end
 
           class << self
@@ -43,7 +39,7 @@ module Neo4j
               end
               result
             end
-            alias_method :for_node_where_clause, :for_where_clause
+            alias for_node_where_clause for_where_clause
 
             def for_where_not_clause(*args)
               for_where_clause(*args).each do |link|
@@ -52,7 +48,7 @@ module Neo4j
             end
 
             def new_for_key_and_value(model, key, value)
-              key = (key.to_sym == :id ? model.id_property_name : key)
+              key = converted_key(model, key)
 
               val = if !model
                       value
@@ -88,8 +84,8 @@ module Neo4j
               [new(:order, ->(_, v) { arg.is_a?(String) ? arg : {v => arg} })]
             end
 
-            def for_order_clause(arg, _)
-              [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => arg} })]
+            def for_order_clause(arg, model)
+              [new(:order, ->(v, _) { arg.is_a?(String) ? arg : {v => converted_keys(model, arg)} })]
             end
 
             def for_args(model, clause, args, association = nil)
@@ -110,6 +106,14 @@ module Neo4j
               default
             end
 
+            def converted_keys(model, arg)
+              arg.is_a?(Hash) ? Hash[arg.map { |key, value| [converted_key(model, key), value] }] : arg
+            end
+
+            def converted_key(model, key)
+              key.to_sym == :id ? model.id_property_name : key
+            end
+
             def converted_value(model, key, value)
               model.declared_properties.value_for_where(key, value)
             end

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

@@ -1,7 +1,9 @@
 module Neo4j
   module ActiveNode
     module Query
+      # rubocop:disable Metrics/ModuleLength
       module QueryProxyMethods
+        # rubocop:enable Metrics/ModuleLength
         FIRST = 'HEAD'
         LAST = 'LAST'
 
@@ -15,10 +17,6 @@ module Neo4j
           rels.first
         end
 
-        def as(node_var)
-          new_link(node_var)
-        end
-
         # Give ability to call `#find` on associations to get a scoped find
         # Doesn't pass through via `method_missing` because Enumerable has a `#find` method
         def find(*args)
@@ -66,14 +64,14 @@ module Neo4j
           query_with_target(target) { |var| !self.exists?(nil, var) }
         end
 
-        alias_method :blank?, :empty?
+        alias blank? empty?
 
         # @param [Neo4j::ActiveNode, Neo4j::Node, String] other An instance of a Neo4j.rb model, a Neo4j-core node, or a string uuid
         # @param [String, Symbol] target An identifier of a link in the Cypher chain
         # @return [Boolean]
         def include?(other, target = nil)
           query_with_target(target) do |var|
-            where_filter = if other.respond_to?(:neo_id)
+            where_filter = if other.respond_to?(:neo_id) || association_id_key == :neo_id
                              "ID(#{var}) = {other_node_id}"
                            else
                              "#{var}.#{association_id_key} = {other_node_id}"
@@ -129,7 +127,7 @@ module Neo4j
         def rels_to(node)
           self.match_to(node).pluck(rel_var)
         end
-        alias_method :all_rels_to, :rels_to
+        alias all_rels_to rels_to
 
         # When called, this method returns a single node that satisfies the match specified in the params hash.
         # If no existing node is found to satisfy the match, one is created or associated as expected.
@@ -137,13 +135,21 @@ module Neo4j
           fail 'Method invalid when called on Class objects' unless source_object
           result = self.where(params).first
           return result unless result.nil?
-          Neo4j::Transaction.run do
+          Neo4j::ActiveBase.run_transaction do
             node = model.find_or_create_by(params)
             self << node
             return node
           end
         end
 
+        def find_or_initialize_by(attributes, &block)
+          find_by(attributes) || initialize_by_current_chain_params(attributes, &block)
+        end
+
+        def first_or_initialize(attributes = {}, &block)
+          first || initialize_by_current_chain_params(attributes, &block)
+        end
+
         # A shortcut for attaching a new, optional match to the end of a QueryProxy chain.
         def optional(association, node_var = nil, rel_var = nil)
           self.send(association, node_var, rel_var, optional: true)
@@ -167,8 +173,70 @@ module Neo4j
           where("(#{where_clause})")
         end
 
+        # Matches all nodes having at least a relation
+        #
+        # @example Load all people having a friend
+        #   Person.all.having_rel(:friends).to_a # => Returns a list of `Person`
+        #
+        # @example Load all people having a best friend
+        #   Person.all.having_rel(:friends, best: true).to_a # => Returns a list of `Person`
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def having_rel(association_name, rel_properties = {})
+          association = association_or_fail(association_name)
+          where("(#{identity})#{association.arrow_cypher(nil, rel_properties)}()")
+        end
+
+        # Matches all nodes not having a certain relation
+        #
+        # @example Load all people not having friends
+        #   Person.all.not_having_rel(:friends).to_a # => Returns a list of `Person`
+        #
+        # @example Load all people not having best friends
+        #   Person.all.not_having_rel(:friends, best: true).to_a # => Returns a list of `Person`
+        #
+        # @return [QueryProxy] A new QueryProxy
+        def not_having_rel(association_name, rel_properties = {})
+          association = association_or_fail(association_name)
+          where_not("(#{identity})#{association.arrow_cypher(nil, rel_properties)}()")
+        end
+
         private
 
+        def association_or_fail(association_name)
+          model.associations[association_name] || fail(ArgumentError, "No such association #{association_name}")
+        end
+
+        def find_inverse_association!(model, source, association)
+          model.associations.values.find do |reverse_association|
+            association.inverse_of?(reverse_association) ||
+              reverse_association.inverse_of?(association) ||
+              inverse_relation_of?(source, association, model, reverse_association)
+          end || fail("Could not find reverse association for #{@context}")
+        end
+
+        def inverse_relation_of?(source, source_association, target, target_association)
+          source_association.direction != target_association.direction &&
+            source == target_association.target_class &&
+            target == source_association.target_class &&
+            source_association.relationship_class_name == target_association.relationship_class_name
+        end
+
+        def initialize_by_current_chain_params(params = {})
+          result = new(where_clause_params.merge(params))
+
+          inverse_association = find_inverse_association!(model, source_object.class, association) if source_object
+          result.tap do |m|
+            yield(m) if block_given?
+            m.public_send(inverse_association.name) << source_object if inverse_association
+          end
+        end
+
+        def where_clause_params
+          query.clauses.select { |c| c.is_a?(Neo4j::Core::QueryClauses::WhereClause) && c.arg.is_a?(Hash) }
+               .map! { |e| e.arg[identity] }.compact.inject { |a, b| a.merge(b) } || {}
+        end
+
         def first_and_last(func, target)
           new_query, pluck_proc = if self.query.clause?(:order)
                                     [self.query.with(identity),