activecypher 0.10.4 → 0.11.1

data/lib/active_cypher/bolt/session.rb

@@ -7,6 +7,7 @@ module ActiveCypher
     # It maintains a connection to the database server and allows running queries.
     class Session
       include Instrumentation
+
       attr_reader :connection, :database
 
       def initialize(connection, database: nil)
@@ -120,53 +121,34 @@ module ActiveCypher
       # @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
         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, &)
         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, &)
           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, &)
+        # 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, &)
+        end
       end
 
       def write_transaction(db: nil, timeout: nil, metadata: nil, &)
@@ -177,6 +159,55 @@ module ActiveCypher
         run_transaction(:read, db: db, timeout: timeout, metadata: metadata, &)
       end
 
+      def async_write_transaction(db: nil, timeout: nil, metadata: nil, &)
+        async_run_transaction(:write, db: db, timeout: timeout, metadata: metadata, &)
+      end
+
+      def async_read_transaction(db: nil, timeout: nil, metadata: nil, &)
+        async_run_transaction(:read, db: db, timeout: timeout, metadata: metadata, &)
+      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 +228,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/bolt/transaction.rb

@@ -5,6 +5,7 @@ module ActiveCypher
     # Manages transaction state (BEGIN/COMMIT/ROLLBACK) and runs queries within a transaction.
     class Transaction
       include Instrumentation
+
       attr_reader :bookmarks, :metadata, :connection
 
       # Initializes a new Transaction instance.
@@ -147,11 +148,7 @@ module ActiveCypher
       rescue ConnectionError
         @state = :failed
         # Mark transaction as completed in the session
-        begin
-          @session.complete_transaction(self)
-        rescue StandardError
-          nil
-        end
+        @session.complete_transaction(self)
         raise
       end
 
@@ -184,11 +181,7 @@ module ActiveCypher
         ensure
           # Always mark as rolled back and complete the transaction
           @state = :rolled_back
-          begin
-            @session.complete_transaction(self)
-          rescue StandardError
-            nil
-          end
+          @session.complete_transaction(self)
         end
       end
 

data/lib/active_cypher/connection_adapters/abstract_adapter.rb

@@ -49,32 +49,12 @@ module ActiveCypher
         end
       end
 
-      # Get current adapter type for ID handling
-      # Helper for generating ID-related Cypher functions that are database-specific
-      module CypherFunction
-        # Generate ID equality clause with the ID value embedded in the query for Memgraph
-        def self.id_equals(var, id_value, adapter)
-          func = id_function(adapter)
-          "#{func}(#{var}) = #{id_value}"
-        end
-
-        # Generate ID equality clause using a parameterized ID value for Neo4j
-        def self.id_equals_param(var, param_name, adapter)
-          func = id_function(adapter)
-          "#{func}(#{var}) = $#{param_name}"
-        end
-
-        # Generate a node variable with ID predicate
-        def self.node_with_id(node_var, id_value, adapter)
-          func = id_function(adapter)
-          "#{func}(#{node_var}) = #{id_value}"
-        end
-
-        # Return ID expression
-        def self.return_id(var, as_name, adapter)
-          func = id_function(adapter)
-          "#{func}(#{var}) AS #{as_name}"
-        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
 
       # Turns rows into symbols, because Rubyists fear strings.

data/lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb

@@ -10,8 +10,16 @@ module ActiveCypher
     # It's like ActiveRecord::ConnectionAdapter, but for weirdos like me who use graph databases.
     class AbstractBoltAdapter < AbstractAdapter
       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
@@ -64,7 +72,7 @@ module ActiveCypher
       # Clean disconnection. Resets the internal state.
       def disconnect
         instrument_connection(:disconnect) do
-          @connection&.close
+          @connection.close if @connection
           @connection = nil
           true
         end

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -11,8 +11,6 @@ module ActiveCypher
       def schema_catalog
         rows = run('SHOW SCHEMA')
         parse_schema(rows)
-      rescue StandardError
-        introspect_fallback
       end
 
       # Use id() for Memgraph instead of elementId()
@@ -108,6 +106,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)
@@ -174,6 +196,7 @@ module ActiveCypher
 
       module Persistence
         include PersistenceMethods
+
         module_function :create_record, :update_record, :destroy_record
       end
 

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -33,8 +33,6 @@ module ActiveCypher
 
         Schema::Catalog.new(indexes: idx_defs, constraints: con_defs,
                             node_types: [], edge_types: [])
-      rescue StandardError
-        Schema::Catalog.new(indexes: [], constraints: [], node_types: [], edge_types: [])
       end
 
       # Use elementId() for Neo4j
@@ -130,8 +128,33 @@ 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
       end
 

data/lib/active_cypher/connection_pool.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'concurrent/atomic/atomic_reference'
 require 'timeout'
 
 module ActiveCypher
@@ -24,29 +23,27 @@ module ActiveCypher
 
         # Merge the resolved config with any additional options
         @spec = resolved_config.merge(@spec.except(:url))
-
       end
 
-      @conn_ref = Concurrent::AtomicReference.new # holds the adapter instance
+      @conn_ref = nil # holds the adapter instance
       @creation_mutex = Mutex.new # prevents multiple threads from creating connections simultaneously
-      @retry_count = Concurrent::AtomicReference.new(0)
     end
 
-    # Returns a live adapter, initialising it once in a thread‑safe way.
+    # Returns a live adapter, initializing it once in a thread‑safe way.
     def connection
-      # Fast path —already connected and alive
-      conn = @conn_ref.value
+      # Fast path — already connected and alive
+      conn = @conn_ref
       return conn if conn&.active?
 
       # Use mutex for the slow path to prevent thundering herd
       @creation_mutex.synchronize do
         # Check again inside the mutex in case another thread created it
-        conn = @conn_ref.value
+        conn = @conn_ref
         return conn if conn&.active?
 
         # Create a new connection
         new_conn = build_connection
-        @conn_ref.set(new_conn)
+        @conn_ref = new_conn
         return new_conn
       end
     end
@@ -54,12 +51,12 @@ module ActiveCypher
 
     # Check if the pool has a persistent connection issue
     def troubled?
-      @retry_count.value >= @spec[:max_retries]
+      @retry_count >= @spec[:max_retries]
     end
 
     # Explicitly close and reset the connection
     def disconnect
-      conn = @conn_ref.value
+      conn = @conn_ref
       return unless conn
 
       begin
@@ -68,7 +65,7 @@ module ActiveCypher
         # Log but don't raise to ensure cleanup continues
         puts "Warning: Error disconnecting: #{e.message}" if ENV['DEBUG']
       ensure
-        @conn_ref.set(nil)
+        @conn_ref = nil
       end
     end
 
@@ -91,8 +88,8 @@ module ActiveCypher
       rescue Timeout::Error
         begin
           adapter.disconnect
-        rescue StandardError
-          nil
+        rescue StandardError => e
+          puts "Warning: Error disconnecting during timeout cleanup: #{e.message}" if ENV['DEBUG']
         end
         raise ConnectionError, "Connection timed out after #{@spec[:pool_timeout]} seconds"
       end

data/lib/active_cypher/fixtures.rb

@@ -32,11 +32,7 @@ module ActiveCypher
 
       # 5. Gather unique connections for all model classes referenced in this profile
       model_classes = dsl_context.nodes.map { |node| node[:model_class] }.uniq
-      connections = model_classes.map do |klass|
-        klass.connection
-      rescue StandardError
-        nil
-      end.compact.uniq
+      connections = model_classes.map(&:connection).compact.uniq
 
       # 6. Wipe all nodes in each relevant connection
       connections.each do |conn|
@@ -78,11 +74,7 @@ module ActiveCypher
       end
 
       # Gather unique connections from all model classes
-      connections = model_classes.map do |klass|
-        klass.connection
-      rescue StandardError
-        nil
-      end.compact.uniq
+      connections = model_classes.map(&:connection).compact.uniq
 
       # Wipe all nodes in each connection
       connections.each do |conn|
@@ -104,17 +96,13 @@ module ActiveCypher
         next unless klass < ActiveCypher::Base
         next if klass.respond_to?(:abstract_class?) && klass.abstract_class?
 
-        begin
-          conn = klass.connection
-          # Store connection details for comparison
-          model_connections[klass] = {
-            adapter: conn.class.name,
-            config: conn.instance_variable_get(:@config),
-            object_id: conn.object_id
-          }
-        rescue StandardError
-          # Skip if can't get connection
-        end
+        conn = klass.connection
+        # Store connection details for comparison
+        model_connections[klass] = {
+          adapter: conn.class.name,
+          config: conn.instance_variable_get(:@config),
+          object_id: conn.object_id
+        }
       end
 
       relationships.each do |rel|

data/lib/active_cypher/instrumentation.rb

@@ -132,7 +132,7 @@ module ActiveCypher
     # @param key [String, Symbol] The key to check
     # @return [Boolean] True if the key contains sensitive information
     def sensitive_key?(key)
-      return true if key.to_s.match?(/(^|[\-_])(?:password|token|secret|credential|key)($|[\-_])/i)
+      return true if key.to_s.match?(/(^|[-_])(?:password|token|secret|credential|key)($|[-_])/i)
 
       # Check against Rails filter parameters if available
       if defined?(Rails) && Rails.application

data/lib/active_cypher/logging.rb

@@ -14,11 +14,7 @@ module ActiveCypher
         self.backend ||= begin
           base = Logger.new($stdout)
           base.level = ENV.fetch('AC_LOG_LEVEL', 'info').upcase
-                          .then do |lvl|
-            Logger.const_get(lvl)
-          rescue StandardError
-            Logger::INFO
-          end
+                          .then { |lvl| Logger.const_get(lvl) }
           ActiveSupport::TaggedLogging.new(base).tap { |l| l.tagged! 'ActiveCypher' }
         end
       end

data/lib/active_cypher/migrator.rb

@@ -64,8 +64,6 @@ module ActiveCypher
     def existing_versions
       @connection.execute_cypher('MATCH (m:SchemaMigration) RETURN m.version AS version')
                  .map { |r| r[:version].to_s }
-    rescue StandardError
-      []
     end
 
     def ensure_schema_migration_constraint

data/lib/active_cypher/model/connection_owner.rb

@@ -23,7 +23,8 @@ module ActiveCypher
 
         # Returns the adapter class being used by this model
         def adapter_class
-          connection&.class
+          conn = connection
+          conn&.class
         end
 
         # Always dynamically fetch the connection for the current db_key

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

@@ -73,11 +73,7 @@ module ActiveCypher
 
       return @connection if defined?(@connection) && @connection
 
-      begin
-        from_class.constantize.connection
-      rescue StandardError
-        nil
-      end
+      from_class.constantize.connection
     end
 
     # --------------------------------------------------------------
@@ -301,9 +297,14 @@ module ActiveCypher
           _run(:update) { update_relationship }
         end
       end
-    rescue StandardError => e
-      log_error "Failed to save #{self.class}: #{e.class} – #{e.message}"
-      false
+    rescue ActiveCypher::RecordNotSaved, RuntimeError => e
+      # Only catch specific validation errors, let other errors propagate
+      if e.message.include?('must be persisted') || e.message.include?('creation returned no id')
+        log_error "Failed to save #{self.class}: #{e.message}"
+        false
+      else
+        raise
+      end
     end
 
     # Bang version of save - raises exception if save fails
@@ -366,16 +367,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 +382,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
@@ -399,9 +397,6 @@ module ActiveCypher
       @new_record = false
       changes_applied
       true
-    rescue StandardError => e
-      log_error "Failed to save #{self.class}: #{e.class} – #{e.message}"
-      false
     end
 
     def update_relationship

data/lib/active_cypher/version.rb

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

data/lib/cyrel/ast/clause_adapter.rb

@@ -9,20 +9,14 @@ module Cyrel
 
       def initialize(ast_node)
         @ast_node = ast_node
-        @ast_node_hash = ast_node.hash
         super()
       end
 
       def render(query)
-        # Use a simple cache key based on AST node structure
-        cache_key = [@ast_node_hash, @ast_node.class.name].join(':')
-
-        SimpleCache.instance.fetch(cache_key) do
-          # Create a compiler that delegates parameter registration to the query
-          compiler = QueryIntegratedCompiler.new(query)
-          compiler.compile(ast_node)
-          compiler.output.string
-        end
+        # Create a compiler that delegates parameter registration to the query
+        compiler = QueryIntegratedCompiler.new(query)
+        compiler.compile(ast_node)
+        compiler.output.string
       end
 
       # Ruby 3.0+ pattern matching support