activecypher 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ccd00478564eeb903b76a423867e21973268d6c23af232de7329abe94263d5
-  data.tar.gz: a6e74f587ad7c543123840d5f44440efca909a44efa0a59be5b8ce15d8d39f0f
+  metadata.gz: 738573111aeb926ef359c2bd2643e07d25f83b76d63f7cebf0d31e762c06fabf
+  data.tar.gz: 8ede3884325f7e86e4ca06dea636e0193d8742fc19b0ed2e92724f3270f31f7f
 SHA512:
-  metadata.gz: 1b90a82d07ffc1504ddf9d07fcd88a80d3371d32ed09eb8f799c4d228958e090522a44cac2abd6bdf661983fda43ce95b898fe440f8e76c0427621f55ad342a0
-  data.tar.gz: bd848d6485fdc502673f88ad3ea3dd776d486a1e11cf501592994efba1347cb799b28af0b6f06e5a29daf3a60c79c39072181fb03d36f0938df5ed52699bd881
+  metadata.gz: afc1446c1c2e7195ed3ad241e84bcdaffaf9c634084068088f15137f897ea4955d80448af5b80b225af204a23baa217486b4327160b50b7bd41899d7c6b95df1
+  data.tar.gz: f5cf3960f8127672e803d9dd9d2246e8245499e2f7208013e2bd97a4e5971fbcd5044aa107bcf1208a21cfc40337d0c89cbc3354706dce06f0bb1df8b62d84a3

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
@@ -46,7 +44,26 @@ module ActiveCypher
         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)
@@ -122,6 +139,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
@@ -100,6 +98,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,77 @@
+# 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
+
+        cypher = "CREATE (n#{label_string} $props) RETURN id(n) AS internal_id"
+        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(', ')
+        params = changes.merge(node_id: model.internal_id)
+
+        cypher = "MATCH (n#{label_string}) WHERE id(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
+
+        cypher = <<~CYPHER
+          MATCH (n#{label_string})
+          WHERE id(n) = $node_id
+          DETACH DELETE n
+          RETURN count(*) AS deleted
+        CYPHER
+
+        result = model.connection.execute_cypher(cypher, { node_id: model.internal_id }, 'Destroy')
+        result.present? && result.first[:deleted].to_i.positive?
+      end
+    end
+  end
+end

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/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
     # --------------------------------------------------------------

data/lib/active_cypher/version.rb

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

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/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.2
 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