activecypher 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ccd00478564eeb903b76a423867e21973268d6c23af232de7329abe94263d5
-  data.tar.gz: a6e74f587ad7c543123840d5f44440efca909a44efa0a59be5b8ce15d8d39f0f
+  metadata.gz: bcfe9f62e0fdcf58b7d4f46fef0b7869bac550fc730f2e93a2d057938cad8a4e
+  data.tar.gz: a835e25b6ff10e6e9e4884c2855091e617086e1635931988cc018d9eac06afd8
 SHA512:
-  metadata.gz: 1b90a82d07ffc1504ddf9d07fcd88a80d3371d32ed09eb8f799c4d228958e090522a44cac2abd6bdf661983fda43ce95b898fe440f8e76c0427621f55ad342a0
-  data.tar.gz: bd848d6485fdc502673f88ad3ea3dd776d486a1e11cf501592994efba1347cb799b28af0b6f06e5a29daf3a60c79c39072181fb03d36f0938df5ed52699bd881
+  metadata.gz: 4297ab6127aa159da2800dd2024102e8768cfac6604ce390fa35d71d95b393e3226a6d544e535ccc09c14d1632a23009c48df5067a62b6f158fc344b7e1ff21c
+  data.tar.gz: b929133db5f0be22b7fbd2e3923e54b0a6b041e748d28dc32bbd6f454ab0547ea48637a945262b480339ccee8e78551b23b64cd6aea8a276c5f3d5e766adbc8d

data/lib/active_cypher/associations/collection_proxy.rb

@@ -128,9 +128,9 @@ module ActiveCypher
           arrow = (dir == :both ? :'--' : :out)
           Cyrel
             .match(Cyrel.node(from_node.class.label_name).as(:a)
-                        .where(Cyrel.id(:a).eq(from_node.internal_id)))
+                        .where(Cyrel.node_id(:a).eq(from_node.internal_id)))
             .match(Cyrel.node(to_node.class.label_name).as(:b)
-                        .where(Cyrel.id(:b).eq(to_node.internal_id)))
+                        .where(Cyrel.node_id(:b).eq(to_node.internal_id)))
             .create(Cyrel.node(:a).rel(arrow, reflection[:relationship]).to(:b))
             .tap { |qry| owner.class.connection.execute_cypher(*qry.to_cypher, 'Create Association') }
         end

data/lib/active_cypher/associations.rb

@@ -142,7 +142,7 @@ module ActiveCypher
           # Compose query  MATCH – WHERE – RETURN
           query = Cyrel::Query.new
                               .match(path)
-                              .where(Cyrel.id(a_alias).eq(internal_id))
+                              .where(Cyrel.node_id(a_alias).eq(internal_id))
                               .return_(b_alias)
 
           base_relation = Relation.new(target_class, query)
@@ -186,7 +186,7 @@ module ActiveCypher
 
           query = Cyrel::Query.new
                               .match(path)
-                              .where(Cyrel.id(a_alias).eq(internal_id))
+                              .where(Cyrel.node_id(a_alias).eq(internal_id))
                               .return_(b_alias)
                               .limit(1)
 
@@ -225,8 +225,8 @@ module ActiveCypher
                                       .rel(cyrel_direction, rel_type)
                                       .as(del_rel_alias)
                                       .to(del_end_alias))
-                        .where(Cyrel.id(del_start_alias).eq(del_start_node.internal_id))
-                        .where(Cyrel.id(del_end_alias).eq(del_end_node.internal_id))
+                        .where(Cyrel.node_id(del_start_alias).eq(del_start_node.internal_id))
+                        .where(Cyrel.node_id(del_end_alias).eq(del_end_node.internal_id))
                         .delete(del_rel_alias)
 
             self.class.connection.execute_cypher(
@@ -266,8 +266,8 @@ module ActiveCypher
               create_query = Cyrel
                              .match(Cyrel.node(new_start_node.class.label_name).as(new_start_alias))
                              .match(Cyrel.node(new_end_node.class.label_name).as(new_end_alias))
-                             .where(Cyrel.id(new_start_alias).eq(new_start_node.internal_id))
-                             .where(Cyrel.id(new_end_alias).eq(new_end_node.internal_id))
+                             .where(Cyrel.node_id(new_start_alias).eq(new_start_node.internal_id))
+                             .where(Cyrel.node_id(new_end_alias).eq(new_end_node.internal_id))
                              .create(Cyrel.node(new_start_alias)
                                             .rel(arrow, rel_type)
                                             .to(new_end_alias))
@@ -322,7 +322,7 @@ module ActiveCypher
           target_node_alias = :target_node
 
           start_node_pattern = Cyrel.node(self.class.label_name).as(start_node_alias)
-                                    .where(Cyrel.id(start_node_alias).eq(internal_id))
+                                    .where(Cyrel.node_id(start_node_alias).eq(internal_id))
           target_node_pattern = Cyrel.node(target_class.label_name).as(target_node_alias)
 
           rel_pattern = case direction
@@ -372,10 +372,10 @@ module ActiveCypher
             # Adjust direction for Cyrel pattern if needed
             cyrel_direction = direction == :in ? :out : direction
             del_query = Cyrel.match(Cyrel.node(del_start_node.class.label_name)
-                                         .as(del_start_alias).where(Cyrel.id(del_start_alias)
+                                         .as(del_start_alias).where(Cyrel.node_id(del_start_alias)
                                                                          .eq(del_start_node.internal_id)))
                              .match(Cyrel.node(del_end_node.class.label_name)
-                                         .as(del_end_alias).where(Cyrel.id(del_end_alias)
+                                         .as(del_end_alias).where(Cyrel.node_id(del_end_alias)
                                                                        .eq(del_end_node.internal_id)))
                              .match(Cyrel.node(del_start_alias).rel(cyrel_direction,
                                                                     rel_type).as(del_rel_alias).to(del_end_alias))
@@ -411,10 +411,10 @@ module ActiveCypher
               new_start_alias = :a
               new_end_alias = :b
               create_query = Cyrel.match(Cyrel.node(new_start_node.class.label_name)
-                                              .as(new_start_alias).where(Cyrel.id(new_start_alias)
+                                              .as(new_start_alias).where(Cyrel.node_id(new_start_alias)
                                                                               .eq(new_start_node.internal_id)))
                                   .match(Cyrel.node(new_end_node.class.label_name)
-                                              .as(new_end_alias).where(Cyrel.id(new_end_alias)
+                                              .as(new_end_alias).where(Cyrel.node_id(new_end_alias)
                                                                             .eq(new_end_node.internal_id)))
                                   .create(Cyrel.node(new_start_alias).rel(:out, rel_type).to(new_end_alias))
 
@@ -488,7 +488,7 @@ module ActiveCypher
 
         # Start node pattern
         start_node_pattern = Cyrel.node(self.class.label_name).as(start_node_alias)
-                                  .where(Cyrel.id(start_node_alias).eq(internal_id))
+                                  .where(Cyrel.node_id(start_node_alias).eq(internal_id))
 
         # Intermediate node pattern (based on through_reflection)
         intermediate_node_pattern = Cyrel.node(intermediate_class.label_name).as(intermediate_node_alias)

data/lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'uri'
+require 'async'
 
 module ActiveCypher
   module ConnectionAdapters
@@ -99,6 +100,55 @@ module ActiveCypher
         # Return handler for connection to store
       end
 
+      # Reset the connection state by sending a RESET message.
+      # This clears any pending work and returns the connection to a clean state.
+      # Useful for error recovery or connection pooling.
+      #
+      # @return [Boolean] true if reset succeeded, false otherwise
+      def reset!
+        return false unless active?
+
+        instrument_connection(:reset, config) do
+          # Wrap in async to handle the connection reset properly
+          result = nil
+          error = nil
+
+          Async do
+            begin
+              # Try to execute a simple query first
+              session = Bolt::Session.new(@connection)
+              session.run('RETURN 1 AS check', {})
+              session.close
+              result = true
+            rescue StandardError => e
+              # Query failed, need to reset the connection
+              logger.debug { "Connection needs reset: #{e.message}" }
+
+              # Send RESET message directly
+              begin
+                @connection.write_message(Bolt::Messaging::Reset.new)
+                response = @connection.read_message
+                result = response.is_a?(Bolt::Messaging::Success)
+                logger.debug { "Reset response: #{response.class}" }
+              rescue StandardError => reset_error
+                logger.error { "Reset failed: #{reset_error.message}" }
+                result = false
+              end
+            end
+          rescue StandardError => e
+            error = e
+          end.wait
+
+          raise error if error
+
+          result
+        end
+      rescue StandardError => e
+        # This is madness!
+        logger.error { "Failed to reset connection: #{e.message}" }
+        false
+      end
+
       protected
 
       # These must be defined by subclasses. If you don't override them,

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_cypher/schema/catalog'
-
 module ActiveCypher
   module ConnectionAdapters
     class MemgraphAdapter < AbstractBoltAdapter
@@ -41,15 +39,58 @@ module ActiveCypher
         'id(r) AS rid'
       end
 
+      # Additional helper methods for nodes
+      def self.node_id_where(alias_name, param_name = nil)
+        if param_name
+          "id(#{alias_name}) = $#{param_name}"
+        else
+          "id(#{alias_name})"
+        end
+      end
+
+      def self.node_id_equals_value(alias_name, value)
+        "id(#{alias_name}) = #{value}"
+      end
+
+      def self.return_node_id(alias_name, as_name = 'internal_id')
+        "id(#{alias_name}) AS #{as_name}"
+      end
+
+      def self.id_function
+        'id'
+      end
+
       # Return self as id_handler for compatibility with tests
       def id_handler
         self.class
       end
 
-      # Memgraph defaults to **implicit auto‑commit** transactions :contentReference[oaicite:1]{index=1},
+      # Override run to execute queries without explicit transactions
+      # Memgraph auto‑commits each query, so we send RUN + PULL directly
+      def run(cypher, params = {}, context: 'Query', db: nil, access_mode: :write)
+        connect
+        logger.debug { "[#{context}] #{cypher} #{params.inspect}" }
+
+        instrument_query(cypher, params, context: context, metadata: { db: db, access_mode: access_mode }) do
+          session = Bolt::Session.new(connection)
+
+          rows = session.run_transaction(access_mode, db: db) do |tx|
+            result = tx.run(cypher, prepare_params(params))
+            result.respond_to?(:to_a) ? result.to_a : result
+          end
+
+          session.close
+          rows
+        end
+      end
+
+      # Memgraph defaults to **implicit auto‑commit** transactions
       # so we simply run the Cypher and return the rows.
       def execute_cypher(cypher, params = {}, ctx = 'Query')
-        rows = run(cypher.gsub(/\belementId\(/i, 'id('), params, context: ctx)
+        # Replace adapter-aware placeholder with Memgraph's id function
+        # Because Memgraph insists on being different and using id() instead of elementId()
+        cypher = cypher.gsub('__NODE_ID__', 'id')
+        rows = run(cypher, params, context: ctx)
         process_records(rows)
       end
 
@@ -122,6 +163,11 @@ module ActiveCypher
         end
       end
 
+      module Persistence
+        include PersistenceMethods
+        module_function :create_record, :update_record, :destroy_record
+      end
+
       class ProtocolHandler < AbstractProtocolHandler
         def extract_version(agent)
           agent[%r{Memgraph/([\d.]+)}, 1] || 'unknown'

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_cypher/schema/catalog'
-
 module ActiveCypher
   module ConnectionAdapters
     class Neo4jAdapter < AbstractBoltAdapter
@@ -63,8 +61,40 @@ module ActiveCypher
         'elementId(r) AS rid'
       end
 
+      # Additional helper methods for nodes
+      def self.node_id_where(alias_name, param_name = nil)
+        if param_name
+          "elementId(#{alias_name}) = $#{param_name}"
+        else
+          "elementId(#{alias_name})"
+        end
+      end
+
+      def self.node_id_equals_value(alias_name, value)
+        # Quote string values for Cypher because Neo4j is paranoid about injection attacks
+        # (As it should be, have you seen what people try to inject these days?)
+        quoted_value = value.is_a?(String) ? "'#{value}'" : value
+        "elementId(#{alias_name}) = #{quoted_value}"
+      end
+
+      def self.return_node_id(alias_name, as_name = 'internal_id')
+        "elementId(#{alias_name}) AS #{as_name}"
+      end
+
+      def self.id_function
+        'elementId'
+      end
+
+      # Return self as id_handler for compatibility
+      def id_handler
+        self.class
+      end
+
       def execute_cypher(cypher, params = {}, ctx = 'Query')
         connect
+        # Replace adapter-aware placeholder with Neo4j's elementId function
+        cypher = cypher.gsub('__NODE_ID__', 'elementId')
+        
         session = connection.session # thin wrapper around Bolt::Session
         result  = session.write_transaction do |tx|
           logger.debug { "[#{ctx}] #{cypher} #{params.inspect}" }
@@ -100,6 +130,11 @@ module ActiveCypher
         metadata.compact
       end
 
+      module Persistence
+        include PersistenceMethods
+        module_function :create_record, :update_record, :destroy_record
+      end
+
       protected
 
       def protocol_handler_class = ProtocolHandler

data/lib/active_cypher/connection_adapters/persistence_methods.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module ConnectionAdapters
+    # Common persistence helpers shared by adapters
+    module PersistenceMethods
+      # Create a record in the database and update model state.
+      # @param model [ActiveCypher::Base, ActiveCypher::Relationship] the model instance
+      # @return [Boolean] true if created successfully
+      def create_record(model)
+        props = model.send(:attributes_for_persistence)
+        labels = if model.class.respond_to?(:labels)
+                   model.class.labels
+                 else
+                   [model.class.label_name.to_s]
+                 end
+        label_string = labels.map { |l| ":#{l}" }.join
+
+        adapter = model.connection.id_handler
+        cypher = "CREATE (n#{label_string} $props) RETURN #{adapter.return_node_id('n')}"
+        data = model.connection.execute_cypher(cypher, { props: props }, 'Create')
+
+        return false if data.blank? || !data.first.key?(:internal_id)
+
+        model.internal_id = data.first[:internal_id]
+        model.instance_variable_set(:@new_record, false)
+        model.send(:changes_applied)
+        true
+      end
+
+      # Update a record in the database based on model changes.
+      # @param model [ActiveCypher::Base, ActiveCypher::Relationship] the model instance
+      # @return [Boolean] true if update succeeded
+      def update_record(model)
+        changes = model.send(:changes_to_save)
+        return true if changes.empty?
+
+        labels = if model.class.respond_to?(:labels)
+                   model.class.labels
+                 else
+                   [model.class.label_name.to_s]
+                 end
+
+        label_string = labels.map { |l| ":#{l}" }.join
+        set_clauses = changes.keys.map { |property| "n.#{property} = $#{property}" }.join(', ')
+
+        adapter = model.connection.id_handler
+        # Convert internal_id to its preferred existential format
+        # Neo4j wants strings because it's complicated, Memgraph wants integers because it's not
+        node_id_param = adapter.id_function == 'elementId' ? model.internal_id.to_s : model.internal_id.to_i
+        params = changes.merge(node_id: node_id_param)
+
+        cypher = "MATCH (n#{label_string}) WHERE #{adapter.node_id_where('n', 'node_id')} SET #{set_clauses} RETURN n"
+        model.connection.execute_cypher(cypher, params, 'Update')
+
+        model.send(:changes_applied)
+        true
+      end
+
+      # Destroy a record in the database.
+      # @param model [ActiveCypher::Base, ActiveCypher::Relationship] the model instance
+      # @return [Boolean] true if a record was deleted
+      def destroy_record(model)
+        labels = if model.class.respond_to?(:labels)
+                   model.class.labels
+                 else
+                   [model.class.label_name]
+                 end
+        label_string = labels.map { |l| ":#{l}" }.join
+
+        adapter = model.connection.id_handler
+        # Convert internal_id to whatever format makes the database feel validated
+        # It's like therapy, but for graph databases
+        node_id_param = adapter.id_function == 'elementId' ? model.internal_id.to_s : model.internal_id.to_i
+
+        cypher = <<~CYPHER
+          MATCH (n#{label_string})
+          WHERE #{adapter.node_id_where('n', 'node_id')}
+          DETACH DELETE n
+          RETURN count(*) AS deleted
+        CYPHER
+
+        result = model.connection.execute_cypher(cypher, { node_id: node_id_param }, 'Destroy')
+        result.present? && result.first[:deleted].to_i.positive?
+      end
+    end
+  end
+end

data/lib/active_cypher/connection_url_resolver.rb

@@ -9,9 +9,11 @@ module ActiveCypher
   #
   # Supported URL prefixes:
   # - neo4j://
+  # - neo4j+s:// (alias for neo4j+ssc://)
   # - neo4j+ssl://
   # - neo4j+ssc://
   # - memgraph://
+  # - memgraph+s:// (alias for memgraph+ssc://)
   # - memgraph+ssl://
   # - memgraph+ssc://
   #
@@ -138,10 +140,14 @@ module ActiveCypher
 
       return nil unless SUPPORTED_ADAPTERS.include?(adapter)
 
-      modifiers = parts.select { |mod| %w[ssl ssc].include?(mod) }
+      # Map 's' to 'ssc' for Neo4j compatibility (self-signed certificates)
+      mapped_parts = parts.map { |mod| mod == 's' ? 'ssc' : mod }
+      modifiers = mapped_parts.select { |mod| %w[ssl ssc].include?(mod) }
 
       # If there are parts that are neither the adapter nor valid modifiers, the URL is invalid
-      remaining_parts = parts - modifiers
+      # Check against original parts but also accept 's' as valid
+      valid_modifiers = %w[ssl ssc s]
+      remaining_parts = parts.reject { |part| valid_modifiers.include?(part) }
       return nil if remaining_parts.any?
 
       [adapter, modifiers]

data/lib/active_cypher/fixtures/node_builder.rb

@@ -17,10 +17,11 @@ module ActiveCypher
         label_clause = labels.map { |label| "`#{label}`" }.join(':')
 
         # Build and fire the CREATE query.
-        # We use id(n) because elementId(n) lies to us with strings.
+        # Ask the adapter how it likes its IDs served - string or integer, sir?
+        adapter = conn.id_handler
         cypher = <<~CYPHER
           CREATE (n:#{label_clause} $props)
-          RETURN n, id(n) AS internal_id, properties(n) AS props
+          RETURN n, #{adapter.return_node_id('n')}, properties(n) AS props
         CYPHER
 
         result = conn.execute_cypher(cypher, props: props)

data/lib/active_cypher/generators/templates/cypher_databases.yml

@@ -1,11 +1,11 @@
 development:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>
 
 test:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>
 
 production:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>

data/lib/active_cypher/model/core.rb

@@ -12,7 +12,11 @@ module ActiveCypher
         include ActiveCypher::Associations
         include ActiveCypher::Scoping
 
-        attribute :internal_id, :integer
+        # internal_id: The ID that proves you exist in the graph's eyes
+        # String type because Neo4j needs UUIDs like "4:abc:xyz" to feel special
+        # while Memgraph just counts sheep like a normal database.
+        # ActiveModel will convert between them, hopefully without existential dread
+        attribute :internal_id, :string
 
         class_attribute :configurations, instance_accessor: false,
                                          default: ActiveSupport::HashWithIndifferentAccess.new

data/lib/active_cypher/model/destruction.rb

@@ -20,20 +20,10 @@ module ActiveCypher
           raise 'Cannot destroy a new record' if new_record?
           raise 'Record already destroyed' if destroyed?
 
-          n = :n
-          labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
-          label_string = labels.map { |l| ":#{l}" }.join
+          adapter = adapter_class
+          raise NotImplementedError, "#{adapter} does not implement Persistence" unless adapter&.const_defined?(:Persistence)
 
-          cypher = <<~CYPHER
-            MATCH (#{n}#{label_string})
-            WHERE id(#{n}) = #{internal_id}
-            DETACH DELETE #{n}
-            RETURN count(*) AS deleted
-          CYPHER
-
-          result = self.class.connection.execute_cypher(cypher, {}, 'Destroy')
-
-          if result.present? && result.first[:deleted].to_i.positive?
+          if adapter::Persistence.destroy_record(self)
             @destroyed = true
             freeze
             true

data/lib/active_cypher/model/persistence.rb

@@ -121,40 +121,10 @@ module ActiveCypher
       # Because nothing says "production ready" like a hand-crafted query.
       # If this method ever works on the first try, that's not engineering—it's back magick.
       def create_record
-        props = attributes_for_persistence
-        n = :n
-
-        # Use all labels for database operations
-        labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name.to_s]
-
-        # For Memgraph, construct direct Cypher query
-        label_string = labels.map { |l| ":#{l}" }.join
-
-        # Handle properties for Cypher query
-        props_str = props.map do |k, v|
-          value_str = if v.nil?
-                        'NULL'
-                      elsif v.is_a?(String)
-                        "'#{v.gsub("'", "\\\\'")}'"
-                      elsif v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass)
-                        v.to_s
-                      else
-                        "'#{v.to_s.gsub("'", "\\\\'")}'"
-                      end
-          "#{k}: #{value_str}"
-        end.join(', ')
-
-        cypher = "CREATE (#{n}#{label_string} {#{props_str}}) " \
-                 "RETURN id(#{n}) AS internal_id"
-
-        data = self.class.connection.execute_cypher(cypher, {}, 'Create')
-
-        return false if data.blank? || !data.first.key?(:internal_id)
-
-        self.internal_id = data.first[:internal_id]
-        @new_record = false
-        changes_applied
-        true
+        adapter = adapter_class
+        raise NotImplementedError, "#{adapter} does not implement Persistence" unless adapter&.const_defined?(:Persistence)
+
+        adapter::Persistence.create_record(self)
       end
 
       # Returns a hash of attributes that have changed and their spicy new values.
@@ -173,35 +143,10 @@ module ActiveCypher
       #
       # @return [Boolean] true if we updated something, or just acted like we did.
       def update_record
-        changes = changes_to_save
-        return true if changes.empty?
-
-        # Use all labels for database operations
-        labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
-
-        label_string = labels.map { |l| ":#{l}" }.join
-        set_clauses = changes.map do |property, value|
-          # Handle different value types appropriately
-          if value.nil?
-            "n.#{property} = NULL"
-          elsif value.is_a?(String)
-            "n.#{property} = '#{value.gsub("'", "\\\\'")}'"
-          elsif value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
-            "n.#{property} = #{value}"
-          else
-            "n.#{property} = '#{value.to_s.gsub("'", "\\\\'")}'"
-          end
-        end.join(', ')
-
-        cypher = "MATCH (n#{label_string}) " \
-                 "WHERE id(n) = #{internal_id} " \
-                 "SET #{set_clauses} " \
-                 'RETURN n'
-
-        self.class.connection.execute_cypher(cypher, {}, 'Update')
+        adapter = adapter_class
+        raise NotImplementedError, "#{adapter} does not implement Persistence" unless adapter&.const_defined?(:Persistence)
 
-        changes_applied
-        true
+        adapter::Persistence.update_record(self)
       end
     end
   end

data/lib/active_cypher/model/querying.rb

@@ -33,16 +33,25 @@ module ActiveCypher
         # Find a node by internal DB ID. Returns the record or dies dramatically.
         # Because sometimes you want to find a node, and sometimes you want to find existential dread.
         def find(internal_db_id)
-          internal_db_id = internal_db_id.to_i if internal_db_id.respond_to?(:to_i)
           node_alias = :n
 
           labels = respond_to?(:labels) ? self.labels : [label_name]
-          Cyrel.match(Cyrel.node(node_alias, labels: labels)).limit(1)
+          adapter = connection.id_handler
           label_string = labels.map { |l| ":#{l}" }.join
+
+          # Handle ID format based on adapter's preferred flavor of existential crisis
+          # Neo4j insists on string IDs like "4:uuid:wtf" because simple integers are for peasants
+          # Memgraph keeps it real with numeric IDs because it doesn't need to prove anything
+          formatted_id = if adapter.id_function == 'elementId'
+                           internal_db_id.to_s  # String for Neo4j
+                         else
+                           internal_db_id.to_i  # Numeric for Memgraph
+                         end
+
           cypher = <<~CYPHER
             MATCH (#{node_alias}#{label_string})
-            WHERE id(#{node_alias}) = #{internal_db_id}
-            RETURN #{node_alias}, id(#{node_alias}) AS internal_id
+            WHERE #{adapter.node_id_equals_value(node_alias, formatted_id)}
+            RETURN #{node_alias}, #{adapter.return_node_id(node_alias)}
             LIMIT 1
           CYPHER
 

data/lib/active_cypher/relation.rb

@@ -142,7 +142,7 @@ module ActiveCypher
 
       Cyrel
         .match(Cyrel.node(node_alias, labels: labels))
-        .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
+        .return_(node_alias, Cyrel.node_id(node_alias).as(:internal_id))
     end
 
     # Actually loads the records from the database, shattering the illusion of laziness.

data/lib/active_cypher/relationship.rb

@@ -29,6 +29,9 @@ require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveCypher
   class Relationship
+    # Define connects_to_mappings as a class attribute to match ActiveCypher::Base
+    class_attribute :connects_to_mappings, default: {}
+
     # --------------------------------------------------------------
     # Mix‑ins
     # --------------------------------------------------------------
@@ -47,7 +50,10 @@ module ActiveCypher
     # --------------------------------------------------------------
     # Attributes
     # --------------------------------------------------------------
-    attribute :internal_id, :integer
+    # internal_id: Your relationship's social security number, but less secure
+    # String because Neo4j relationships have commitment issues and need complex IDs
+    # Memgraph relationships just want a simple number, like the good old days with MS Access.
+    attribute :internal_id, :string
 
     # --------------------------------------------------------------
     # Connection fallback

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.7.1'
+  VERSION = '0.7.3'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/cyrel/functions.rb

@@ -18,14 +18,25 @@ module Cyrel
     # --- Common Cypher Functions ---
 
     # Use elementId() instead of deprecated id()
+    # @deprecated Use {#node_id} instead for adapter-aware ID handling
     def element_id(node_variable)
       Expression::FunctionCall.new(:elementId, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
+    # @deprecated Use {#node_id} instead for adapter-aware ID handling
     def id(node_variable)
       Expression::FunctionCall.new(:id, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
+    # Adapter-aware node ID function
+    # Generates a placeholder that will be replaced by the correct ID function
+    # at execution time based on the database adapter (Neo4j vs Memgraph)
+    # Because databases can't agree on how to name their ID functions,
+    # we'll just pretend they're all the same and fix it later
+    def node_id(node_variable)
+      Expression::FunctionCall.new(:__NODE_ID__, Clause::Return::RawIdentifier.new(node_variable.to_s))
+    end
+
     # Because apparently, COUNT(*) isn’t obvious enough.
     # Handles the 'give me everything and make it snappy' use case.
     def count(expression, distinct: false)

data/lib/cyrel/pattern/node.rb

@@ -7,7 +7,7 @@ module Cyrel
   module Pattern
     class Node
       include ActiveModel::Model
-      include ActiveModel::Attributes # :contentReference[oaicite:3]{index=3}
+      include ActiveModel::Attributes
       include Cyrel::Parameterizable
 
       attribute :alias_name, Cyrel::Types::SymbolType.new

data/lib/cyrel.rb

@@ -35,11 +35,15 @@ module Cyrel
 
   # Cyrel DSL helper: returns the element id of a node/relationship.
   # Example: Cyrel.id(:n)
-  def id(...) = Functions.element_id(...)
+  def id(...) = Functions.id(...)
 
   # Cyrel DSL helper: returns the element id of a node/relationship (alias).
   def element_id(...) = Functions.element_id(...)
 
+  # Cyrel DSL helper: adapter-aware node ID function
+  # Example: Cyrel.node_id(:n)
+  def node_id(...) = Functions.node_id(...)
+
   # Cyrel DSL helper: Cypher count() aggregation.
   # Example: Cyrel.count(:n)
   def count(...) = Functions.count(...)

data/lib/tasks/graphdb_migrate.rake

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 namespace :graphdb do
+  # bin/rails graphdb:migrate
   desc 'Run graph database migrations'
   task migrate: :environment do
     ActiveCypher::Migrator.new.migrate!
     puts 'GraphDB migrations complete'
   end
 
+  # bin/rails graphdb:status
   desc 'Show graph database migration status'
   task status: :environment do
     ActiveCypher::Migrator.new.status.each do |m|
-      puts format('%-4s %s %s', m[:status], m[:version], m[:name])
+      puts format('%-4<status>s %<version>s %<name>s', m)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -119,6 +119,7 @@ files:
 - lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb
 - lib/active_cypher/connection_adapters/memgraph_adapter.rb
 - lib/active_cypher/connection_adapters/neo4j_adapter.rb
+- lib/active_cypher/connection_adapters/persistence_methods.rb
 - lib/active_cypher/connection_adapters/registry.rb
 - lib/active_cypher/connection_handler.rb
 - lib/active_cypher/connection_pool.rb