neo4j-ruby-driver 4.4.0.alpha.7 → 4.4.0.alpha.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a035a8385e54c70c851003ce4131072610617d515f118d2d4b03f6ada71de3a7
-  data.tar.gz: bc8dfddb76165d4aea25d702e1d4bb1be5db3bb375d25f48fab39acb7f247c07
+  metadata.gz: d282964e01764e3a21d07c1e836567b3bc1f334e08d45b7392984db661faa14a
+  data.tar.gz: afc45978f3583f6f491c75c5f4f9da89099620d0be88c0367c8e9469554ecc20
 SHA512:
-  metadata.gz: 17a1b5ada9f09120e7dda4316504d59fedf366696d27c26e87c5feeee381a876409a75eaa05cbc177af64415946af7ec8c1de7b4ed5e637ffc464a40c1fd4eea
-  data.tar.gz: aa41d20c4794dac6841aa1bf70cb0c3e8573a658e74d8aa4e475f45a2a0a9072056633a83f8744251014ab5a805b6ec368f4a75b036316c2179bc1bcc1f8f8fa
+  metadata.gz: 0a40657edbf022793691d6926f93ae779d4b671878cdbd29538a0ff83bd82de1912210380715390219503a1fbfb3ada37ae70cce66e6184664b1a90fbff12f80
+  data.tar.gz: 4ae8f0cb141fc923df3fc8bfab0696adb979a40331e76a440096eb64b3d8060a2f70e49934ed6af06015f734cc1d4f85468b0118b3231db1df4369ff93c0fa63

data/ruby/neo4j/driver/graph_database.rb

@@ -26,12 +26,12 @@ module Neo4j::Driver
         )
       end
 
-      def routing_driver(routing_uris, auth_toke, **config)
+      def routing_driver(routing_uris, auth_token, **config)
         assert_routing_uris(routing_uris)
         log = Config.new(**config)[:logger]
 
         routing_uris.each do |uri|
-          driver = driver(uri, auth_toke, **config)
+          driver = driver(uri, auth_token, **config)
           begin
             return driver.tap(&:verify_connectivity)
           rescue Exceptions::ServiceUnavailableException => e

data/ruby/neo4j/driver/internal/async/inbound/inbound_message_dispatcher.rb

@@ -59,7 +59,8 @@ module Neo4j::Driver
             raise @current_error if Util::ErrorUtil.fatal?(@current_error) # TODO clarify
 
             if @current_error.is_a?(Exceptions::AuthorizationExpiredException)
-              Connection::ChannelAttributes.authorization_state_listener(@channel).on_expired(@current_error, @channel)
+              # TODO: ??????
+              # Connection::ChannelAttributes.authorization_state_listener(@channel).on_expired(@current_error, @channel)
             else
               # write a RESET to "acknowledge" the failure
               enqueue(Handlers::ResetResponseHandler.new(self))
@@ -115,8 +116,6 @@ module Neo4j::Driver
           end
 
           def clear_current_error
-            raise @current_error if @current_error
-          ensure
             @current_error = nil
           end
 

data/ruby/neo4j/driver/internal/async/unmanaged_transaction.rb

@@ -52,28 +52,30 @@ module Neo4j::Driver
         def close_async(commit = false, complete_with_null_if_not_open = true)
           @lock.synchronize do
             if complete_with_null_if_not_open && !open?
-              nil
+              Util::ResultHolder.successful(nil)
             elsif @state == State::COMMITTED
-              raise Neo4j::Driver::Exceptions::ClientException, commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG
+              Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(
+                commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG))
             elsif @state == State::ROLLED_BACK
-              raise Neo4j::Driver::Exceptions::ClientException, commit ? CANT_COMMIT_ROLLED_BACK_MSG : CANT_ROLLBACK_ROLLED_BACK_MSG
+              Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(
+                commit ? CANT_COMMIT_ROLLED_BACK_MSG : CANT_ROLLBACK_ROLLED_BACK_MSG))
             else
               if commit
                 if @rollback_pending
-                  raise Neo4j::Driver::Exceptions::ClientException, CANT_COMMIT_ROLLING_BACK_MSG
+                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_COMMIT_ROLLING_BACK_MSG))
                 elsif @commit_pending
                   @commit_pending
                 else
-                  @commit_pending = true
+                  @commit_pending = Util::ResultHolder.new
                   nil
                 end
               else
                 if @commit_pending
-                  raise Neo4j::Driver::Exceptions::ClientException, CANT_ROLLBACK_COMMITTING_MSG
+                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_ROLLBACK_COMMITTING_MSG))
                 elsif @rollback_pending
                   @rollback_pending
                 else
-                  @rollback_pending = true
+                  @rollback_pending = Util::ResultHolder.new
                   nil
                 end
               end
@@ -83,22 +85,18 @@ module Neo4j::Driver
               if commit
                 target_future = @commit_pending
                 target_action = lambda { |throwable|
-                  do_commit_async(throwable)
-                  handle_commit_or_rollback(throwable)
+                  do_commit_async(throwable).chain(&handle_commit_or_rollback(throwable))
                 }
               else
                 target_future = @rollback_pending
                 target_action = lambda { |throwable|
-                  do_rollback_async
-                  handle_commit_or_rollback(throwable)
+                  do_rollback_async.chain(&handle_commit_or_rollback(throwable))
                 }
               end
 
               @result_cursors.retrieve_not_consumed_error.then(&target_action)
-              handle_transaction_completion(commit, nil)
+                             .side { |_, error| handle_transaction_completion(commit, error) }.copy_to(target_future)
               target_future
-            rescue => throwable
-              handle_transaction_completion(commit, throwable)
             end
         end
 
@@ -148,7 +146,7 @@ module Neo4j::Driver
               raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has been rolled back'
             when State::TERMINATED
               # TODO clunky positional arguments of Neo4jException#initialize, move to named parameters
-              raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has either experienced an fatal error or was explicitly terminated'#, # TODO should be able to pass @cause_of_termination
+              raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has either experienced an fatal error or was explicitly terminated' #, # TODO should be able to pass @cause_of_termination
             end
           end
         end
@@ -175,23 +173,23 @@ module Neo4j::Driver
           end
 
           if exception
-            Util::Futures.failed_future(exception)
+            Util::ResultHolder.failed(exception)
           else
-            @protocol.commit_transaction(@connection, @bookmark_holder)
+            @protocol.commit_transaction(@connection).then(&@bookmark_holder.method(:bookmark=))
           end
         end
 
         def do_rollback_async
           if @lock.synchronize { @state } == State::TERMINATED
-            Util::Futures.completed_with_null
+            Util::ResultHolder.successful(nil)
           else
             @protocol.rollback_transaction(@connection)
           end
         end
 
         def handle_commit_or_rollback(cursor_failure)
-          lambda { |_fulfilled, _value, commit_or_rollback_error|
-            combined_error = Util::Futures.combined_error(cursor_failure, commit_or_rollback_error)
+          lambda { |_value, commit_or_rollback_error|
+            combined_error = Util::Futures.combine_errors(cursor_failure, commit_or_rollback_error)
             raise combined_error if combined_error
           }
         end

data/ruby/neo4j/driver/internal/cluster/cluster_routing_table.rb

@@ -105,8 +105,8 @@ module Neo4j::Driver
           addresses.map { |address| address == old_address ? new_address : address }.freeze
         end
 
-        def new_with_reused_addresses(current_addresses, disused_addresses, new_addresses)
-          (current_addresses + disused_addresses + new_addresses).freeze
+        def new_with_reused_addresses(*addresses)
+          addresses.map(&:to_set).reduce(&:+).freeze
         end
 
         def to_bolt_server_address(address)

data/ruby/neo4j/driver/internal/cluster/single_database_routing_procedure_runner.rb

@@ -16,9 +16,9 @@ module Neo4j::Driver
           delegate = connection(connection)
           procedure = procedure_query(connection.server_version, database_name)
           bookmark_holder = bookmark_holder(bookmark)
-          records = run_procedure(delegate, procedure, bookmark_holder)
-          release_connection(delegate)
-          process_procedure_response(procedure, records, error)
+          run_procedure(delegate, procedure, bookmark_holder)
+            .side { release_connection(delegate) }
+            .chain { |records, error| process_procedure_response(procedure, records, error) }
         end
 
         private
@@ -32,7 +32,7 @@ module Neo4j::Driver
             raise Exceptions::FatalDiscoveryException, "Refreshing routing table for multi-databases is not supported in server version lower than 4.0. Current server version: #{server_version}. Database name: '#{database_name.description}'"
           end
 
-          Query.new(GET_ROUTING_TABLE, Values.parameters(ROUTING_CONTEXT, @context.to_map))
+          Query.new(GET_ROUTING_TABLE, ROUTING_CONTEXT => @context.to_h)
         end
 
         def bookmark_holder(_ignored)
@@ -43,7 +43,7 @@ module Neo4j::Driver
           connection.protocol
                     .run_in_auto_commit_transaction(connection, procedure, bookmark_holder, TransactionConfig.empty,
                                                     Handlers::Pulln::FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-                    .async_result.to_a
+                    .async_result.then(&:to_a)
         end
 
         def release_connection(connection)
@@ -56,17 +56,15 @@ module Neo4j::Driver
         end
 
         def process_procedure_response(procedure, records, error)
-          cause = Util::Futures.completion_exception_cause(error)
-
-          return RoutingProcedureResponse.new(procedure, records) if cause.nil?
-
-          handle_error(procedure, cause)
+          error ? handle_error(procedure, error) : RoutingProcedureResponse.new(procedure, records: records)
         end
 
         def handle_error(procedure, error)
-          return RoutingProcedureResponse.new(procedure, records) if error.is_a? Exceptions::ClientException
-
-          raise java.util.concurrent.CompletionException, error
+          if error.is_a? Exceptions::ClientException
+            RoutingProcedureResponse.new(procedure, error: error)
+          else
+            raise error
+          end
         end
       end
     end

data/ruby/neo4j/driver/internal/cursor/async_result_cursor_impl.rb

@@ -15,20 +15,24 @@ module Neo4j::Driver
         end
 
         def single_async
-          first_record = next_async
-          unless first_record
-            raise Exceptions::NoSuchRecordException, 'Cannot retrieve a single record, because this result is empty.'
-          end
-          if next_async
-            raise Exceptions::NoSuchRecordException,
-                  'Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.'
+          next_async.compose do |first_record|
+            unless first_record
+              raise Exceptions::NoSuchRecordException, 'Cannot retrieve a single record, because this result is empty.'
+            end
+            next_async.then do |second_record|
+              if second_record
+                raise Exceptions::NoSuchRecordException,
+                      'Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.'
+              end
+              first_record
+            end
           end
-          first_record
         end
 
         def each(&action)
-          internal_for_each_async(&action)
-          consume_async
+          result_holder = Util::ResultHolder.new
+          internal_for_each_async(result_holder, &action)
+          result_holder.then { consume_async }
         end
 
         def to_async(&map_function)
@@ -37,7 +41,7 @@ module Neo4j::Driver
 
         def discard_all_failure_async
           # runError has priority over other errors and is expected to have been reported to user by now
-          consume_async #.chain { |_fulfilled, _summary, error| @run_error ? nil : error }
+          consume_async.chain { |_summary, error| run_error ? nil : error }
           nil
         end
 
@@ -46,18 +50,25 @@ module Neo4j::Driver
           @pull_all_handler.pull_all_failure_async.then { |error| run_error ? nil : error }
         end
 
-        private def internal_for_each_async
-          while record = next_async
-            begin
-              yield record
-            rescue
-              nil
+        private def internal_for_each_async(result_holder, &action)
+          next_async.chain do |record, error|
+            if error
+              result_holder.fail(error)
+            elsif record
+              begin
+                yield record
+              rescue => action_error
+                result_holder.fail(action_error)
+              end
+              internal_for_each_async(result_holder, &action)
+            else
+              result_holder.succeed(nil)
             end
           end
         end
 
         def map_successful_run_completion_async
-          run_error || self
+          run_error&.then(&Util::ResultHolder.method(:failed)) || Util::ResultHolder.successful(self)
         end
 
         def run_error

data/ruby/neo4j/driver/internal/cursor/disposable_async_result_cursor.rb

@@ -40,7 +40,7 @@ module Neo4j::Driver
         end
 
         private def assert_not_disposed
-          raise Neo4j::Driver::Internal::Util.new_result_consumed_error if @disposed
+          raise Util::ErrorUtil.new_result_consumed_error if @disposed
         end
 
         def disposed?
@@ -48,7 +48,7 @@ module Neo4j::Driver
         end
 
         def map_successful_run_completion_async
-          @delegate.map_successful_run_completion_async
+          @delegate.map_successful_run_completion_async.then { self }
         end
       end
     end

data/ruby/neo4j/driver/internal/handlers/commit_tx_response_handler.rb

@@ -4,16 +4,16 @@ module Neo4j::Driver
       class CommitTxResponseHandler
         include Spi::ResponseHandler
 
-        def initialize(completion_listener)
-          @completion_listener = completion_listener
+        def initialize(result_holder)
+          @result_holder = result_holder
         end
 
         def on_success(metadata)
-          @completion_listener.bookmark = metadata[:bookmark]&.then(&InternalBookmark.method(:parse))
+          @result_holder.succeed(metadata[:bookmark]&.then(&InternalBookmark.method(:parse)))
         end
 
         def on_failure(error)
-          raise error
+          @result_holder.fail(error)
         end
 
         def on_record(fields)

data/ruby/neo4j/driver/internal/handlers/legacy_pull_all_response_handler.rb

@@ -4,6 +4,7 @@ module Neo4j::Driver
       # This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions.
       class LegacyPullAllResponseHandler
         include Spi::ResponseHandler
+        include Enumerable
         RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
@@ -67,7 +68,9 @@ module Neo4j::Driver
           while @records.empty? && !(@ignore_records || @finished)
             @records.wait
           end
-          @records.items.first
+          record = @records.items.first
+
+          Util::ResultHolder.successful(record)
 
           # if record.nil?
           #   return Util::Futures.failed_future(extract_failure) unless @failure.nil?
@@ -84,17 +87,25 @@ module Neo4j::Driver
         end
 
         def next_async
-          dequeue_record if peek_async
+          # dequeue_record if peek_async
+          peek_async.then { |record| dequeue_record if record }
         end
 
         def consume_async
           @ignore_records = true
           @records.items.clear
 
-          if pull_all_failure_async.nil?
-            @summary
+          # if pull_all_failure_async.nil?
+          #   # @summary.then(&Util::ResultHolder.method(:successful))
+          #   Util::ResultHolder.successful(@summary)
+          # else
+          #   raise pull_all_failure_async
+          # end
+
+          if @failure
+            Util::ResultHolder.failed(extract_failure)
           else
-            raise Util::Futures.as_completion_exception, pull_all_failure_async
+            Util::ResultHolder.successful(@summary)
           end
 
           # pull_all_failure_async do |error|
@@ -106,13 +117,22 @@ module Neo4j::Driver
           # end
         end
 
-        def list_async(map_function)
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
-            end
+        # def list_async(map_function)
+        #   pull_all_failure_async.then_apply do |error|
+        #     unless error.nil?
+        #       raise Util::Futures.as_completion_exception, error
+        #     end
 
-            records_as_list(map_function)
+        #     records_as_list(map_function)
+        #   end
+        # end
+
+        def each
+          pull_all_failure_async.then do
+            unless @finished
+              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+            end
+            @records.each { |record| yield record }
           end
         end
 
@@ -122,7 +142,8 @@ module Neo4j::Driver
 
         def pull_all_failure_async
           if !@failure.nil?
-            return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
+            return Util::ResultHolder.failed(extract_failure)
+            # return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
           elsif @finished
             return nil
             # return Util::Futures.completed_with_null
@@ -191,33 +212,41 @@ module Neo4j::Driver
         end
 
         def complete_record_future(record)
-          unless @record_future.nil?
-            future = @record_future
-            @record_future = nil
-            future.complete(record)
-          end
+          # unless @record_future.nil?
+          #   future = @record_future
+          #   @record_future = nil
+          #   future.complete(record)
+          # end
+          @record_future&.succeed(record)
+          @record_future = nil
         end
 
         def fail_record_future(error)
-          unless @record_future.nil?
-            future = @record_future
-            @record_future = nil
-            future.complete_exceptionally(error)
-            return true
-          end
+          # unless @record_future.nil?
+          #   future = @record_future
+          #   @record_future = nil
+          #   future.complete_exceptionally(error)
+          #   return true
+          # end
 
-          false
+          # false
+            @record_future&.fail(error)
+          ensure
+            @record_future = nil
         end
 
         def complete_failure_future(error)
-          unless @failure_future.nil?
-            future = @failure_future
-            @failure_future = nil
-            future.complete(error)
-            return true
-          end
+          # unless @failure_future.nil?
+          #   future = @failure_future
+          #   @failure_future = nil
+          #   future.complete(error)
+          #   return true
+          # end
 
-          false
+          # false
+          @failure_future&.fail(error)
+        ensure
+          @failure_future = nil
         end
 
         def extract_result_summary(metadata)

data/ruby/neo4j/driver/internal/handlers/pulln/auto_pull_response_handler.rb

@@ -3,6 +3,7 @@ module Neo4j::Driver
     module Handlers
       module Pulln
         class AutoPullResponseHandler < BasicPullResponseHandler
+          include Enumerable
           delegate :signal, to: :@records
           LONG_MAX_VALUE = 2 ** 63 - 1
 
@@ -55,7 +56,7 @@ module Neo4j::Driver
 
           private def handle_failure(error)
             # error has not been propagated to the user, remember it
-            unless fail_record_future(error) && fail_summary_future(error)
+            unless fail_record_future(error) || fail_summary_future(error)
               @failure = error
             end
           end
@@ -64,26 +65,31 @@ module Neo4j::Driver
             while @records.empty? && !done?
               @records.wait
             end
-            @records.items.first
+            @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
+              completed_with_value_if_no_failure(nil)
           end
 
           def next_async
-            dequeue_record if peek_async
+            peek_async.then { |record| dequeue_record if record }
           end
 
           def consume_async
             @records.items.clear
-            return completed_with_value_if_no_failure(@summary) if done?
-            cancel
-            @summary
+            cancel unless done?
+            completed_with_value_if_no_failure(@summary)
           end
 
-          def list_async(&map_function)
-            pull_all_async.then_apply(-> (summary) { records_as_list(&map_function) })
+          def each
+            pull_all_async.then do
+              unless done?
+                raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+              end
+              @records.each { |record| yield record }
+            end
           end
 
           def pull_all_failure_async
-            pull_all_async
+            pull_all_async.chain { |_, error| error }
           end
 
           def pre_populate_records
@@ -94,12 +100,8 @@ module Neo4j::Driver
 
           def pull_all_async
             return completed_with_value_if_no_failure(@summary) if done?
-
             request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-
-            @summary_future = java.util.concurrent.CompletableFuture.new if @summary_future.nil?
-
-            @summary_future
+            @summary_future ||= Util::ResultHolder.new
           end
 
           def enqueue_record(record)
@@ -122,14 +124,6 @@ module Neo4j::Driver
             record
           end
 
-          def records_as_list(&map_function)
-            unless done?
-              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
-            end
-
-            @records.each.map(&map_function)
-          end
-
           def extract_failure
             @failure or raise Exceptions::IllegalStateException, "Can't extract failure because it does not exist"
           ensure
@@ -137,39 +131,34 @@ module Neo4j::Driver
           end
 
           def complete_record_future(record)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-            end
+            @record_future&.succeed(record)
+            @record_future = nil
           end
 
           def complete_summary_future(summary)
-            unless @summary_future.nil?
-              future = @summary_future
-              @summary_future = nil
-              future.complete(summary)
-            end
+            @summary_future&.succeed(summary)
+            @summary_future = nil
           end
 
           def fail_record_future(error)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-              return true
-            end
+            @record_future&.fail(error)
+          ensure
+            @record_future = nil
+          end
 
-            false
+          def fail_summary_future(error)
+            @summary_future&.fail(error)
+          ensure
+            @summary_future = nil
           end
 
           def completed_with_value_if_no_failure(value)
-            @failure ? extract_failure : value
+            if @failure
+              Util::ResultHolder.failed(extract_failure)
+            else
+              Util::ResultHolder.successful(value)
+            end
           end
-
-          # def request(size)
-          #   @auto_pull_enabled ? Async { super } : super
-          # end
         end
       end
     end

data/ruby/neo4j/driver/internal/handlers/rollback_tx_response_handler.rb

@@ -3,11 +3,17 @@ module Neo4j::Driver
     module Handlers
       class RollbackTxResponseHandler
         include Spi::ResponseHandler
+
+        def initialize(result_holder)
+          @result_holder = result_holder
+        end
+
         def on_success(_metadata)
+          @result_holder.succeed
         end
 
         def on_failure(error)
-          raise error
+          @result_holder.fail(error)
         end
 
         def on_record(fields)

data/ruby/neo4j/driver/internal/internal_result.rb

@@ -19,19 +19,19 @@ module Neo4j::Driver
       end
 
       def has_next?
-        @cursor.peek_async
+        @cursor.peek_async.result!
       end
 
       def next
-        @cursor.next_async || raise(Exceptions::NoSuchRecordException.no_more)
+        @cursor.next_async.result! || raise(Exceptions::NoSuchRecordException.no_more)
       end
 
       def single
-        @cursor.single_async
+        @cursor.single_async.result!
       end
 
       def peek
-        @cursor.peek_async or raise Exceptions::NoSuchRecordException.no_peek_past
+        @cursor.peek_async.result! or raise Exceptions::NoSuchRecordException.no_peek_past
       end
 
       def each
@@ -39,7 +39,7 @@ module Neo4j::Driver
       end
 
       def consume
-        @cursor.consume_async
+        @cursor.consume_async.result!
       end
 
       def remove

data/ruby/neo4j/driver/internal/internal_session.rb

@@ -17,7 +17,7 @@ module Neo4j::Driver
         Validator.require_hash_parameters!(parameters)
         cursor = @session.run_async(Query.new(query, **parameters), **TransactionConfig.new(**config.compact)) do
           terminate_connection_on_thread_interrupt('Thread interrupted while running query in session')
-        end
+        end.result!
 
         # query executed, it is safe to obtain a connection in a blocking way
         connection = @session.connection_async

data/ruby/neo4j/driver/internal/internal_transaction.rb

@@ -10,28 +10,28 @@ module Neo4j::Driver
       end
 
       def commit
-        @tx.commit_async
+        @tx.commit_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.commit_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while committing the transaction')
         # end
       end
 
       def rollback
-        @tx.rollback_async
+        @tx.rollback_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.rollback_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while rolling back the transaction')
         # end
       end
 
       def close
-        @tx.close_async
+        @tx.close_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.close_async) do
         #     terminate_connection_on_thread_interrupt('Thread interrupted while closing the transaction')
         #   end
       end
 
       def run(query, **parameters)
-        cursor = @tx.run_async(Query.new(query, **parameters))
+        cursor = @tx.run_async(Query.new(query, **parameters)).result!
         # cursor = org.neo4j.driver.internal.util.Futures.blockingGet(@tx.run_async(to_statement(query, parameters))) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while running query in transaction')
         # end

data/ruby/neo4j/driver/internal/messaging/request/abstract_streaming_message.rb

@@ -4,7 +4,10 @@ module Neo4j::Driver
       module Request
         class AbstractStreamingMessage < Struct.new(:n, :qid)
           STREAM_LIMIT_UNLIMITED = -1
-          alias metadata to_h
+
+          def metadata
+            to_h.compact
+          end
 
           def to_s
             "#{name} #{metadata}"

data/ruby/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -36,12 +36,16 @@ module Neo4j::Driver
             connection.write_and_flush(begin_message, Handlers::BeginTxResponseHandler.new)
           end
 
-          def commit_transaction(connection, bookmark_holder)
-            connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(bookmark_holder))
+          def commit_transaction(connection)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(result_holder))
+            end
           end
 
           def rollback_transaction(connection)
-            connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new(result_holder))
+            end
           end
 
           def run_in_auto_commit_transaction(connection, query, bookmark_holder, config, fetch_size)

data/ruby/neo4j/driver/internal/resolved_bolt_server_address.rb

@@ -22,7 +22,7 @@ module Neo4j::Driver
         @string_value
       end
 
-      private def attributes
+      def attributes
         super + [@resolved_addresses]
       end
 

data/ruby/neo4j/driver/internal/util/result_holder.rb

@@ -0,0 +1,70 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class ResultHolder
+        def self.successful(result = nil)
+          new.tap { |holder| holder.succeed(result) }
+        end
+
+        def self.failed(error)
+          new.tap { |holder| holder.fail(error) }
+        end
+
+        def succeed(result = nil)
+          if @completed
+            false
+          else
+            @result = result
+            true
+          end
+        ensure
+          @completed = true
+        end
+
+        def fail(error)
+          if @completed
+            false
+          else
+            @error = error
+            true
+          end
+        ensure
+          @completed = true
+        end
+
+        def result!
+          raise @error if @error
+          @result
+        end
+
+        def then
+          @error ? self : ResultHolder.successful(yield(@result))
+        end
+
+        # &block returns a ResultHolder
+        def compose
+          @error ? self : yield(@result)
+        end
+
+        def chain
+          ResultHolder.successful(yield(@result, @error))
+        rescue => error
+          ResultHolder.failed(error)
+        end
+
+        def side
+          yield(@result, @error)
+          self
+        end
+
+        def copy_to(result_holder)
+          if @error
+            result_holder.fail(@error)
+          else
+            result_holder.succeed(@result)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '4.4.0.alpha.7'
+    VERSION = '4.4.0.alpha.8'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 4.4.0.alpha.7
+  version: 4.4.0.alpha.8
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-10 00:00:00.000000000 Z
+date: 2022-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -467,6 +467,7 @@ files:
 - ruby/neo4j/driver/internal/util/metadata_extractor.rb
 - ruby/neo4j/driver/internal/util/mutex.rb
 - ruby/neo4j/driver/internal/util/preconditions.rb
+- ruby/neo4j/driver/internal/util/result_holder.rb
 - ruby/neo4j/driver/internal/util/server_version.rb
 - ruby/neo4j/driver/logging1.rb
 - ruby/neo4j/driver/net/server_address.rb