neo4j-ruby-driver 4.4.0.alpha.8 → 4.4.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d282964e01764e3a21d07c1e836567b3bc1f334e08d45b7392984db661faa14a
-  data.tar.gz: afc45978f3583f6f491c75c5f4f9da89099620d0be88c0367c8e9469554ecc20
+  metadata.gz: c795045f581183398e15ba5c44c1f89b10ea234a9a6dc1e46fecd8c02b857bb3
+  data.tar.gz: 1859daea7265d9409d001e748048ab97837fe26895d80fe4e24773b1b51ed49d
 SHA512:
-  metadata.gz: 0a40657edbf022793691d6926f93ae779d4b671878cdbd29538a0ff83bd82de1912210380715390219503a1fbfb3ada37ae70cce66e6184664b1a90fbff12f80
-  data.tar.gz: 4ae8f0cb141fc923df3fc8bfab0696adb979a40331e76a440096eb64b3d8060a2f70e49934ed6af06015f734cc1d4f85468b0118b3231db1df4369ff93c0fa63
+  metadata.gz: 5f72367997a92a64e8a75ef08bfca59d0acffaac7589e594b69d8fead9173dc3339d6b3dc26ad63ae1f2f0f7cde0a9f172908e9112b92b3496c209ef8c99e01d
+  data.tar.gz: 7bee1a6da116192d42ad2d9b86091d787211af683278c9cfe136f3c8ebf3d1d8c807834b44d5162a308b47b5208ee8e0b40302961a5dfb83c16a7180353d617e

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

@@ -1,14 +1,13 @@
 module Neo4j::Driver
   module Internal
     module Async
-      class NetworkConnection < ::Async::Pool::Resource
+      class NetworkConnection
         include Spi::Connection
         delegate :protocol, to: :@channel
 
         attr_reader :server_agent, :server_address, :server_version
 
         def initialize(channel, channel_pool, logger)
-          super()
           @log = logger
           @channel = channel
           @message_dispatcher = channel.attributes[:message_dispatcher]
@@ -23,11 +22,6 @@ module Neo4j::Driver
           @status = Concurrent::AtomicReference.new(Status::OPEN)
         end
 
-        # def close
-        #   super
-        #   @io.close
-        # end
-
         def open?
           @status.get == Status::OPEN
         end
@@ -79,11 +73,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 +89,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/pool/channel.rb

@@ -2,14 +2,13 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class Channel < ::Async::Pool::Resource
+        class Channel
           attr :stream
           attr_accessor :version, :protocol, :message_format, :message_dispatcher
           attr :attributes # should be attr
           attr_accessor :auto_read
 
           def initialize(address, connector, logger)
-            super()
             @attributes = Connection::ChannelAttributes.new
             @stream = Connection::Stream.new(connector.connect(address))
             @stream.write(Connection::BoltProtocolUtil.handshake_buf)
@@ -25,7 +24,6 @@ module Neo4j::Driver
           end
 
           def close
-            super unless closed? # Should this be conditional?
             @stream.close
           end
 

data/ruby/neo4j/driver/internal/async/pool/connection_pool_impl.rb

@@ -77,7 +77,7 @@ module Neo4j::Driver
           private
 
           def process_acquisition_error(pool, server_address, error)
-            if error.is_a?(::Async::TimeoutError)
+            if error.is_a?(ConnectionPool::TimeoutError)
               # NettyChannelPool returns future failed with TimeoutException if acquire operation takes more than
               # configured time, translate this exception to a prettier one and re-throw
               raise Neo4j::Driver::Exceptions::ClientException.new("Unable to acquire connection from the pool within configured maximum time of #{@settings.connection_acquisition_timeout.inspect}")
@@ -109,7 +109,7 @@ module Neo4j::Driver
           end
 
           def new_pool(address)
-            Controller.wrap(limit: @settings.max_connection_pool_size, acquisition_timeout: @settings.connection_acquisition_timeout) { Channel.new(address, @connector, @log) }
+            Controller.new(limit: @settings.max_connection_pool_size, acquisition_timeout: @settings.connection_acquisition_timeout) { Channel.new(address, @connector, @log) }
           end
 
           def get_or_create_pool(address)

data/ruby/neo4j/driver/internal/async/pool/controller.rb

@@ -2,21 +2,27 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class Controller < ::Async::Pool::Controller
-          def initialize(constructor, limit: nil, concurrency: nil, acquisition_timeout: nil)
-            super(constructor, limit: limit, concurrency: concurrency)
-            @acquisition_timeout = acquisition_timeout
+        class Controller < ConnectionPool
+          def initialize(limit: nil, acquisition_timeout: nil, &block)
+            super(size: limit, timeout: acquisition_timeout, &block)
+            @available = TimedStack.new(@size, &block)
           end
 
-          def wait_for_resource
-            case @acquisition_timeout
-            when nil
-              super
-            when 0
-              available_resource or raise ::Async::TimeoutError
-            else
-              ::Async::Task.current.with_timeout(@acquisition_timeout) { super }
-            end
+          def acquire(options = {})
+            @available.pop(options[:timeout] || @timeout)
+          end
+
+          def release(resource)
+            @available.push(resource)
+            nil
+          end
+
+          def close
+            @available.shutdown(&:close)
+          end
+
+          def busy?
+            @available.any_resource_busy?
           end
         end
       end

data/ruby/neo4j/driver/internal/async/pool/timed_stack.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Pool
+        class TimedStack < ConnectionPool::TimedStack
+          def any_resource_busy?
+            @mutex.synchronize do
+              @created > @que.length
+            end
+          end
+        end
+      end
+    end
+  end
+end

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)
-          run_procedure(delegate, procedure, bookmark_holder)
-            .side { release_connection(delegate) }
-            .chain { |records, error| 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
@@ -55,10 +60,6 @@ module Neo4j::Driver
           connection.release
         end
 
-        def process_procedure_response(procedure, records, error)
-          error ? handle_error(procedure, error) : RoutingProcedureResponse.new(procedure, records: records)
-        end
-
         def handle_error(procedure, error)
           if error.is_a? Exceptions::ClientException
             RoutingProcedureResponse.new(procedure, error: error)

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

@@ -41,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 { |_summary, error| run_error ? nil : error }
-          nil
+          consume_async.error.then { |error| run_error ? nil : error }
         end
 
         def pull_all_failure_async

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

@@ -68,65 +68,21 @@ module Neo4j::Driver
           while @records.empty? && !(@ignore_records || @finished)
             @records.wait
           end
-          record = @records.items.first
-
-          Util::ResultHolder.successful(record)
-
-          # 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.then(&Util::ResultHolder.method(:successful))
-          #   Util::ResultHolder.successful(@summary)
-          # else
-          #   raise pull_all_failure_async
-          # end
-
-          if @failure
-            Util::ResultHolder.failed(extract_failure)
-          else
+          pull_all_failure_async.result!&.then(&Util::ResultHolder.method(:failed)) or
             Util::ResultHolder.successful(@summary)
-          end
-
-          # pull_all_failure_async do |error|
-          #   unless error.nil?
-          #     raise Util::Futures.as_completion_exception, error
-          #   end
-
-          #   @summary
-          # 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
-
-        #     records_as_list(map_function)
-        #   end
-        # end
-
         def each
           pull_all_failure_async.then do
             unless @finished
@@ -141,22 +97,17 @@ module Neo4j::Driver
         end
 
         def pull_all_failure_async
-          if !@failure.nil?
-            return Util::ResultHolder.failed(extract_failure)
-            # 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
 
@@ -212,38 +163,17 @@ 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
+          @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

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

@@ -100,8 +100,9 @@ module Neo4j::Driver
 
           def pull_all_async
             return completed_with_value_if_no_failure(@summary) if done?
-            request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-            @summary_future ||= Util::ResultHolder.new
+            (@summary_future ||= Util::ResultHolder.new).tap do |_|
+              request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
+            end
           end
 
           def enqueue_record(record)

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

@@ -99,7 +99,7 @@ module Neo4j::Driver
           end
 
           def done?
-            @state == State::SUCEEDED_STATE || @state == State::FAILURE_STATE
+            @state == State::SUCCEEDED_STATE || @state == State::FAILURE_STATE
           end
 
           private def extract_result_summary(**metadata)
@@ -147,7 +147,7 @@ module Neo4j::Driver
           end
 
           module State
-            READY_STATE = Class.new do
+            class Ready
               def on_success(context, metadata)
                 context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
@@ -171,15 +171,17 @@ module Neo4j::Driver
                 context.state = CANCELLED_STATE
                 context.discard_all
               end
-            end.new
+            end
+
+            READY_STATE = Ready.new
 
-            STREAMING_STATE = Class.new do
+            class Streaming
               def on_success(context, metadata)
                 if metadata[:has_more]
                   context.state = READY_STATE
                   context.success_has_more
                 else
-                  context.state = SUCEEDED_STATE
+                  context.state = SUCCEEDED_STATE
                   context.complete_with_success(metadata)
                 end
               end
@@ -202,15 +204,17 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = CANCELLED_STATE
               end
-            end.new
+            end
+
+            STREAMING_STATE = Streaming.new
 
-            CANCELLED_STATE = Class.new do
+            class Cancelled
               def on_success(context, metadata)
                 if metadata[:has_more]
                   context.state = CANCELLED_STATE
                   context.discard_all
                 else
-                  context.state = SUCEEDED_STATE
+                  context.state = SUCCEEDED_STATE
                   context.complete_with_success(metadata)
                 end
               end
@@ -231,11 +235,13 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = CANCELLED_STATE
               end
-            end.new
+            end
+
+            CANCELLED_STATE = Cancelled.new
 
-            SUCEEDED_STATE = Class.new do
+            class Succeeded
               def on_success(context, metadata)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
               end
 
@@ -245,21 +251,23 @@ module Neo4j::Driver
               end
 
               def on_record(context, _fields)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
 
               def request(context, _n)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
 
               def cancel(context)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
-            end.new
+            end
+
+            SUCCEEDED_STATE = Succeeded.new
 
-            FAILURE_STATE = Class.new do
+            class Failed
               def on_success(context, metadata)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
               end
 
@@ -279,7 +287,9 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = FAILURE_STATE
               end
-            end.new
+            end
+
+            FAILURE_STATE = Failed.new
           end
         end
       end

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

@@ -21,10 +21,6 @@ module Neo4j::Driver
         InternalSession.new(new_session(**session_config))
       end
 
-      def rx_session(**session_config)
-        InternalRxSession.new(new_session(**session_config))
-      end
-
       def async_session(**session_config)
         InternalAsyncSession.new(new_session(**session_config))
       end

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

@@ -4,20 +4,13 @@ module Neo4j::Driver
       extend Synchronizable
       include Enumerable
       sync :keys, :has_next?, :next, :single, :peek, :consume
+      delegate :keys, to: :@cursor
 
       def initialize(connection, cursor)
         @connection = connection
         @cursor = cursor
       end
 
-      def keys
-        @keys ||=
-          begin
-            @cursor.peek_async
-            @cursor.keys
-          end
-      end
-
       def has_next?
         @cursor.peek_async.result!
       end
@@ -48,10 +41,6 @@ module Neo4j::Driver
 
       private
 
-      def blocking_get(stage)
-        Util::Futures.blocking_get(stage, &method(:terminate_connection_on_thread_interrupt))
-      end
-
       def terminate_connection_on_thread_interrupt
         @connection.terminate_and_release('Thread interrupted while waiting for result to arrive')
       end

data/ruby/neo4j/driver/internal/messaging/abstract_message_writer.rb

@@ -4,7 +4,7 @@ module Neo4j::Driver
       class AbstractMessageWriter
         def initialize(packer)
           @packer = Internal::Validator.require_non_nil!(packer)
-          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders)
+          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders).transform_values(&:new)
         end
 
         def write(msg)

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

@@ -3,22 +3,22 @@ module Neo4j::Driver
     module Messaging
       module V3
         class MessageWriterV3 < AbstractMessageWriter
+          COMMON_ENCODERS = {
+            Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder,
+            Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder,
+            Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder,
+            Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder,
+            Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder,
+            Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder,
+            Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder,
+          }
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder.new,
-              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder.new,
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            COMMON_ENCODERS.merge(
+              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder,
+              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder,
+            )
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v4/message_writer_v4.rb

@@ -2,24 +2,13 @@ module Neo4j::Driver
   module Internal
     module Messaging
       module V4
-        class MessageWriterV4 < AbstractMessageWriter
+        class MessageWriterV4 < V3::MessageWriterV3
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-
-              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder.new, # new
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new, # new
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            COMMON_ENCODERS.merge(
+              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder,
+              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v43/message_writer_v43.rb

@@ -7,25 +7,11 @@ module Neo4j::Driver
         # This version is able to encode all the versions existing on v4.2, but it encodes
 
         # new messages such as ROUTE
-        class MessageWriterV43 < AbstractMessageWriter
+        class MessageWriterV43 < V4::MessageWriterV4
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder.new, # new
-
-              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v44/message_writer_v44.rb

@@ -2,22 +2,11 @@ module Neo4j::Driver
   module Internal
     module Messaging
       module V44
-        class MessageWriterV44 < AbstractMessageWriter
+        class MessageWriterV44 < V4::MessageWriterV4
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder.new,
-              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder)
           end
         end
       end

data/ruby/neo4j/driver/internal/retry/exponential_backoff_retry_logic.rb

@@ -143,7 +143,7 @@ module Neo4j::Driver
         end
 
         def add_suppressed(error, suppressed_errors)
-          suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed))
+          suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed)) if error.is_a? Exceptions::Neo4jException
         end
       end
     end

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

@@ -2,8 +2,6 @@ module Neo4j::Driver
   module Internal
     module Util
       class MetadataExtractor
-        ABSENT_QUERY_ID = -1
-
         def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key)
           @result_available_after_metadata_key = result_available_after_metadata_key
           @result_consumed_after_metadata_key = result_consumed_after_metadata_key
@@ -14,7 +12,7 @@ module Neo4j::Driver
         end
 
         def extract_query_id(metadata)
-          metadata[:qid] || ABSENT_QUERY_ID
+          metadata[:qid]
         end
 
         def extract_result_available_after(metadata)

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

@@ -2,6 +2,8 @@ module Neo4j::Driver
   module Internal
     module Util
       class ResultHolder
+        attr :error
+
         def self.successful(result = nil)
           new.tap { |holder| holder.succeed(result) }
         end

data/ruby/neo4j/driver/version.rb

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

data/ruby/neo4j/driver.rb

@@ -5,9 +5,8 @@ require 'active_support/core_ext/hash/keys'
 require 'active_support/logger'
 require 'async/io'
 require 'async/io/stream'
-require 'async/pool'
-require 'async/pool/resource'
 require 'async/queue'
+require 'connection_pool'
 require 'bigdecimal'
 require 'date'
 require 'loader'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 4.4.0.alpha.8
+  version: 4.4.0.beta.1
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-19 00:00:00.000000000 Z
+date: 2022-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: async-pool
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -294,6 +294,7 @@ files:
 - ruby/neo4j/driver/internal/async/pool/netty_channel_pool.rb
 - ruby/neo4j/driver/internal/async/pool/network_connection_factory.rb
 - ruby/neo4j/driver/internal/async/pool/pool_settings.rb
+- ruby/neo4j/driver/internal/async/pool/timed_stack.rb
 - ruby/neo4j/driver/internal/async/result_cursors_holder.rb
 - ruby/neo4j/driver/internal/async/unmanaged_transaction.rb
 - ruby/neo4j/driver/internal/bookmark_holder.rb
@@ -473,7 +474,6 @@ files:
 - ruby/neo4j/driver/net/server_address.rb
 - ruby/neo4j/driver/query.rb
 - ruby/neo4j/driver/records.rb
-- ruby/neo4j/driver/session_config.rb
 - ruby/neo4j/driver/transaction_config.rb
 - ruby/neo4j/driver/values.rb
 - ruby/neo4j/driver/version.rb

data/ruby/neo4j/driver/session_config.rb

@@ -1,15 +0,0 @@
-module Neo4j
-  module Driver
-    # The session configurations used to configure a session.
-    class SessionConfig < Hash
-      attr_reader :bookmarks, :default_access_mode, :database, :fetch_size, :impersonated_user
-      def initialize(**config)
-        @bookmarks = config.bookmarks
-        @default_access_mode = config.default_access_mode
-        @database = config.database
-        @fetch_size = config.fetch_size
-        @impersonated_user = config.impersonated_user
-      end
-    end
-  end
-end