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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a035a8385e54c70c851003ce4131072610617d515f118d2d4b03f6ada71de3a7
-  data.tar.gz: bc8dfddb76165d4aea25d702e1d4bb1be5db3bb375d25f48fab39acb7f247c07
+  metadata.gz: 41dc794832386239a05ddcc44bb1937da85f8d1b3d0be4977ab3b53157ab5ac0
+  data.tar.gz: e085f6bfce9255985ead9e0aab6bd70a8495f9b62bbfa16fbe38efaac1508032
 SHA512:
-  metadata.gz: 17a1b5ada9f09120e7dda4316504d59fedf366696d27c26e87c5feeee381a876409a75eaa05cbc177af64415946af7ec8c1de7b4ed5e637ffc464a40c1fd4eea
-  data.tar.gz: aa41d20c4794dac6841aa1bf70cb0c3e8573a658e74d8aa4e475f45a2a0a9072056633a83f8744251014ab5a805b6ec368f4a75b036316c2179bc1bcc1f8f8fa
+  metadata.gz: d3eeaeaeb2a4f8d19ffacdec93f2fb64ff5c8a65ab27bf6593d4ae3ce2c08e092b97662bd6ab58f4cc59a5bb4d2215e1c8fe80c916c05eda9e9b9454b72411a5
+  data.tar.gz: 0a86332ba42e153c1f21964fbca5a0cdba75bf5b3cea574ce40db4a1a54f090dd43d1b1f6096acb51e04ac7d6cdddaf03a3f84dad6fb4582de911d11f22824b5

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/network_connection.rb

@@ -79,11 +79,10 @@ module Neo4j::Driver
 
         def terminate_and_release(reason)
           if @status.compare_and_set(Status::OPEN, Status::TERMINATED)
-            Connection::ChannelAttributes.set_termination_reason(@channel, reason)
-            Util::Futures.as_completion_stage(@channel.close).exceptionally(-> (_throwable) { nil }).then_compose(-> (_ignored) { @channel_pool.release(@channel) }).when_complete do |_ignored, _throwable|
-              @release_future.complete(nil)
-              @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
-            end
+            @channel.attributes[:termination_reason] = reason
+            @channel.close rescue nil
+            @channel_pool.release(@channel)
+            # @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
           end
         end
 
@@ -96,7 +95,7 @@ module Neo4j::Driver
             # auto-read could've been disabled, re-enable it to automatically receive response for RESET
             @channel.auto_read = true
             @message_dispatcher.enqueue(reset_handler)
-            @channel.write_and_flush(Messaging::Request::ResetMessage::RESET)#.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+            @channel.write_and_flush(Messaging::Request::ResetMessage::RESET) #.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
           end
         end
 

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

@@ -22,12 +22,6 @@ module Neo4j::Driver
           new_result_cursor.map_successful_run_completion_async
         end
 
-        def run_rx(query, **config)
-          new_result_cursor_stage = build_result_cursor_factory(query, config).then_flat(Cursor::ResultCursorFactory.rx_result)
-          @result_cursor_stage = new_result_cursor_stage.rescue {}
-          new_result_cursor_stage
-        end
-
         def begin_transaction_async(mode = @mode, **config)
           ensure_session_is_open
           ensure_no_open_tx_before_starting_tx
@@ -67,9 +61,12 @@ module Neo4j::Driver
         def close_async
           return unless @open.make_false
           # there exists a cursor with potentially unconsumed error, try to extract and propagate it
-          @result_cursor&.discard_all_failure_async
-        ensure
+          error = @result_cursor&.discard_all_failure_async
           close_transaction_and_release_connection
+        rescue => tx_close_error
+          error = Util::Futures.combine_errors(error, tx_close_error)
+        ensure
+          raise error if error
         end
 
         def current_connection_open?
@@ -89,7 +86,7 @@ module Neo4j::Driver
 
         def acquire_connection(mode)
           # make sure previous result is fully consumed and connection is released back to the pool
-          @result_cursor&.pull_all_failure_async
+          @result_cursor&.pull_all_failure_async&.result!&.then(&method(:raise))
           if @connection&.open?
             # there somehow is an existing open connection, this should not happen, just a precondition
             raise Neo4j::Driver::Exceptions::IllegalStateException.new('Existing open connection detected')

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/rediscovery_impl.rb

@@ -48,8 +48,7 @@ module Neo4j::Driver
           resolved_addresses = @resolver.call(@initial_router).flat_map do |server_address|
             resolve_all_by_domain_name(server_address).unicast_stream
             # rescue java.net.UnknownHostException => e
-          rescue => e
-            exception&.add_suppressed(e)
+          rescue SocketError => e
             exception ||= e
             []
           end

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

@@ -16,9 +16,14 @@ 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)
+          begin
+            records = run_procedure(delegate, procedure, bookmark_holder)
+            RoutingProcedureResponse.new(procedure, records: records)
+          rescue => error
+            handle_error(procedure, error)
+          ensure
+            release_connection(delegate)
+          end
         end
 
         private
@@ -32,7 +37,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 +48,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)
@@ -55,18 +60,12 @@ module Neo4j::Driver
           connection.release
         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)
-        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,8 +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 }
-          nil
+          consume_async.error.then { |error| run_error ? nil : error }
         end
 
         def pull_all_failure_async
@@ -46,18 +49,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/async_result_cursor_only_factory.rb

@@ -18,10 +18,6 @@ module Neo4j::Driver
 
           DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
         end
-
-        def rx_result
-          Util::Futures.failed_future(Exceptions::ClientException.new('Driver is connected to the database that does not support driver reactive API. In order to use the driver reactive API, please upgrade to neo4j 4.0.0 or later.'))
-        end
       end
     end
   end

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/cursor/result_cursor_factory_impl.rb

@@ -18,11 +18,6 @@ module Neo4j::Driver
 
           DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
         end
-
-        def rx_result
-          @connection.write_and_flush(@run_message, @run_handler)
-          @run_future.handle { |_ignored, error| RxResultCursorImpl.new(error, @run_handler, @pull_handler) }
-        end
       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,52 +68,27 @@ module Neo4j::Driver
           while @records.empty? && !(@ignore_records || @finished)
             @records.wait
           end
-          @records.items.first
-
-          # if record.nil?
-          #   return Util::Futures.failed_future(extract_failure) unless @failure.nil?
-
-          #   return Util::Futures.completed_with_null if @ignore_records || @finished
-
-          #   @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
-
-          #   @record_future
-          # else
-          #   # java.util.concurrent.CompletableFuture.completed_future(record)
-          #   record
-          # end
+          @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
+            @failure ? Util::ResultHolder.failed(extract_failure) : Util::ResultHolder.successful(nil)
         end
 
         def next_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
-          else
-            raise Util::Futures.as_completion_exception, pull_all_failure_async
-          end
-
-          # pull_all_failure_async do |error|
-          #   unless error.nil?
-          #     raise Util::Futures.as_completion_exception, error
-          #   end
-
-          #   @summary
-          # end
+          pull_all_failure_async.result!&.then(&Util::ResultHolder.method(:failed)) or
+            Util::ResultHolder.successful(@summary)
         end
 
-        def list_async(map_function)
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
+        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_as_list(map_function)
+            @records.each { |record| yield record }
           end
         end
 
@@ -121,21 +97,17 @@ module Neo4j::Driver
         end
 
         def pull_all_failure_async
-          if !@failure.nil?
-            return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
+          if @failure
+            Util::ResultHolder.successful(extract_failure)
           elsif @finished
-            return nil
-            # return Util::Futures.completed_with_null
+            Util::ResultHolder.successful
           else
-            if @failure_future.nil?
+            (@failed_future ||= Util::ResultHolder.new).tap do |_|
               # neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives
               # future will be completed with null on SUCCESS and completed with Throwable on FAILURE
               # enable auto-read, otherwise we might not read SUCCESS/FAILURE if records are not consumed
               enable_auto_read
-              @failure_future = java.util.concurrent.CompletableFuture.new
             end
-
-            @failure_future
           end
         end
 
@@ -191,33 +163,20 @@ 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 fail_record_future(error)
-          unless @record_future.nil?
-            future = @record_future
-            @record_future = nil
-            future.complete_exceptionally(error)
-            return true
-          end
-
-          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
-
-          false
+          @failure_future&.fail(error)
+        ensure
+          @failure_future = nil
         end
 
         def extract_result_summary(metadata)