activegraph 11.5.0.beta.3 → 12.0.0.beta.1

data/lib/active_graph/node/labels.rb

@@ -108,7 +108,7 @@ module ActiveGraph
 
         # Deletes all nodes and connected relationships from Cypher.
         def delete_all
-          neo4j_query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
+          neo4j_query("MATCH (n:`#{mapped_label_name}`) DETACH DELETE n")
         end
 
         # Returns each node to Ruby and calls `destroy`. Be careful, as this can be a very slow operation if you have many nodes. It will generate at least
@@ -127,11 +127,15 @@ module ActiveGraph
           @mapped_label_name || label_for_model
         end
 
+        alias mapped_element_name mapped_label_name
+
         # @return [ActiveGraph::Label] the label for this class
         def mapped_label
           ActiveGraph::Core::Label.new(mapped_label_name)
         end
 
+        alias mapped_element mapped_label
+
         def base_class
           unless self < ActiveGraph::Node
             fail "#{name} doesn't belong in a hierarchy descending from Node"
@@ -160,6 +164,7 @@ module ActiveGraph
 
           self.mapped_label_name = name
         end
+
         # rubocop:enable Naming/AccessorMethodName
 
         private
@@ -184,20 +189,18 @@ module ActiveGraph
         end
 
         def label_for_model
-          (self.name.nil? ? object_id.to_s.to_sym : decorated_label_name)
+          name.nil? ? object_id.to_s.to_sym : decorated_label_name
         end
 
         def decorated_label_name
-          name =  case ActiveGraph::Config[:module_handling]
-                  when :demodulize
-                    self.name.demodulize
-                  when Proc
-                    ActiveGraph::Config[:module_handling].call self.name
-                  else
-                    self.name
-                  end
-
-          name.to_sym
+          case ActiveGraph::Config[:module_handling]
+          when :demodulize
+            name.demodulize
+          when Proc
+            ActiveGraph::Config[:module_handling].call name
+          else
+            name
+          end.to_sym
         end
       end
     end

data/lib/active_graph/node/persistence.rb

@@ -70,17 +70,6 @@ module ActiveGraph::Node
       neo4j_query(query, {props: node_props}, wrap: false).to_a[0][:n]
     end
 
-    # As the name suggests, this inserts the primary key (id property) into the properties hash.
-    # The method called here, `default_property_values`, is a holdover from an earlier version of the gem. It does NOT
-    # contain the default values of properties, it contains the Default Property, which we now refer to as the ID Property.
-    # It will be deprecated and renamed in a coming refactor.
-    # @param [Hash] converted_props A hash of properties post-typeconversion, ready for insertion into the DB.
-    def inject_primary_key!(converted_props)
-      self.class.default_property_values(self).tap do |destination_props|
-        destination_props.merge!(converted_props) if converted_props.is_a?(Hash)
-      end
-    end
-
     # @return [Array] Labels to be set on the node during a create event
     def labels_for_create
       self.class.mapped_label_names

data/lib/active_graph/node/query/query_proxy/link.rb

@@ -147,8 +147,8 @@ module ActiveGraph
 
               val = if !model
                       value
-                    elsif key == model.id_property_name && value.is_a?(ActiveGraph::Node)
-                      value.id
+                    elsif key == model.id_property_name
+                      try_id(value)
                     else
                       converted_value(model, key, value)
                     end
@@ -156,13 +156,24 @@ module ActiveGraph
               new(:where, ->(v, _) { {v => {key => val}} })
             end
 
+            private def try_id(value)
+              case value
+              when Shared::Identity
+                value.id
+              when Enumerable
+                value.map(&method(:try_id))
+              else
+                value
+              end
+            end
+
             def for_association(name, value, n_string, model)
               neo_id = value.try(:neo_id) || value
-              fail ArgumentError, "Invalid value for '#{name}' condition" if not neo_id.is_a?(Integer)
+              fail ArgumentError, "Invalid value for '#{name}' condition" unless neo_id.is_a?(String)
 
               [
                 new(:match, ->(v, _) { "(#{v})#{model.associations[name].arrow_cypher}(#{n_string})" }),
-                new(:where, ->(_, _) { {"ID(#{n_string})" => neo_id.to_i} })
+                new(:where, ->(_, _) { {"elementId(#{n_string})" => neo_id} })
               ]
             end
 

data/lib/active_graph/node/query/query_proxy.rb

@@ -223,7 +223,7 @@ module ActiveGraph
 
           ActiveGraph::Base.transaction do
             other_nodes.each do |other_node|
-              if other_node.neo_id
+              if other_node.element_id
                 other_node.try(:delete_reverse_has_one_core_rel, association)
               else
                 other_node.save
@@ -238,7 +238,7 @@ module ActiveGraph
 
         def _nodeify!(*args)
           other_nodes = [args].flatten!.map! do |arg|
-            (arg.is_a?(Integer) || arg.is_a?(String)) ? @model.find_by(id: arg) : arg
+            arg.is_a?(String) ? @model.find_by(id: arg) : arg
           end.compact
 
           if @model && other_nodes.any? { |other_node| !other_node.class.mapped_label_names.include?(@model.mapped_label_name) }
@@ -351,7 +351,7 @@ module ActiveGraph
           fail 'Crazy error' if !(start_object || @query_proxy)
 
           if start_object
-            :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id}"
+            :"#{start_object.class.name.gsub('::', '_').downcase}#{start_object.neo_id&.gsub(/[:\-]/, '_')}"
           else
             @query_proxy.node_var || :"node#{_chain_level}"
           end

data/lib/active_graph/node/query/query_proxy_eager_loading.rb

@@ -62,7 +62,7 @@ module ActiveGraph
           if rel.is_a?(ActiveGraph::Relationship)
             rel.instance_variable_set(direction == :in ? '@from_node' : '@to_node', node)
           end
-          @_cache[direction == :out ? rel.start_node_id : rel.end_node_id]
+          @_cache[direction == :out ? rel.start_node_element_id : rel.end_node_element_id]
             .association_proxy(element.name).add_to_cache(node, rel)
         end
 

data/lib/active_graph/node/query/query_proxy_enumerable.rb

@@ -62,22 +62,22 @@ module ActiveGraph
         # Does exactly what you would hope. Without it, comparing `bobby.lessons == sandy.lessons` would evaluate to false because it
         # would be comparing the QueryProxy objects, not the lessons themselves.
         def ==(other)
-          self.to_a == other
+          to_a == other
         end
 
         # For getting variables which have been defined as part of the association chain
         def pluck(*args)
-          transformable_attributes = (model ? model.attribute_names : []) + %w(uuid neo_id)
+          transformable_attributes = (model ? model.attribute_names + [model.id_property_name.to_s] : []) + %w(uuid neo_id)
           arg_list = args.map do |arg|
             arg = ActiveGraph::Node::Query::QueryProxy::Link.converted_key(model, arg)
             if transformable_attributes.include?(arg.to_s)
-              {identity => arg}
+              { identity => arg }
             else
               arg
             end
           end
 
-          self.query.pluck(*arg_list)
+          query.pluck(*arg_list)
         end
 
         protected

data/lib/active_graph/node/query/query_proxy_methods.rb

@@ -88,7 +88,7 @@ module ActiveGraph
         def include?(other, target = nil)
           query_with_target(target) do |var|
             where_filter = if other.respond_to?(:neo_id) || association_id_key == :neo_id
-                             "ID(#{var}) = $other_node_id"
+                             "elementId(#{var}) = $other_node_id"
                            else
                              "#{var}.#{association_id_key} = $other_node_id"
                            end
@@ -99,12 +99,12 @@ module ActiveGraph
         end
 
         def exists?(node_condition = nil, target = nil)
-          unless [Integer, String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
+          unless [String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
             fail(ActiveGraph::InvalidParameterError, ':exists? only accepts ids or conditions')
           end
           query_with_target(target) do |var|
             start_q = exists_query_start(node_condition, var)
-            result = start_q.query.reorder.return("ID(#{var}) AS proof_of_life LIMIT 1").first
+            result = start_q.query.reorder.return("elementId(#{var}) AS proof_of_life LIMIT 1").first
             !!result
           end
         end
@@ -119,9 +119,9 @@ module ActiveGraph
         def match_to(node)
           first_node = node.is_a?(Array) ? node.first : node
           where_arg = if first_node.respond_to?(:neo_id)
-                        {neo_id: node.is_a?(Array) ? node.map(&:neo_id) : node}
+                        { neo_id: node.is_a?(Array) ? node.map(&:neo_id) : node }
                       elsif !node.nil?
-                        {association_id_key => node.is_a?(Array) ? ids_array(node) : node}
+                        { association_id_key => node.is_a?(Array) ? ids_array(node) : node }
                       else
                         # support for null object pattern
                         '1 = 2'
@@ -130,7 +130,6 @@ module ActiveGraph
           self.where(where_arg)
         end
 
-
         # Gives you the first relationship between the last link of a QueryProxy chain and a given node
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id} RETURN r`
         # @param [#neo_id, String, Enumerable] node An object to be sent to `match_to`. See params for that method.
@@ -145,6 +144,7 @@ module ActiveGraph
         def rels_to(node)
           self.match_to(node).pluck(rel_var)
         end
+
         alias all_rels_to rels_to
 
         # When called, this method returns a single node that satisfies the match specified in the params hash.
@@ -260,7 +260,7 @@ module ActiveGraph
                                     [self.query.with(identity),
                                      proc { |var| "#{func}(COLLECT(#{var})) as #{var}" }]
                                   else
-                                    ord_prop = (func == LAST ? {order_property => :DESC} : order_property)
+                                    ord_prop = (func == LAST ? { order_property => :DESC } : order_property)
                                     [self.order(ord_prop).limit(1),
                                      proc { |var| var }]
                                   end
@@ -285,16 +285,14 @@ module ActiveGraph
           yield(target || identity)
         end
 
-        def exists_query_start(condition, target)
-          case condition
-          when Integer
-            self.where("ID(#{target}) = $exists_condition").params(exists_condition: condition)
-          when Hash
-            self.where(condition.keys.first => condition.values.first)
-          when String
-            self.where(model.primary_key => condition)
+        def exists_query_start(condition, target = nil)
+          return self unless condition
+          return exists_query_start(model.primary_key => condition) if condition.is_a?(String)
+
+          if condition.key?(:neo_id)
+            where("elementId(#{target}) = $neo_id").params(**condition.slice(:neo_id))
           else
-            self
+            where(**condition)
           end
         end
       end

data/lib/active_graph/node/query/query_proxy_methods_of_mass_updating.rb

@@ -25,11 +25,7 @@ module ActiveGraph
         # @param identifier [String,Symbol] the optional identifier of the link in the chain to delete.
         def delete_all(identifier = nil)
           query_with_target(identifier) do |target|
-            begin
-              self.query.with(target).optional_match("(#{target})-[#{target}_rel]-()").delete("#{target}, #{target}_rel").exec
-            rescue Neo4j::Driver::Exceptions::ClientException # <=- Seems hacky
-              self.query.delete(target).exec
-            end
+            query.detach_delete(target).exec
             clear_source_object_cache
           end
         end

data/lib/active_graph/node/query.rb

@@ -16,7 +16,7 @@ module ActiveGraph
       # @param node_var [Symbol, String] The variable name to specify in the query
       # @return [ActiveGraph::Core::Query]
       def query_as(node_var)
-        self.class.query_as(node_var, false).where("ID(#{node_var})" => self.neo_id)
+        self.class.query_as(node_var, false).where("elementId(#{node_var})" => neo_id)
       end
 
       # Starts a new QueryProxy with the starting identifier set to the given argument and QueryProxy source_object set to the node instance.

data/lib/active_graph/node/query_methods.rb

@@ -2,12 +2,12 @@ module ActiveGraph
   module Node
     module QueryMethods
       def exists?(node_condition = nil)
-        unless [Integer, String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
+        unless [String, Hash, NilClass].any? { |c| node_condition.is_a?(c) }
           fail(ActiveGraph::InvalidParameterError, ':exists? only accepts ids or conditions')
         end
         query_start = exists_query_start(node_condition)
         start_q = query_start.respond_to?(:query_as) ? query_start.query_as(:n) : query_start
-        result = start_q.return('ID(n) AS proof_of_life LIMIT 1').first
+        result = start_q.return('elementId(n) AS proof_of_life LIMIT 1').first
         !!result
       end
 
@@ -18,7 +18,7 @@ module ActiveGraph
 
       # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
       def last
-        self.query_as(:n).limit(1).order(n: {primary_key => :desc}).pluck(:n).first
+        self.query_as(:n).limit(1).order(n: { primary_key => :desc }).pluck(:n).first
       end
 
       # @return [Integer] number of nodes of this class
@@ -51,16 +51,13 @@ module ActiveGraph
 
       private
 
-      def exists_query_start(node_condition)
-        case node_condition
-        when Integer
-          self.query_as(:n).where('ID(n)' => node_condition)
-        when String
-          self.query_as(:n).where(n: {primary_key => node_condition})
-        when Hash
-          self.where(node_condition.keys.first => node_condition.values.first)
+      def exists_query_start(condition)
+        return exists_query_start(primary_key => condition) if condition&.is_a?(String)
+
+        if condition&.key?(:neo_id)
+          query_as(:n).where('elementId(n)' => condition[:neo_id])
         else
-          self.query_as(:n)
+          where(**condition)
         end
       end
     end

data/lib/active_graph/railtie.rb

@@ -1,8 +1,16 @@
-# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
-require 'action_dispatch/railtie'
-require 'rails/railtie'
 require 'active_graph'
 
+if defined?(Rails)
+  # Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
+  require 'action_dispatch/railtie'
+  require 'rails/generators'
+  require 'rails/generators/active_model'
+  require 'rails/generators/named_base'
+  require 'rails/railtie'
+  require File.expand_path('../rails/generators/migration_helper.rb', __dir__)
+  Rails::Generators::GeneratedAttribute.include ActiveGraph::Generators::GeneratedAttribute
+end
+
 module ActiveGraph
   class Railtie < ::Rails::Railtie
     def empty_config
@@ -39,13 +47,6 @@ module ActiveGraph
       ActiveGraph::Config[:verbose_query_logs] = false
     end
 
-    # By default, Rails loads generators from load path.
-    # However, if we want to place generators at a different location we have to use "generators" hook
-    # https://api.rubyonrails.org/classes/Rails/Railtie.html
-    generators do
-      require File.expand_path('../rails/generators/migration_helper.rb', __dir__)
-    end
-
     # Starting Neo after :load_config_initializers allows apps to
     # register migrations in config/initializers
     initializer 'neo4j.start', after: :load_config_initializers do |app|

data/lib/active_graph/relationship/initialize.rb

@@ -19,8 +19,8 @@ module ActiveGraph::Relationship
     def init_on_reload(unwrapped_reloaded)
       @attributes = nil
       init_on_load(unwrapped_reloaded,
-                   unwrapped_reloaded.start_node_id,
-                   unwrapped_reloaded.end_node_id,
+                   unwrapped_reloaded.start_node_element_id,
+                   unwrapped_reloaded.end_node_element_id,
                    unwrapped_reloaded.type)
       self
     end

data/lib/active_graph/relationship/persistence.rb

@@ -5,7 +5,9 @@ module ActiveGraph::Relationship
     include ActiveGraph::Shared::Persistence
 
     class RelInvalidError < RuntimeError; end
+
     class ModelClassInvalidError < RuntimeError; end
+
     class RelCreateFailedError < RuntimeError; end
 
     def from_node_identifier
@@ -84,7 +86,7 @@ module ActiveGraph::Relationship
       end
 
       def query_as(neo_id, var = :r)
-        ActiveGraph::Base.new_query.match("()-[#{var}]->()").where(var => {neo_id: neo_id})
+        ActiveGraph::Base.new_query.match("()-[#{var}]->()").where(var => { neo_id: })
       end
     end
 

data/lib/active_graph/relationship/property.rb

@@ -15,7 +15,7 @@ module ActiveGraph::Relationship
     alias end_node to_node
 
     %w(start_node end_node).each do |direction|
-      define_method("#{direction}_id") { send(direction).neo_id if direction }
+      define_method("#{direction}_element_id") { send(direction).neo_id if direction }
     end
 
     # @return [String] a string representing the relationship type that will be created
@@ -45,10 +45,6 @@ module ActiveGraph::Relationship
         end
       end
 
-      def id_property_name
-        false
-      end
-
       %w(to_class from_class).each do |direction|
         define_method(direction.to_s) do |argument = nil|
           if !argument.nil?

data/lib/active_graph/relationship/query.rb

@@ -6,18 +6,17 @@ module ActiveGraph::Relationship
 
     module ClassMethods
       # Returns the object with the specified neo4j id.
-      # @param [String,Integer] id of node to find
+      # @param [String] id of node to find
       def find(id)
-        fail "Unknown argument #{id.class} in find method (expected String or Integer)" if !(id.is_a?(String) || id.is_a?(Integer))
-        find_by_id(id)
+        fail "Unknown argument #{id.class} in find method (expected String)" unless [Integer, String].any?(&id.method(:is_a?))
+        find_by_id(id) || fail(RecordNotFound.new("Couldn't find #{name} with 'id'=#{id.inspect}", name, id))
       end
 
       # Loads the relationship using its neo_id.
       def find_by_id(key)
         query = ActiveGraph::Base.new_query
-        result = query.match('()-[r]-()').where('ID(r)' => key.to_i).limit(1).return(:r).first
-        fail RecordNotFound.new("Couldn't find #{name} with 'id'=#{key.inspect}", name, key) if result.blank?
-        result[:r]
+        result = query.match('()-[r]-()').where("r.#{id_property_name}" => key).limit(1).return(:r).first
+        result&.send(:[], :r)
       end
 
       # Performs a very basic match on the relationship.
@@ -29,6 +28,10 @@ module ActiveGraph::Relationship
         where_query.where(where_string(args)).pluck(:r1)
       end
 
+      def find_by(args)
+        where(args).first
+      end
+
       # Performs a basic match on the relationship, returning all results.
       # This is not executed lazily, it will immediately return matching objects.
       def all
@@ -36,11 +39,11 @@ module ActiveGraph::Relationship
       end
 
       def first
-        all_query.limit(1).order('ID(r1)').pluck(:r1).first
+        all_query.limit(1).order('r1.created_at').pluck(:r1).first
       end
 
       def last
-        all_query.limit(1).order('ID(r1) DESC').pluck(:r1).first
+        all_query.limit(1).order('r1.created_at DESC').pluck(:r1).first
       end
 
       private
@@ -89,7 +92,9 @@ module ActiveGraph::Relationship
       def where_string(args)
         case args
         when Hash
-          args.map { |k, v| v.is_a?(Integer) ? "r1.#{k} = #{v}" : "r1.#{k} = '#{v}'" }.join(', ')
+          args.transform_keys { |key| key == :neo_id ? 'elementId(r1)' : "r1.#{key}" }
+              .transform_values { |v| v.is_a?(Integer) ? v : "'#{v}'" }
+              .map { |k, v| "#{k} = #{v}" }.join(', ')
         else
           args
         end

data/lib/active_graph/relationship/related_node.rb

@@ -17,7 +17,7 @@ module ActiveGraph::Relationship
 
     # Loads the node if needed, then conducts comparison.
     def ==(other)
-      loaded if @node.is_a?(Integer)
+      loaded if @node.is_a?(String)
       @node == other
     end
 
@@ -62,15 +62,11 @@ module ActiveGraph::Relationship
     end
 
     def method_missing(*args, **kwargs, &block)
-      if RUBY_VERSION < '3' && kwargs.empty?
-        loaded.send(*args, &block)
-      else
-        loaded.send(*args, **kwargs, &block)
-      end
+      loaded.send(*args, **kwargs, &block)
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      loaded if @node.is_a?(Numeric)
+      loaded if @node.is_a?(String)
       @node.respond_to?(method_name) ? true : super
     end
 
@@ -85,7 +81,7 @@ module ActiveGraph::Relationship
     end
 
     def valid_node_param?(node)
-      node.nil? || node.is_a?(Integer) || node.respond_to?(:neo_id)
+      node.nil? || node.is_a?(String) || node.respond_to?(:neo_id)
     end
   end
 end

data/lib/active_graph/relationship/types.rb

@@ -67,6 +67,14 @@ module ActiveGraph
           !!@type
         end
 
+        def mapped_element_name
+          @type
+        end
+
+        def mapped_element
+          Core::Type.new(mapped_element_name)
+        end
+
         private
 
         def assign_type!(given_type, auto)

data/lib/active_graph/relationship/wrapping.rb

@@ -13,7 +13,7 @@ module ActiveGraph
 
             return rel
           end.tap do |wrapped_rel|
-            wrapped_rel.init_on_load(rel, rel.start_node_id, rel.end_node_id, rel.type)
+            wrapped_rel.init_on_load(rel, rel.start_node_element_id, rel.end_node_element_id, rel.type)
           end
         end
 

data/lib/active_graph/relationship.rb

@@ -10,6 +10,7 @@ module ActiveGraph
     include ActiveGraph::Relationship::Initialize
     include ActiveGraph::Shared::Identity
     include ActiveGraph::Shared::Marshal
+    include ActiveGraph::Node::IdProperty
     include ActiveGraph::Shared::SerializedProperties
     include ActiveGraph::Relationship::Property
     include ActiveGraph::Relationship::Persistence
@@ -24,6 +25,8 @@ module ActiveGraph
     class FrozenRelError < ActiveGraph::Error; end
 
     def initialize(from_node = nil, to_node = nil, args = nil)
+      self.class.ensure_id_property_info! # So that we make sure all objects have an id_property
+
       load_nodes(node_or_nil(from_node), node_or_nil(to_node))
       resolved_args = hash_or_nil(from_node, args)
       symbol_args = sanitize_input_parameters(resolved_args)
@@ -58,7 +61,7 @@ module ActiveGraph
     private
 
     def node_or_nil(node)
-      node.is_a?(ActiveGraph::Node) || node.is_a?(Integer) ? node : nil
+      node.is_a?(ActiveGraph::Node) || node.is_a?(String) ? node : nil
     end
 
     def hash_or_nil(node_or_hash, hash_or_nil)

data/lib/active_graph/shared/identity.rb

@@ -4,6 +4,7 @@ module ActiveGraph
       def ==(other)
         other.class == self.class && other.id == id
       end
+
       alias eql? ==
 
       # Returns an Enumerable of all (primary) key attributes
@@ -12,11 +13,13 @@ module ActiveGraph
         _persisted_obj ? [id] : nil
       end
 
-      # @return [Integer, nil] the neo4j id of the node if persisted or nil
-      def neo_id
-        _persisted_obj ? _persisted_obj.id : nil
+      # @return [String, nil] the neo4j id of the node if persisted or nil
+      def element_id
+        _persisted_obj&.element_id
       end
 
+      alias neo_id element_id
+
       def id
         if self.class.id_property_name
           send(self.class.id_property_name)

data/lib/active_graph/shared/persistence.rb

@@ -134,7 +134,7 @@ module ActiveGraph::Shared
     def exist?
       return if !_persisted_obj
 
-      neo4j_query(query_as(:n).return('ID(n)')).any?
+      neo4j_query(query_as(:n).return('elementId(n)')).any?
     end
 
     # Returns +true+ if the object was destroyed.
@@ -223,6 +223,17 @@ module ActiveGraph::Shared
       end
     end
 
+    # As the name suggests, this inserts the primary key (id property) into the properties hash.
+    # The method called here, `default_property_values`, is a holdover from an earlier version of the gem. It does NOT
+    # contain the default values of properties, it contains the Default Property, which we now refer to as the ID Property.
+    # It will be deprecated and renamed in a coming refactor.
+    # @param [Hash] converted_props A hash of properties post-typeconversion, ready for insertion into the DB.
+    def inject_primary_key!(converted_props)
+      self.class.default_property_values(self).tap do |destination_props|
+        destination_props.merge!(converted_props) if converted_props.is_a?(Hash)
+      end
+    end
+
     protected
 
     def increment_by_query!(match_query, attribute, by, element_name = :n)

data/lib/active_graph/shared/query_factory.rb

@@ -47,7 +47,7 @@ module ActiveGraph::Shared
 
     def match_query
       base_query
-        .match(match_string).where("ID(#{identifier}) = $#{identifier_id}")
+        .match(match_string).where("elementId(#{identifier}) = $#{identifier_id}")
         .params(identifier_id.to_sym => graph_object.neo_id)
     end
 

data/lib/active_graph/shared/type_converters.rb

@@ -389,7 +389,7 @@ module ActiveGraph::Shared
       def included(_)
         ActiveGraph::Shared::TypeConverters.constants.each do |constant_name|
           constant = ActiveGraph::Shared::TypeConverters.const_get(constant_name)
-          register_converter(constant) if constant.respond_to?(:convert_type)
+          register_converter(constant, force: false) if constant.respond_to?(:convert_type)
         end
       end
 
@@ -425,7 +425,8 @@ module ActiveGraph::Shared
         found_converter.respond_to?(:converted?) ? found_converter.converted?(value) : value.is_a?(found_converter.db_type)
       end
 
-      def register_converter(converter)
+      def register_converter(converter, force: true)
+        return if CONVERTERS.key?(converter.convert_type) && !force
         CONVERTERS[converter.convert_type] = converter
       end
     end