neo4j 4.1.5 → 5.0.0.rc.1

data/lib/neo4j/active_node/node_wrapper.rb

@@ -1,51 +1,58 @@
+require 'active_support/inflector'
+
 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
-      self.props.symbolize_keys!
-      most_concrete_class = sorted_wrapper_classes
-      return self unless most_concrete_class
-      wrapped_node = most_concrete_class.new
-      wrapped_node.init_on_load(self, self.props)
-      wrapped_node
-    end
+      found_class = class_to_wrap
+      return self if not found_class
 
-    def checked_labels_set
-      @@_checked_labels_set ||= Set.new
+      found_class.new.tap do |wrapped_node|
+        wrapped_node.init_on_load(self, self.props)
+      end
     end
 
-    def check_label(label_name)
-      unless checked_labels_set.include?(label_name)
-        load_class_from_label(label_name)
-        # do this only once
-        checked_labels_set.add(label_name)
+    def class_to_wrap
+      load_classes_from_labels
+      (named_class || ::Neo4j::ActiveNode::Labels.model_for_labels(labels)).tap do |model_class|
+        Neo4j::Node::Wrapper.populate_constants_for_labels_cache(model_class, labels)
       end
     end
 
-    # Makes the determination of whether to use <tt>_classname</tt> (or whatever is defined by config) or the node's labels.
-    def sorted_wrapper_classes
-      if self.props.is_a?(Hash) && self.props.key?(Neo4j::Config.class_name_property)
-        self.props[Neo4j::Config.class_name_property].constantize
-      else
-        wrappers = _class_wrappers
-        return self if wrappers.nil?
-        wrapper_classes = wrappers.map { |w| Neo4j::ActiveNode::Labels._wrapped_labels[w] }
-        wrapper_classes.sort.first
-      end
+    private
+
+    def load_classes_from_labels
+      labels.each { |label| Neo4j::Node::Wrapper.constant_for_label(label) }
     end
 
-    def load_class_from_label(label_name)
-      label_name.to_s.split('::').inject(Kernel) { |container, name| container.const_get(name.to_s) }
+    # Only load classes once for performance
+    CONSTANTS_FOR_LABELS_CACHE = {}
+
+    def self.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 _class_wrappers
-      labels.find_all do |label_name|
-        check_label(label_name)
-        Neo4j::ActiveNode::Labels._wrapped_labels[label_name].class == Class
+    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?
       end
     end
+
+    def self.association_model_namespace
+      Neo4j::Config.association_model_namespace_string
+    end
+
+    def named_class
+      property = Neo4j::Config.class_name_property
+
+      Neo4j::Node::Wrapper.constant_for_label(self.props[property]) if self.props.is_a?(Hash) && self.props.key?(property)
+    end
   end
 end

data/lib/neo4j/active_node/orm_adapter.rb

@@ -28,7 +28,7 @@ module Neo4j
 
       # Get an instance by id of the model
       def get(id)
-        klass.find(wrap_key(id))
+        klass.find_by(klass.id_property_name => wrap_key(id))
       end
 
       # Find the first instance matching conditions
@@ -72,9 +72,10 @@ module Neo4j
       end
 
       def extract_id!(conditions)
-        if id = conditions.delete(:id)
-          conditions[klass.id_property_name.to_sym] = id
-        end
+        id = conditions.delete(:id)
+        return if not id
+
+        conditions[klass.id_property_name.to_sym] = id
       end
     end
   end

data/lib/neo4j/active_node/persistence.rb

@@ -10,17 +10,21 @@ module Neo4j::ActiveNode
     end
 
     extend ActiveSupport::Concern
+    extend Forwardable
     include Neo4j::Shared::Persistence
 
     # Saves the model.
     #
     # If the model is new a record gets created in the database, otherwise the existing record gets updated.
     # If perform_validation is true validations run.
-    # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
-    # There's a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
+    # If any of them fail the action is cancelled and save returns false.
+    # If the flag is false validations are bypassed altogether.
+    # See ActiveRecord::Validations for more information.
+    # There's a series of callbacks associated with save.
+    # If any of the before_* callbacks return false the action is cancelled and save returns false.
     def save(*)
       update_magic_properties
-      clear_association_cache
+      association_proxy_cache.clear
       create_or_update
     end
 
@@ -45,13 +49,11 @@ module Neo4j::ActiveNode
       create_magic_properties
       set_timestamps
       create_magic_properties
-      properties = convert_properties_to :db, props
+      properties = self.class.declared_property_manager.convert_properties_to(self, :db, props)
       node = _create_node(properties)
       init_on_load(node, node.props)
       send_props(@relationship_props) if @relationship_props
       @relationship_props = nil
-      # Neo4j::IdentityMap.add(node, self)
-      # write_changed_relationships
       true
     end
 
@@ -68,7 +70,7 @@ module Neo4j::ActiveNode
       # Creates and saves a new node
       # @param [Hash] props the properties the new node should have
       def create(props = {})
-        association_props = extract_association_attributes!(props)
+        association_props = extract_association_attributes!(props) || {}
 
         new(props).tap do |obj|
           yield obj if block_given?
@@ -82,7 +84,7 @@ module Neo4j::ActiveNode
       # Same as #create, but raises an error if there is a problem during save.
       def create!(*args)
         props = args[0] || {}
-        association_props = extract_association_attributes!(props)
+        association_props = extract_association_attributes!(props) || {}
 
         new(*args).tap do |o|
           yield o if block_given?
@@ -93,6 +95,21 @@ module Neo4j::ActiveNode
         end
       end
 
+      def merge(attributes)
+        neo4j_session.query.merge(n: {self.mapped_label_names => attributes})
+          .on_create_set(n: on_create_props(attributes))
+          .on_match_set(n: on_match_props)
+          .pluck(:n).first
+      end
+
+      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_match_set(n: on_match_attributes)
+          .pluck(:n).first
+      end
+
       # Finds the first node with the given attributes, or calls create if none found
       def find_or_create_by(attributes, &block)
         find_by(attributes) || create(attributes, &block)
@@ -106,8 +123,34 @@ module Neo4j::ActiveNode
       def load_entity(id)
         Neo4j::Node.load(id)
       end
-    end
 
-    private
+      private
+
+      def on_create_props(find_attributes)
+        {id_property_name => id_prop_val(find_attributes)}.tap do |props|
+          now = DateTime.now.to_i
+          set_props_timestamp!('created_at', props, now)
+          set_props_timestamp!('updated_at', props, now)
+        end
+      end
+
+      # The process of creating custom id_property values is different from auto uuids. This adapts to that, calls the appropriate method,
+      # and raises an error if it fails.
+      def id_prop_val(find_attributes)
+        custom_uuid_method = id_property_info[:type][:on]
+        id_prop_val = custom_uuid_method ? self.new(find_attributes).send(custom_uuid_method) : default_properties[id_property_name].call
+        fail 'Unable to create custom id property' if id_prop_val.nil?
+        id_prop_val
+      end
+
+      def on_match_props
+        set_props_timestamp!('updated_at')
+      end
+
+      def set_props_timestamp!(key_name, props = {}, stamp = DateTime.now.to_i)
+        props[key_name.to_sym] = stamp if attributes_nil_hash.key?(key_name)
+        props
+      end
+    end
   end
 end

data/lib/neo4j/active_node/property.rb

@@ -5,18 +5,26 @@ module Neo4j::ActiveNode
 
     def initialize(attributes = {}, options = {})
       super(attributes, options)
-
-      send_props(@relationship_props) if persisted? && !@relationship_props.nil?
+      @attributes ||= self.class.attributes_nil_hash.dup
+      send_props(@relationship_props) if _persisted_obj && !@relationship_props.nil?
     end
 
     module ClassMethods
-      # Extracts keys from attributes hash which are relationships of the model
+      # Extracts keys from attributes hash which are associations of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
-        attributes.keys.each_with_object({}) do |key, association_props|
-          association_props[key] = attributes.delete(key) if self.association?(key)
+        return unless contains_association?(attributes)
+        attributes.each_with_object({}) do |(key, _), result|
+          result[key] = attributes.delete(key) if self.association?(key)
         end
       end
+
+      private
+
+      def contains_association?(attributes)
+        attributes.each_key { |key| return true if associations_keys.include?(key) }
+        false
+      end
     end
   end
 end

data/lib/neo4j/active_node/query.rb

@@ -16,10 +16,10 @@ module Neo4j
       # @param var [Symbol, String] The variable name to specify in the query
       # @return [Neo4j::Core::Query]
       def query_as(node_var)
-        self.class.query_as(node_var).where("ID(#{node_var})" => self.neo_id)
+        self.class.query_as(node_var, false).where("ID(#{node_var})" => self.neo_id)
       end
 
-      # Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy caller set to the node instance.
+      # Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy source_object set to the node instance.
       # This method does not exist within QueryProxy and can only be used to start a new chain.
       #
       # @example Start a new QueryProxy chain with the first identifier set manually
@@ -29,7 +29,7 @@ module Neo4j
       # @param [String, Symbol] node_var The identifier to use within the QueryProxy object
       # @return [Neo4j::ActiveNode::Query::QueryProxy]
       def as(node_var)
-        self.class.query_proxy(node: node_var, caller: self).match_to(self)
+        self.class.query_proxy(node: node_var, source_object: self).match_to(self)
       end
 
       module ClassMethods
@@ -39,17 +39,18 @@ module Neo4j
         #   # Generates: MATCH (person:Person), person-[:owned]-car WHERE person.age > 30 RETURN car.registration_number
         #   Person.query_as(:person).where('person.age > 30').match('person-[:owned]-car').return(car: :registration_number)
         #
-        # @param var [Symbol, String] The variable name to specify in the query
+        # @param [Symbol, String] var The variable name to specify in the query
+        # @param [Boolean] with_labels Should labels be used to build the match? There are situations (neo_id used to filter,
+        # an early Cypher match has already filtered results) where including labels will degrade performance.
         # @return [Neo4j::Core::Query]
-        def query_as(var)
-          query_proxy.query_as(var)
+        def query_as(var, with_labels = true)
+          query_proxy.query_as(var, with_labels)
         end
 
         Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
-          module_eval(%{
-            def #{method}(*args)
-              self.query_proxy.#{method}(*args)
-            end}, __FILE__, __LINE__)
+          define_method(method) do |*args|
+            self.query_proxy.send(method, *args)
+          end
         end
 
         def query_proxy(options = {})

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

@@ -9,7 +9,7 @@ module Neo4j
 
         # The most recent node to start a QueryProxy chain.
         # Will be nil when using QueryProxy chains on class methods.
-        attr_reader :caller, :association, :model, :starting_query
+        attr_reader :source_object, :association, :model, :starting_query
 
         # QueryProxy is ActiveNode's Cypher DSL. While the name might imply that it creates queries in a general sense,
         # it is actually referring to <tt>Neo4j::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
@@ -28,7 +28,7 @@ module Neo4j
         # * node_var: A string or symbol to be used by Cypher within its query string as an identifier
         # * rel_var:  Same as above but pertaining to a relationship identifier
         # * session: The session to be used for this query
-        # * caller:  The node instance at the start of the QueryProxy chain
+        # * source_object:  The node instance at the start of the QueryProxy chain
         # * query_proxy: An existing QueryProxy chain upon which this new object should be built
         #
         # QueryProxy objects are evaluated lazily.
@@ -37,17 +37,26 @@ module Neo4j
           @association = association
           @context = options.delete(:context)
           @options = options
-          @node_var = options[:node]
+
+          @node_var, @session, @source_object, @starting_query, @optional, @start_object, @query_proxy, @chain_level =
+            options.values_at(:node, :session, :source_object, :starting_query, :optional, :start_object, :query_proxy, :chain_level)
+
+          @match_type = @optional ? :optional_match : :match
+
           @rel_var = options[:rel] || _rel_chain_var
-          @session = options[:session]
-          @caller = options[:caller]
-          @chain_level = options[:chain_level]
+
           @chain = []
-          @starting_query = options[:starting_query]
-          @optional = options[:optional]
-          @params = options[:query_proxy] ? options[:query_proxy].instance_variable_get('@params') : {}
+          @params = @query_proxy ? @query_proxy.instance_variable_get('@params') : {}
+        end
+
+        def inspect
+          clear, yellow, cyan = %W(\e[0m \e[33m \e[36m)
+
+          "<QueryProxy #{cyan}#{@context}#{clear} CYPHER: #{yellow}#{self.to_cypher.inspect}#{clear}>"
         end
 
+        attr_reader :start_object, :query_proxy
+
         # The current node identifier on deck, so to speak. It is the object that will be returned by calling `each` and the last node link
         # in the QueryProxy chain.
         attr_reader :node_var
@@ -65,9 +74,7 @@ module Neo4j
         end
 
         def params(params)
-          self.dup.tap do |new_query|
-            new_query._add_params(params)
-          end
+          new_link.tap { |new_query| new_query._add_params(params) }
         end
 
         # Like calling #query_as, but for when you don't care about the variable name
@@ -79,22 +86,31 @@ module Neo4j
         # and work with it from the more powerful (but less friendly) Neo4j::Core::Query.
         # @param [String,Symbol] var The identifier to use for node at this link of the QueryProxy chain.
         #   student.lessons.query_as(:l).with('your cypher here...')
-        def query_as(var)
-          base_query = if @association
-                         chain_var = _association_chain_var
-                         label_string = @model && ":`#{@model.mapped_label_name}`"
-                         (_association_query_start(chain_var) & _query_model_as(var)).send(_match_type, "#{chain_var}#{_association_arrow}(#{var}#{label_string})")
-                       else
-                         starting_query ? (starting_query & _query_model_as(var)) : _query_model_as(var)
-                       end
-          # Build a query chain via the chain, return the result
-          result_query = @chain.inject(base_query.params(@params)) do |query, (method, arg)|
-            query.send(method, arg.respond_to?(:call) ? arg.call(var) : arg)
+        def query_as(var, with_label = true)
+          result_query = @chain.inject(base_query(var, with_label).params(@params)) do |query, link|
+            args = link.args(var, rel_var)
+
+            args.is_a?(Array) ? query.send(link.clause, *args) : query.send(link.clause, args)
           end
 
           result_query.tap { |query| query.proxy_chain_level = _chain_level }
         end
 
+        def base_query(var, with_labels = true)
+          if @association
+            chain_var = _association_chain_var
+            (_association_query_start(chain_var) & _query).send(@match_type,
+                                                                "#{chain_var}#{_association_arrow}(#{var}#{_model_label_string})")
+          else
+            starting_query ? (starting_query & _query_model_as(var, with_labels)) : _query_model_as(var, with_labels)
+          end
+        end
+
+        def _model_label_string
+          return if !@model
+          @model.mapped_label_names.map { |label_name| ":`#{label_name}`" }.join
+        end
+
         # Scope all queries to the current scope.
         #
         #   Comment.where(post_id: 1).scoping do
@@ -105,7 +121,8 @@ module Neo4j
         # Please check unscoped if you want to remove all previous scopes (including
         # the default_scope) during the execution of a block.
         def scoping
-          previous, @model.current_scope = @model.current_scope, self
+          previous = @model.current_scope
+          @model.current_scope = self
           yield
         ensure
           @model.current_scope = previous
@@ -114,10 +131,7 @@ module Neo4j
         METHODS = %w(where rel_where order skip limit)
 
         METHODS.each do |method|
-          module_eval(%{
-            def #{method}(*args)
-              build_deeper_query_proxy(:#{method}, args)
-            end}, __FILE__, __LINE__)
+          define_method(method) { |*args| build_deeper_query_proxy(method.to_sym, args) }
         end
         # Since there is a rel_where method, it seems only natural for there to be node_where
         alias_method :node_where, :where
@@ -151,35 +165,53 @@ module Neo4j
         end
 
         def create(other_nodes, properties)
-          fail 'Can only create associations on associations' unless @association
-          other_nodes = [other_nodes].flatten
+          fail 'Can only create relationships on associations' if !@association
+          other_nodes = _nodeify!(*other_nodes)
+
           properties = @association.inject_classname(properties)
-          other_nodes = other_nodes.map do |other_node|
-            case other_node
-            when Integer, String
-              @model.find(other_node)
-            else
-              other_node
+
+          Neo4j::Transaction.run do
+            other_nodes.each do |other_node|
+              other_node.save unless other_node.neo_id
+
+              return false if @association.perform_callback(@start_object, other_node, :before) == false
+
+              @start_object.association_proxy_cache.clear
+
+              _create_relationship(other_node, properties)
+
+              @association.perform_callback(@start_object, other_node, :after)
             end
-          end.compact
+          end
+        end
 
-          fail ArgumentError, "Node must be of the association's class when model is specified" if @model && other_nodes.any? { |other_node| !other_node.is_a?(@model) }
-          other_nodes.each do |other_node|
-            # Neo4j::Transaction.run do
-            other_node.save unless other_node.neo_id
+        def rels
+          fail 'Cannot get rels without a relationship variable.' if !@rel_var
 
-            return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
+          pluck(@rel_var)
+        end
 
-            start_object = @options[:start_object]
-            start_object.clear_association_cache
-            _session.query(context: @options[:context])
-              .match("(start#{match_string(start_object)}), (end#{match_string(other_node)})").where('ID(start) = {start_id} AND ID(end) = {end_id}')
-              .params(start_id: start_object.neo_id, end_id: other_node.neo_id)
-              .send(create_method, "start#{_association_arrow(properties, true)}end").exec
+        def rel
+          rels.first
+        end
+
+        def _nodeify!(*args)
+          other_nodes = [args].flatten!.map! do |arg|
+            (arg.is_a?(Integer) || arg.is_a?(String)) ? @model.find_by(@model.id_property_name => arg) : arg
+          end.compact
 
-            @association.perform_callback(@options[:start_object], other_node, :after)
-            # end
+          if @model && other_nodes.any? { |other_node| !other_node.is_a?(@model) }
+            fail ArgumentError, "Node must be of the association's class when model is specified"
           end
+
+          other_nodes
+        end
+
+        def _create_relationship(other_node_or_nodes, properties)
+          _session.query(context: @options[:context])
+            .match(:start, :end)
+            .where(start: {neo_id: @start_object}, end: {neo_id: other_node_or_nodes})
+            .send(association.create_method, "start#{_association_arrow(properties, true)}end").exec
         end
 
         def read_attribute_for_serialization(*args)
@@ -190,23 +222,37 @@ module Neo4j
         # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
         def method_missing(method_name, *args, &block)
           if @model && @model.respond_to?(method_name)
-            args[2] = self if @model.association?(method_name) || @model.scope?(method_name)
             scoping { @model.public_send(method_name, *args, &block) }
           else
             super
           end
         end
 
+        def respond_to?(method_name)
+          (@model && @model.respond_to?(method_name)) || super
+        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)
+          scoping { @model.find(*args) }
+        end
+
         def optional?
           @optional == true
         end
 
         attr_reader :context
 
+        def new_link(node_var = nil)
+          self.clone.tap do |new_query_proxy|
+            new_query_proxy.instance_variable_set('@node_var', node_var) if node_var
+          end
+        end
+
         protected
 
         # Methods are underscored to prevent conflict with user class methods
-
         def _add_params(params)
           @params = @params.merge(params)
         end
@@ -215,29 +261,32 @@ module Neo4j
           @chain += links
         end
 
-        def _query_model_as(var)
-          match_arg = if @model
-                        label = @model.respond_to?(:mapped_label_name) ? @model.mapped_label_name : @model
-                        {var => label}
-                      else
-                        var
-                      end
-          _session.query(context: @context).send(_match_type, match_arg)
+        def _query_model_as(var, with_labels = true)
+          _query.send(@match_type, _match_arg(var, with_labels))
         end
 
-        # TODO: Refactor this. Too much happening here.
-        def _result_string
-          if self.association
-            "result_#{self.association.name}".to_sym
-          elsif self.model && self.model.name
-            label = "result_#{self.model.name}"
-            label.downcase!.tr!(':', '')
-            label.to_sym
+        # @param [String, Symbol] var The Cypher identifier to use within the match string
+        # @param [Boolean] with_labels Send "true" to include model labels where possible.
+        def _match_arg(var, with_labels)
+          if @model && with_labels != false
+            labels = @model.respond_to?(:mapped_label_names) ? _model_label_string : @model
+            {var => labels}
           else
-            :result
+            var
           end
         end
 
+        def _query
+          _session.query(context: @context)
+        end
+
+        # TODO: Refactor this. Too much happening here.
+        def _result_string
+          s = (self.association && self.association.name) || (self.model && self.model.name) || ''
+
+          s ? "result_#{s}".downcase.tr(':', '').to_sym : :result
+        end
+
         def _session
           @session || (@model && @model.neo4j_session)
         end
@@ -247,30 +296,22 @@ module Neo4j
         end
 
         def _chain_level
-          if query_proxy = @options[:query_proxy]
-            query_proxy._chain_level + 1
-          elsif @chain_level
-            @chain_level + 1
-          else
-            1
-          end
+          (@query_proxy ? @query_proxy._chain_level : (@chain_level || 0)) + 1
         end
 
         def _association_chain_var
-          if start_object = @options[:start_object]
+          if start_object
             :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id}"
-          elsif query_proxy = @options[:query_proxy]
-            query_proxy.node_var || :"node#{_chain_level}"
+          elsif @query_proxy
+            @query_proxy.node_var || :"node#{_chain_level}"
           else
             fail 'Crazy error' # TODO: Better error
           end
         end
 
         def _association_query_start(var)
-          if start_object = @options[:start_object]
-            start_object.query_as(var)
-          elsif query_proxy = @options[:query_proxy]
-            query_proxy.query_as(var)
+          if object = (start_object || @query_proxy)
+            object.query_as(var)
           else
             fail 'Crazy error' # TODO: Better error
           end
@@ -280,82 +321,14 @@ module Neo4j
           :"rel#{_chain_level - 1}"
         end
 
-        def _match_type
-          @optional ? :optional_match : :match
-        end
-
         attr_writer :context
 
         private
 
-        def create_method
-          association.unique? ? :create_unique : :create
-        end
-
         def build_deeper_query_proxy(method, args)
-          self.dup.tap do |new_query|
-            args.each do |arg|
-              new_query._add_links(links_for_arg(method, arg))
-            end
-          end
-        end
-
-        def links_for_arg(method, arg)
-          method_to_call = "links_for_#{method}_arg"
-
-          default = [[method, arg]]
-
-          self.send(method_to_call, arg) || default
-        rescue NoMethodError
-          default
-        end
-
-        def links_for_where_arg(arg)
-          node_num = 1
-          result = []
-          if arg.is_a?(Hash)
-            arg.each do |key, value|
-              if @model && @model.association?(key)
-                result += links_for_association(key, value, "n#{node_num}")
-
-                node_num += 1
-              else
-                result << [:where, ->(v) { {v => {key => value}} }]
-              end
-            end
-          elsif arg.is_a?(String)
-            result << [:where, arg]
+          new_link.tap do |new_query|
+            Link.for_args(@model, method, args).each { |link| new_query._add_links(link) }
           end
-          result
-        end
-        alias_method :links_for_node_where_arg, :links_for_where_arg
-
-        def links_for_association(name, value, n_string)
-          neo_id = value.try(:neo_id) || value
-          fail ArgumentError, "Invalid value for '#{name}' condition" if not neo_id.is_a?(Integer)
-
-          dir = @model.associations[name].direction
-
-          arrow = dir == :out ? '-->' : '<--'
-          [
-            [:match, ->(v) { "#{v}#{arrow}(#{n_string})" }],
-            [:where, ->(_) { {"ID(#{n_string})" => neo_id.to_i} }]
-          ]
-        end
-
-        # We don't accept strings here. If you want to use a string, just use where.
-        def links_for_rel_where_arg(arg)
-          arg.each_with_object([]) do |(key, value), result|
-            result << [:where, ->(_) { {rel_var => {key => value}} }]
-          end
-        end
-
-        def links_for_order_arg(arg)
-          [[:order, ->(v) { arg.is_a?(String) ? arg : {v => arg} }]]
-        end
-
-        def match_string(node)
-          ":`#{node.class.mapped_label_name}`" if node.class.respond_to?(:mapped_label_name)
         end
       end
     end