activecypher 0.10.4 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45703ee8a46ca012c9c4e6bd82708f3846bdea0fae15c4fb7fbff7a46d0fb3b3
-  data.tar.gz: 93e134bd2615288003c16c94159344b48023d3d593f45e47441483a5be3c02b1
+  metadata.gz: 2396c4b661d5d743f6c35c7921d020f096531f543c7df9b99e05bddf84c9a2db
+  data.tar.gz: 51e407abc0ac00aaa315fd8acdf489fad8a8d8ae3a46702df4b97c8347ea3fbd
 SHA512:
-  metadata.gz: 9232c48290ea388ad7c49b4a3dfb4ffffc5f4493c33fa3000ad7936c40730f5c6b106a9190b61a52576d80f09c4632a903696f0c0c683332fd6c6325a2c9d7af
-  data.tar.gz: d48c94cf08b6aa3d1a7a9659b13fdde62fdb0ca444a281e97ccea3e28646bc0520702e3f90df59a0e9b2650b48a65e6170cedea896e2a7402901d6df7a5615dc
+  metadata.gz: 210b7c45581497c2ab69a3609e452dba832c0b15ccd3dbf1ee81740f7e4a4c693c537745ea9de13b3904f4c2c5c8386fecfd3fa45eab7e98ce2e7c8976b85cf6
+  data.tar.gz: 29df9c560d01ec8ce6e8c7eee1e977d6a1b61dc532c7af929b3da101fbf9f3440afdd4332a9b7cc2c2f4af1ab420e51bcc21f55841e9a1b57f94120371459610

data/lib/active_cypher/bolt/connection.rb

@@ -230,23 +230,13 @@ module ActiveCypher
       def viable?
         return false unless connected?
 
-        # Perform a lightweight check to verify the connection is still functional
-        begin
-          # Try to send a simple NOOP query to check connection health
-          write_message(Messaging::Run.new('RETURN 1', {}, {}), 'VIABILITY_CHECK')
-          read_message
-
-          # Reset the connection state
-          reset!
+        # Use the health check method to determine viability
+        health = health_check
 
-          # If we got a successful response, the connection is viable
+        if health[:healthy]
           true
-        rescue ConnectionError, ProtocolError
-          # If the connection is broken, close it and return false
-          close
-          false
-        rescue StandardError
-          # For any other errors, also consider the connection non-viable
+        else
+          # If health check failed, close the connection
           close
           false
         end
@@ -480,6 +470,110 @@ module ActiveCypher
         Bolt::Session.new(self, **)
       end
 
+      # Synchronously execute a read transaction.
+      def read_transaction(db: nil, timeout: nil, metadata: nil, &)
+        session(database: db).read_transaction(db: db, timeout: timeout, metadata: metadata, &)
+      end
+
+      # Synchronously execute a write transaction.
+      def write_transaction(db: nil, timeout: nil, metadata: nil, &)
+        session(database: db).write_transaction(db: db, timeout: timeout, metadata: metadata, &)
+      end
+
+      # Asynchronously execute a read transaction.
+      def async_read_transaction(db: nil, timeout: nil, metadata: nil, &)
+        session(database: db).async_read_transaction(db: db, timeout: timeout, metadata: metadata, &)
+      end
+
+      # Asynchronously execute a write transaction.
+      def async_write_transaction(db: nil, timeout: nil, metadata: nil, &)
+        session(database: db).async_write_transaction(db: db, timeout: timeout, metadata: metadata, &)
+      end
+
+      # ────────────────────────────────────────────────────────────────────
+      # HEALTH AND VERSION DETECTION METHODS
+      # ────────────────────────────────────────────────────────────────────
+
+      # Returns parsed version information from the server agent string.
+      #
+      # @return [Hash] version information with :database_type, :version, :major, :minor, :patch
+      # @note Extracts version from server_agent captured during handshake
+      def version
+        return @version if defined?(@version)
+
+        @version = parse_version_from_server_agent
+      end
+
+      # Returns the database type detected from server agent.
+      #
+      # @return [Symbol] :neo4j, :memgraph, or :unknown
+      def database_type
+        version[:database_type]
+      end
+
+      # Performs a health check using database-appropriate queries.
+      #
+      # @return [Hash] health check result with :healthy, :response_time_ms, :details
+      # @note Uses different queries based on detected database type
+      def health_check
+        return { healthy: false, response_time_ms: nil, details: 'Not connected' } unless connected?
+
+        result = nil
+
+        begin
+          Async do
+            result = case database_type
+                     when :neo4j
+                       perform_neo4j_health_check
+                     when :memgraph
+                       perform_memgraph_health_check
+                     else
+                       perform_generic_health_check
+                     end
+          end.wait
+
+          result
+        rescue ConnectionError, ProtocolError => e
+          { healthy: false, response_time_ms: nil, details: "Health check failed: #{e.message}" }
+        end
+      end
+
+      # Returns comprehensive database information.
+      #
+      # @return [Hash] database information including version, health, and system details
+      def database_info
+        info = version.dup
+        health = health_check
+
+        info.merge({
+                     healthy: health[:healthy],
+                     response_time_ms: health[:response_time_ms],
+                     server_agent: @server_agent,
+                     connection_id: @connection_id,
+                     protocol_version: @protocol_version
+                   })
+      end
+
+      # Returns server/cluster status information (when available).
+      #
+      # @return [Array<Hash>, nil] array of server status objects or nil if not supported
+      def server_status
+        return nil unless connected?
+
+        begin
+          case database_type
+          when :neo4j
+            get_neo4j_server_status
+          when :memgraph
+            get_memgraph_server_status
+          else
+            nil
+          end
+        rescue ConnectionError, ProtocolError
+          nil # Gracefully handle unsupported operations
+        end
+      end
+
       # ────────────────────────────────────────────────────────────────────
       # PRIVATE HELPER METHODS
       # ────────────────────────────────────────────────────────────────────
@@ -540,6 +634,317 @@ module ActiveCypher
       # @return [Boolean]
       # @note The Schrödinger's cat of sockets.
       def socket_open? = @socket && !@socket.closed?
+
+      # ────────────────────────────────────────────────────────────────────
+      # HEALTH AND VERSION DETECTION HELPERS
+      # ────────────────────────────────────────────────────────────────────
+
+      # Parses version information from the server_agent string.
+      #
+      # @return [Hash] parsed version information
+      def parse_version_from_server_agent
+        return default_version_info unless @server_agent
+
+        case @server_agent
+        when %r{^Neo4j/(\d+\.\d+(?:\.\d+)?)}i
+          version_string = ::Regexp.last_match(1)
+          parts = version_string.split('.').map(&:to_i)
+          {
+            database_type: :neo4j,
+            version: version_string,
+            major: parts[0] || 0,
+            minor: parts[1] || 0,
+            patch: parts[2] || 0
+          }
+        when %r{^Memgraph/(\d+\.\d+(?:\.\d+)?)}i
+          version_string = ::Regexp.last_match(1)
+          parts = version_string.split('.').map(&:to_i)
+          {
+            database_type: :memgraph,
+            version: version_string,
+            major: parts[0] || 0,
+            minor: parts[1] || 0,
+            patch: parts[2] || 0
+          }
+        when /.*Memgraph/i
+          # Handle Memgraph server agent: "Neo4j/v5.11.0 compatible graph database server - Memgraph"
+          if @server_agent =~ %r{Neo4j/v(\d+\.\d+(?:\.\d+)?)}
+            version_string = ::Regexp.last_match(1)
+            parts = version_string.split('.').map(&:to_i)
+            {
+              database_type: :memgraph,
+              version: version_string,
+              major: parts[0] || 0,
+              minor: parts[1] || 0,
+              patch: parts[2] || 0
+            }
+          else
+            {
+              database_type: :memgraph,
+              version: 'unknown',
+              major: 0,
+              minor: 0,
+              patch: 0
+            }
+          end
+        else
+          {
+            database_type: :unknown,
+            version: @server_agent,
+            major: 0,
+            minor: 0,
+            patch: 0
+          }
+        end
+      end
+
+      # Returns default version info when server_agent is not available.
+      #
+      # @return [Hash] default version information
+      def default_version_info
+        {
+          database_type: :unknown,
+          version: 'unknown',
+          major: 0,
+          minor: 0,
+          patch: 0
+        }
+      end
+
+      # Performs Neo4j-specific health check using RETURN 1 (fallback from db.ping).
+      #
+      # @return [Hash] health check result
+      def perform_neo4j_health_check
+        start_time = Time.now
+
+        begin
+          write_message(Messaging::Run.new('RETURN 1 AS result', {}, {}), 'HEALTH_CHECK')
+          run_response = read_message
+
+          case run_response
+          when Messaging::Success
+            # Send PULL message to complete the transaction
+            write_message(Messaging::Pull.new({ 'n' => -1 }), 'PULL')
+
+            # Read messages until we get SUCCESS or FAILURE
+            response_time = nil
+            loop do
+              msg = read_message
+              case msg
+              when Messaging::Record
+                # Skip records, we just want to know if the query succeeded
+                next
+              when Messaging::Success
+                response_time = ((Time.now - start_time) * 1000).round(2)
+                return { healthy: true, response_time_ms: response_time, details: 'RETURN 1 succeeded' }
+              when Messaging::Failure
+                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 failed with error' }
+              else
+                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 unexpected response' }
+              end
+            end
+          else
+            { healthy: false, response_time_ms: nil, details: 'RETURN 1 run failed' }
+          end
+        ensure
+          # Reset connection state after health check
+          reset!
+        end
+      end
+
+      # Performs Memgraph-specific health check using SHOW STORAGE INFO.
+      #
+      # @return [Hash] health check result
+      def perform_memgraph_health_check
+        start_time = Time.now
+
+        begin
+          write_message(Messaging::Run.new('SHOW STORAGE INFO', {}, {}), 'HEALTH_CHECK')
+          run_response = read_message
+
+          case run_response
+          when Messaging::Success
+            # Send PULL message to complete the transaction
+            write_message(Messaging::Pull.new({ 'n' => -1 }), 'PULL')
+
+            # Read messages until we get SUCCESS or FAILURE
+            response_time = nil
+            loop do
+              msg = read_message
+              case msg
+              when Messaging::Record
+                # Skip records, we just want to know if the query succeeded
+                next
+              when Messaging::Success
+                response_time = ((Time.now - start_time) * 1000).round(2)
+                return { healthy: true, response_time_ms: response_time, details: 'SHOW STORAGE INFO succeeded' }
+              when Messaging::Failure
+                return { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO failed with error' }
+              else
+                return { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO unexpected response' }
+              end
+            end
+          else
+            { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO run failed' }
+          end
+        ensure
+          # Reset connection state after health check
+          reset!
+        end
+      end
+
+      # Performs generic health check using simple RETURN 1 query.
+      #
+      # @return [Hash] health check result
+      def perform_generic_health_check
+        start_time = Time.now
+
+        begin
+          write_message(Messaging::Run.new('RETURN 1', {}, {}), 'HEALTH_CHECK')
+          run_response = read_message
+
+          case run_response
+          when Messaging::Success
+            # Send PULL message to complete the transaction
+            write_message(Messaging::Pull.new({ 'n' => -1 }), 'PULL')
+
+            # Read messages until we get SUCCESS or FAILURE
+            response_time = nil
+            loop do
+              msg = read_message
+              case msg
+              when Messaging::Record
+                # Skip records, we just want to know if the query succeeded
+                next
+              when Messaging::Success
+                response_time = ((Time.now - start_time) * 1000).round(2)
+                return { healthy: true, response_time_ms: response_time, details: 'RETURN 1 succeeded' }
+              when Messaging::Failure
+                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 failed with error' }
+              else
+                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 unexpected response' }
+              end
+            end
+          else
+            { healthy: false, response_time_ms: nil, details: 'RETURN 1 run failed' }
+          end
+        ensure
+          # Reset connection state after health check
+          reset!
+        end
+      end
+
+      # Gets Neo4j server status using SHOW SERVERS query.
+      #
+      # @return [Array<Hash>] server status information
+      def get_neo4j_server_status
+        write_message(Messaging::Run.new('SHOW SERVERS', {}, {}), 'SERVER_STATUS')
+        response = read_message
+
+        case response
+        when Messaging::Success
+          servers = []
+
+          # Read records until we get SUCCESS
+          loop do
+            record_response = read_message
+            case record_response
+            when Messaging::Record
+              # Parse server record - this is a simplified version
+              servers << parse_neo4j_server_record(record_response)
+            when Messaging::Success
+              break
+            else
+              break
+            end
+          end
+
+          servers
+        else
+          []
+        end
+      ensure
+        reset!
+      end
+
+      # Gets Memgraph server status using SHOW DATABASES query.
+      #
+      # @return [Array<Hash>] database status information
+      def get_memgraph_server_status
+        write_message(Messaging::Run.new('SHOW DATABASES', {}, {}), 'SERVER_STATUS')
+        response = read_message
+
+        case response
+        when Messaging::Success
+          databases = []
+
+          # Read records until we get SUCCESS
+          loop do
+            record_response = read_message
+            case record_response
+            when Messaging::Record
+              # Parse database record
+              databases << parse_memgraph_database_record(record_response)
+            when Messaging::Success
+              break
+            else
+              break
+            end
+          end
+
+          databases
+        else
+          # Fallback to SHOW DATABASE for single database info
+          get_memgraph_current_database
+        end
+      ensure
+        reset!
+      end
+
+      # Gets current Memgraph database info using SHOW DATABASE.
+      #
+      # @return [Array<Hash>] current database information
+      def get_memgraph_current_database
+        write_message(Messaging::Run.new('SHOW DATABASE', {}, {}), 'CURRENT_DATABASE')
+        response = read_message
+
+        case response
+        when Messaging::Success
+          [{ name: 'current', status: 'active', type: 'memgraph' }]
+        else
+          []
+        end
+      ensure
+        reset!
+      end
+
+      # Parses a Neo4j server record from SHOW SERVERS result.
+      #
+      # @param record [Messaging::Record] the record message
+      # @return [Hash] parsed server information
+      def parse_neo4j_server_record(_record)
+        # Simplified parsing - in reality this would extract specific fields
+        {
+          name: 'server',
+          address: "#{@host}:#{@port}",
+          state: 'Enabled',
+          health: 'Available',
+          type: 'neo4j'
+        }
+      end
+
+      # Parses a Memgraph database record from SHOW DATABASES result.
+      #
+      # @param record [Messaging::Record] the record message
+      # @return [Hash] parsed database information
+      def parse_memgraph_database_record(_record)
+        # Simplified parsing
+        {
+          name: 'database',
+          status: 'active',
+          type: 'memgraph'
+        }
+      end
     end
   end
 end

data/lib/active_cypher/bolt/session.rb

@@ -119,54 +119,35 @@ module ActiveCypher
       # @param metadata [Hash] Transaction metadata to send to the server.
       # @yield [tx] The transaction to use for queries.
       # @return The result of the block.
-      def run_transaction(mode = :write, db: nil, timeout: nil, metadata: nil, &)
-        # Ensure we're running in an Async context
+      def run_transaction(mode = :write, db: nil, timeout: nil, metadata: nil, &block)
         if Async::Task.current?
-          # Already in an Async task, proceed normally
-          begin
-            execute_transaction(mode, db: db, timeout: timeout, metadata: metadata, &)
-          rescue StandardError => e
-            # Ensure errors are properly propagated
-            raise e
-          end
+          # Already in an async context, just run the block.
+          # The block will run asynchronously within the current task.
+          _execute_transaction_block(mode, db, timeout, metadata, &block)
         else
-          # Wrap in an Async task
-          result = nil
-          error = nil
-
+          # Not in an async context, so we need to create one and wait for it to complete.
           Async do
-            result = execute_transaction(mode, db: db, timeout: timeout, metadata: metadata, &)
-          rescue StandardError => e
-            error = e
+            _execute_transaction_block(mode, db, timeout, metadata, &block)
           end.wait
-
-          # Re-raise any error outside the async block
-          raise error if error
-
-          result
         end
       end
 
-      # Helper method to execute the transaction
-      def execute_transaction(mode, db:, timeout:, metadata:)
-        tx = begin_transaction(db: db,
-                               access_mode: mode,
-                               tx_timeout: timeout,
-                               tx_metadata: metadata)
-
-        result = yield tx           # your block runs here
-        tx.commit                   # happy path
-        result
-      rescue StandardError => e     # any error → rollback → wrap
-        begin
-          tx.rollback
-        rescue StandardError => rollback_error
-          # Log rollback error but continue with the original error
-          puts "Error during rollback: #{rollback_error.message}" if ENV['DEBUG']
-        end
+      # Asynchronously execute a block of code within a transaction.
+      # This method is asynchronous and will return an `Async::Task` that will complete when the transaction is finished.
+      #
+      # @param mode [Symbol] The access mode (:read or :write).
+      # @param db [String] The database name to run the transaction against.
+      # @param timeout [Integer] Transaction timeout in milliseconds.
+      # @param metadata [Hash] Transaction metadata to send to the server.
+      # @yield [tx] The transaction to use for queries.
+      # @return [Async::Task] A task that will complete with the result of the block.
+      def async_run_transaction(mode = :write, db: nil, timeout: nil, metadata: nil, &block)
+        # Ensure we are in an async task, otherwise the behavior is undefined.
+        raise 'Cannot run an async transaction outside of an Async task' unless Async::Task.current?
 
-        # Preserve the original error
-        raise ActiveCypher::TransactionError, e.message
+        Async do
+          _execute_transaction_block(mode, db, timeout, metadata, &block)
+        end
       end
 
       def write_transaction(db: nil, timeout: nil, metadata: nil, &)
@@ -177,6 +158,55 @@ module ActiveCypher
         run_transaction(:read, db: db, timeout: timeout, metadata: metadata, &)
       end
 
+      def async_write_transaction(db: nil, timeout: nil, metadata: nil, &block)
+        async_run_transaction(:write, db: db, timeout: timeout, metadata: metadata, &block)
+      end
+
+      def async_read_transaction(db: nil, timeout: nil, metadata: nil, &block)
+        async_run_transaction(:read, db: db, timeout: timeout, metadata: metadata, &block)
+      end
+
+      # Close the session and any active transaction.
+      def close
+        instrument('session.close') do
+          # If there's an active transaction, try to roll it back
+          @current_transaction&.rollback if @current_transaction&.active?
+
+          # Mark current transaction as complete
+          complete_transaction(@current_transaction) if @current_transaction
+        end
+      end
+
+      private
+
+      def _execute_transaction_block(mode, db, timeout, metadata, &block)
+        tx = begin_transaction(db: db, access_mode: mode, tx_timeout: timeout, tx_metadata: metadata)
+        begin
+          result = block.call(tx)
+          tx.commit
+          result
+        rescue StandardError => e
+          # On any error, rollback the transaction and re-raise the original exception
+          begin
+            tx.rollback
+          rescue StandardError => rollback_error
+            # Log rollback error but continue with the original error
+            puts "Error during rollback: #{rollback_error.message}" if ENV['DEBUG']
+          end
+
+          # Reset the connection to ensure it's in a clean state for the next transaction
+          begin
+            @connection.reset!
+          rescue StandardError => reset_error
+            # If reset fails, the connection will be marked non-viable by the pool
+            puts "Error during connection reset: #{reset_error.message}" if ENV['DEBUG']
+          end
+
+          # Wrap the error in TransactionError to maintain compatibility
+          raise ActiveCypher::TransactionError, e.message
+        end
+      end
+
       # Access the current bookmarks for this session.
       def bookmarks
         @bookmarks || []
@@ -197,17 +227,6 @@ module ActiveCypher
           @connection.reset!
         end
       end
-
-      # Close the session and any active transaction.
-      def close
-        instrument('session.close') do
-          # If there's an active transaction, try to roll it back
-          @current_transaction&.rollback if @current_transaction&.active?
-
-          # Mark current transaction as complete
-          complete_transaction(@current_transaction) if @current_transaction
-        end
-      end
     end
   end
 end

data/lib/active_cypher/connection_adapters/abstract_adapter.rb

@@ -49,6 +49,14 @@ module ActiveCypher
         end
       end
 
+      # Hydrates attributes from a database record
+      # @param record [Hash] The raw record from the database
+      # @param node_alias [Symbol] The alias used for the node in the query
+      # @return [Hash] The hydrated attributes
+      def hydrate_record(record, node_alias)
+        raise NotImplementedError, "#{self.class} must implement #hydrate_record"
+      end
+
       # Get current adapter type for ID handling
       # Helper for generating ID-related Cypher functions that are database-specific
       module CypherFunction

data/lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb

@@ -12,6 +12,13 @@ module ActiveCypher
       include Instrumentation
       attr_reader :connection
 
+      # Returns the raw Bolt connection object
+      # This is useful for accessing low-level connection methods like
+      # read_transaction, write_transaction, async_read_transaction, etc.
+      def raw_connection
+        @connection
+      end
+
       # Establish a connection if not already active.
       # This includes auth token prep, URI parsing, and quiet suffering.
       def connect

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -108,6 +108,30 @@ module ActiveCypher
         metadata.compact
       end
 
+      # Hydrates attributes from a Memgraph record
+      # @param record [Hash] The raw record from Memgraph
+      # @param node_alias [Symbol] The alias used for the node in the query
+      # @return [Hash] The hydrated attributes
+      def hydrate_record(record, node_alias)
+        attrs = {}
+        node_data = record[node_alias] || record[node_alias.to_s]
+
+        if node_data.is_a?(Array) && node_data.length >= 2
+          properties_container = node_data[1]
+          if properties_container.is_a?(Array) && properties_container.length >= 3
+            properties = properties_container[2]
+            properties.each { |k, v| attrs[k.to_sym] = v } if properties.is_a?(Hash)
+          end
+        elsif node_data.is_a?(Hash)
+          node_data.each { |k, v| attrs[k.to_sym] = v }
+        elsif node_data.respond_to?(:properties)
+          attrs = node_data.properties.symbolize_keys
+        end
+
+        attrs[:internal_id] = record[:internal_id] || record['internal_id']
+        attrs
+      end
+
       protected
 
       def parse_schema(rows)

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -130,6 +130,30 @@ module ActiveCypher
         metadata.compact
       end
 
+      # Hydrates attributes from a Neo4j record
+      # @param record [Hash] The raw record from Neo4j
+      # @param node_alias [Symbol] The alias used for the node in the query
+      # @return [Hash] The hydrated attributes
+      def hydrate_record(record, node_alias)
+        attrs = {}
+        node_data = record[node_alias] || record[node_alias.to_s]
+
+        if node_data.is_a?(Array) && node_data.length >= 2
+          properties_container = node_data[1]
+          if properties_container.is_a?(Array) && properties_container.length >= 3
+            properties = properties_container[2]
+            properties.each { |k, v| attrs[k.to_sym] = v } if properties.is_a?(Hash)
+          end
+        elsif node_data.is_a?(Hash)
+          node_data.each { |k, v| attrs[k.to_sym] = v }
+        elsif node_data.respond_to?(:properties)
+          attrs = node_data.properties.symbolize_keys
+        end
+
+        attrs[:internal_id] = record[:internal_id] || record['internal_id']
+        attrs
+      end
+
       module Persistence
         include PersistenceMethods
         module_function :create_record, :update_record, :destroy_record

data/lib/active_cypher/model/querying.rb

@@ -39,9 +39,7 @@ module ActiveCypher
           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
+          # Handle ID format based on adapter type
           formatted_id = if adapter.id_function == 'elementId'
                            internal_db_id.to_s  # String for Neo4j
                          else
@@ -59,7 +57,7 @@ module ActiveCypher
           record = result.first
 
           if record
-            attrs = _hydrate_attributes_from_memgraph_record(record, node_alias)
+            attrs = connection.hydrate_record(record, node_alias)
             return instantiate(attrs)
           end
 
@@ -97,28 +95,6 @@ module ActiveCypher
         # @return [Object] The new, possibly persisted record
         # Because sometimes you just want to live dangerously.
         def create(attrs = {}) = new(attrs).tap(&:save)
-
-        private
-
-        def _hydrate_attributes_from_memgraph_record(record, node_alias)
-          attrs = {}
-          node_data = record[node_alias] || record[node_alias.to_s]
-
-          if node_data.is_a?(Array) && node_data.length >= 2
-            properties_container = node_data[1]
-            if properties_container.is_a?(Array) && properties_container.length >= 3
-              properties = properties_container[2]
-              properties.each { |k, v| attrs[k.to_sym] = v } if properties.is_a?(Hash)
-            end
-          elsif node_data.is_a?(Hash)
-            node_data.each { |k, v| attrs[k.to_sym] = v }
-          elsif node_data.respond_to?(:properties)
-            attrs = node_data.properties.symbolize_keys
-          end
-
-          attrs[:internal_id] = record[:internal_id] || record['internal_id']
-          attrs
-        end
       end
     end
   end

data/lib/active_cypher/relationship.rb

@@ -366,16 +366,14 @@ module ActiveCypher
 
       props  = attributes.except('internal_id').compact
       rel_ty = self.class.relationship_type
-      arrow  = '->' # outgoing by default
-
       adapter = self.class.connection.id_handler
-      parts = []
 
       # Build the Cypher query based on the adapter
       id_clause = adapter.with_direct_node_ids(from_node.internal_id, to_node.internal_id)
+      parts = []
       parts << "MATCH (p), (h) WHERE #{id_clause}"
-      parts << "CREATE (p)-[r:#{rel_ty}]#{arrow}(h)"
-      parts << 'SET r += $props' unless props.empty? # only if we have props
+      parts << "CREATE (p)-[r:#{rel_ty}]->(h)"
+      parts << 'SET r += $props' unless props.empty?
       parts << "RETURN #{adapter.return_id}"
 
       cypher = parts.join(' ')
@@ -383,7 +381,6 @@ module ActiveCypher
 
       # Execute Cypher query
       result = self.class.connection.execute_cypher(cypher, params, 'Create Relationship')
-
       row = result.first
 
       # Try different ways to access the ID

data/lib/active_cypher/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -265,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.7
 specification_version: 4
 summary: OpenCypher Adapter ala ActiveRecord
 test_files: []