neo4j-ruby-driver 5.7.0.alpha.6 → 6.0.0.alpha.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8155401c9cf866b2f2595fdd1334c35c0d09b3160f9b7c9e1c94aef334ad66e5
-  data.tar.gz: 1e4ba8da99822dfb02dbc6f2088c478e1868592b387d9b6acef954f6973a6cd8
+  metadata.gz: 2cb3ba5c3c1dda74bf82e77866ac67ad834c3cc0fbe34c60c6f94d15040f56f2
+  data.tar.gz: 50a8a7f3c771de94889c3edfc28e2c0d3f26fc80c39bae330d81b5d34aedf4ae
 SHA512:
-  metadata.gz: 814db07fdb74c015051783ea1a91db4db2db5a3c715f0a8ce27d83ba726e58af930af4f8470ef67afeb40392499cfdda0b3230a14cecbb3d2f4fbe2dbd1db496
-  data.tar.gz: df14e459b0e08839b105e95f7ca3a4ed7a08c021bd95cfa7ada04aae8c5e7b01383014f808b0c11d0d90e35eba6973adfb612273b32e1ecfbf1c88fb19d54528
+  metadata.gz: f2011130ffcc499091ded7d02ff85484ec8f170a4d7adca828bf7d125eaa9d4b3b1ec0d1c93b53b0d1379ac8b378bb5c77ef7f869e0d1ffe4a2fca4442672a1b
+  data.tar.gz: bae2f8340186a2f0ad94da8e24c193dfdea98bee1a814ea78df481b35e9f4e4ea93c1827b662a46a9a742eaf94d82b8e09b9721754aad2a26dfb77196429ce5d

data/lib/neo4j/driver/exceptions/neo4j_exception.rb

@@ -7,14 +7,14 @@ module Neo4j
         attr_reader :code, :suppressed
 
         def initialize(*args)
-          args, exceptions = args.partition { |arg| arg.is_a?(String) }
-          super(args.pop)
-          @code = args.pop
-          add_suppressed(*exceptions)
+          @code = args.shift if args.count > 1
+          message = args.shift
+          @suppressed = args.shift
+          super(message)
         end
 
-        def add_suppressed(*exceptions)
-          (@suppressed ||= []).concat(exceptions) if exceptions.any?
+        def add_suppressed(exception)
+          (@suppressed ||= []) << exception
         end
       end
     end

data/ruby/neo4j/driver/bookmark.rb

@@ -13,8 +13,8 @@ module Neo4j
       # Reconstruct bookmark from \bookmarks string values.
       # @param values values obtained from a previous bookmark.
       # @return A bookmark.
-      def self.from(*values)
-        Internal::InternalBookmark.parse(*values)
+      def self.from(value)
+        Internal::InternalBookmark.new(value)
       end
     end
   end

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

@@ -2,16 +2,16 @@ module Neo4j::Driver
   module Internal
     module Async
       class ImmutableConnectionContext
-        attr :database_name, :mode, :rediscovery_bookmark, :impersonated_user
+        attr :database_name, :mode, :rediscovery_bookmarks, :impersonated_user
 
-        def initialize(database_name, bookmark, mode)
+        def initialize(database_name, bookmarks, mode)
           @database_name = database_name
-          @rediscovery_bookmark = bookmark
+          @rediscovery_bookmarks = bookmarks
           @mode = mode
         end
 
-        SINGLE_DB_CONTEXT = new(DatabaseNameUtil::DEFAULT_DATABASE, InternalBookmark::EMPTY, AccessMode::READ)
-        MULTI_DB_CONTEXT = new(DatabaseNameUtil::SYSTEM_DATABASE, InternalBookmark::EMPTY, AccessMode::READ)
+        SINGLE_DB_CONTEXT = new(DatabaseNameUtil::DEFAULT_DATABASE, [], AccessMode::READ)
+        MULTI_DB_CONTEXT = new(DatabaseNameUtil::SYSTEM_DATABASE, [], AccessMode::READ)
 
         # A simple context is used to test connectivity with a remote server/cluster. As long as there is a read only service, the connection shall be established
         # successfully. Depending on whether multidb is supported or not, this method returns different context for routing table discovery.

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

@@ -6,7 +6,7 @@ module Neo4j::Driver
           @session = session
         end
 
-        delegate :last_bookmark, :close_async, to: :@session
+        delegate :last_bookmarks, :close_async, to: :@session
 
         def run_async(query, parameters = {}, config = {})
           @session.run_async(org.neo4j.driver.Query.new(query, **parameters), **config)
@@ -32,8 +32,10 @@ module Neo4j::Driver
             tx_future = @session.begin_transaction_async(mode, ** config)
 
             tx_future.when_complete do |tx, completion_error|
-              if completion_error
-                result_future.complete_exceptionally(completion_error)
+              error = Util::Futures.completion_exception_cause(completion_error)
+
+              if !error.nil?
+                result_future.complete_exceptionally(error)
               else
                 execute_work(result_future, tx, &work)
               end
@@ -46,8 +48,10 @@ module Neo4j::Driver
           work_future = safe_execute_work(tx, &work)
 
           work_future.when_complete do |result, completion_error|
-            if completion_error
-              close_tx_after_failed_transaction_work(tx, result_future, completion_error)
+            error = Util::Futures.completion_exception_cause(completion_error)
+
+            if !error.nil?
+              close_tx_after_failed_transaction_work(tx, result_future, error)
             else
               close_tx_after_succeeded_transaction_work(tx, result_future, result)
             end
@@ -79,8 +83,10 @@ module Neo4j::Driver
 
         def close_tx_after_succeeded_transaction_work(tx, result_future, result)
           tx.close_async(true).when_complete do |_ignored, completion_error|
-            if completion_error
-              result_future.complete_exceptionally(completion_error)
+            commit_error = Util::Futures.completion_exception_cause(completion_error)
+
+            if !commit_error.nil?
+              result_future.complete_exceptionally(commit_error)
             else
               result_future.complete(result)
             end

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

@@ -11,7 +11,7 @@ module Neo4j::Driver
           @log = Logging::PrefixedLogger.new("[#{hash}]", logger)
           @bookmark_holder = bookmark_holder
           # @database_name = database_name.database_name
-          @connection_context = NetworkSessionConnectionContext.new(database_name, @bookmark_holder.bookmark, impersonated_user)
+          @connection_context = NetworkSessionConnectionContext.new(database_name, @bookmark_holder.bookmarks, impersonated_user)
           @fetch_size = fetch_size
           @open = Concurrent::AtomicBoolean.new(true)
         end
@@ -28,7 +28,7 @@ module Neo4j::Driver
           acquire_connection(mode).then do |connection|
             ImpersonationUtil.ensure_impersonation_support(connection, connection.impersonated_user)
             tx = UnmanagedTransaction.new(connection, @bookmark_holder, @fetch_size)
-            tx.begin_async(@bookmark_holder.bookmark, config)
+            tx.begin_async(@bookmark_holder.bookmarks, config)
           end&.tap { |new_transaction| @transaction = new_transaction }
         end
 
@@ -42,8 +42,8 @@ module Neo4j::Driver
           end
         end
 
-        def last_bookmark
-          @bookmark_holder.bookmark
+        def last_bookmarks
+          @bookmark_holder.bookmarks
         end
 
         def release_connection_async
@@ -131,11 +131,11 @@ module Neo4j::Driver
           # It has to be the initial bookmark given at the creation of the session.
           # As only that bookmark could carry extra system bookmarks
           attr_accessor :database_name
-          attr :mode, :rediscovery_bookmark, :impersonated_user
+          attr :mode, :rediscovery_bookmarks, :impersonated_user
 
-          def initialize(database_name, bookmark, impersonated_user)
+          def initialize(database_name, bookmarks, impersonated_user)
             @database_name = database_name
-            @rediscovery_bookmark = bookmark
+            @rediscovery_bookmarks = bookmarks
             @impersonated_user = impersonated_user
           end
 

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

@@ -35,8 +35,8 @@ module Neo4j::Driver
           @state = State::ACTIVE
         end
 
-        def begin_async(initial_bookmark, config)
-          @protocol.begin_transaction(@connection, initial_bookmark, config)
+        def begin_async(initial_bookmarks, config)
+          @protocol.begin_transaction(@connection, initial_bookmarks, config)
           self
         rescue Neo4j::Driver::Exceptions::AuthorizationExpiredException
           @connection.terminate_and_release(Neo4j::Driver::Exceptions::AuthorizationExpiredException::DESCRIPTION)
@@ -175,7 +175,7 @@ module Neo4j::Driver
           if exception
             Util::ResultHolder.failed(exception)
           else
-            @protocol.commit_transaction(@connection).then(&@bookmark_holder.method(:bookmark=))
+            @protocol.commit_transaction(@connection).then { @bookmark_holder.bookmarks = Set[it] }
           end
         end
 

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

@@ -33,7 +33,7 @@ module Neo4j::Driver
               @log.debug("Routing table for database '#{@database_name.description}' is stale. #{@routing_table}")
 
               fresh_cluster_composition_fetched(
-                @rediscovery.lookup_cluster_composition(@routing_table, @connection_pool, context.rediscovery_bookmark,
+                @rediscovery.lookup_cluster_composition(@routing_table, @connection_pool, context.rediscovery_bookmarks,
                                                         nil))
             else
               # existing routing table is fresh, use it

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

@@ -1,8 +1,8 @@
 module Neo4j::Driver
   module Internal
     class DefaultBookmarkHolder < ReadOnlyBookmarkHolder
-      def bookmark=(bookmark)
-        @bookmark = bookmark if bookmark.present?
+      def bookmarks=(bookmarks)
+        @bookmarks = bookmarks
       end
     end
   end

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

@@ -8,9 +8,7 @@ module Neo4j::Driver
           @result_holder = result_holder
         end
 
-        def on_success(metadata)
-          @result_holder.succeed(metadata[:bookmark]&.then(&InternalBookmark.method(:parse)))
-        end
+        def on_success(metadata) = @result_holder.succeed(Util::MetadataExtractor.extract_bookmark(metadata))
 
         def on_failure(error)
           @result_holder.fail(error)

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

@@ -19,12 +19,13 @@ module Neo4j::Driver
 
         private
 
-        def handled_error(error)
+        def handled_error(received_error)
+          # TODO: probably not necessary with concurrent-ruby as it might not wrap exceptions like java
+          error = Futures.completion_exception_cause(received_error)
+
           case error
           when Exceptions::ServiceUnavailableException
             handled_service_unavailable_exception(error)
-          when Exceptions::ProtocolException
-            handled_protocol_exception(error)
           when Exceptions::ClientException
             handled_client_exception(error)
           when Exceptions::TransientException
@@ -35,22 +36,12 @@ module Neo4j::Driver
         end
 
         def handled_service_unavailable_exception(e)
-          record_connection_failure
-          Exceptions::SessionExpiredException.new("Server at #{@address} is no longer available", e)
+          @error_handler.on_connection_failure(@address)
+          Exceptions::SessionExpiredException("Server at #{@address} is no longer available", e)
         end
 
         def handled_transient_exception(e)
-          record_connection_failure if e.code == "Neo.TransientError.General.DatabaseUnavailable"
-          e
-        end
-
-        def handled_protocol_exception(e)
-          record_connection_failure
-          e
-        end
-
-        def record_connection_failure
-          @error_handler.on_connection_failure(@address)
+          e.code == "Neo.TransientError.General.DatabaseUnavailable" ? error_handler.on_connection_failure(@address) : e
         end
 
         def handled_client_exception(e)

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

@@ -9,7 +9,7 @@ module Neo4j::Driver
 
         def after_success(metadata)
           release_connection
-          @bookmark_holder.bookmark = Util::MetadataExtractor.extract_bookmarks(metadata)
+          @bookmark_holder.bookmarks = Array(Util::MetadataExtractor.extract_bookmark(metadata)).to_set
         end
 
         def after_failure(error)

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

@@ -1,36 +1,9 @@
 module Neo4j::Driver
   module Internal
-    class InternalBookmark
+    class InternalBookmark < String
       include Bookmark
-      attr :values
-      delegate :hash, :empty?, to: :values
 
-      private def initialize(*values)
-        @values = values.to_set
-      end
-      EMPTY = new.freeze
-
-      def ==(other)
-        equal?(other) || self.class == other.class && values == other.values
-      end
-
-      alias eql? ==
-
-      def to_s
-        "Bookmark{values=#{values}}"
-      end
-
-      class << self
-        def empty
-          EMPTY
-        end
-
-        def from(*bookmarks)
-          new(*bookmarks.reduce(Set.new) { |set, bookmark| set + bookmark.values })
-        end
-
-        alias parse new
-      end
+      def to_s = "Bookmark{value=#{super}}"
     end
   end
 end

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

@@ -4,7 +4,7 @@ module Neo4j::Driver
       extend AutoCloseable
       extend Synchronizable
       # include Ext::RunOverride
-      delegate :open?, :last_bookmark, to: :@session
+      delegate :open?, :last_bookmarks, to: :@session
       auto_closeable :begin_transaction
       sync :close, :begin_transaction, :run, :transaction
 

data/ruby/neo4j/driver/internal/messaging/encode/route_message_encoder.rb

@@ -8,7 +8,7 @@ module Neo4j::Driver
             Util::Preconditions.check_argument(message, Request::RouteMessage)
             packer.pack_struct_header(3, message.signature)
             packer.pack(message.routing_context)
-            packer.pack(message.bookmark&.values || [])
+            packer.pack(message.bookmark || [])
             packer.pack(option(message))
           end
 

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

@@ -5,10 +5,10 @@ module Neo4j::Driver
         class BeginMessage < MessageWithMetadata
           SIGNATURE = 0x11
 
-          def initialize(bookmark, config, database_name, mode, impersonated_user)
+          def initialize(bookmarks, config, database_name, mode, impersonated_user)
             super(Request::TransactionMetadataBuilder.build_metadata(
               timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
-              bookmark: bookmark, impersonated_user: impersonated_user))
+              bookmarks: bookmarks, impersonated_user: impersonated_user))
           end
 
           def signature

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

@@ -7,10 +7,10 @@ module Neo4j::Driver
           attr_reader :query, :parameters
 
           class << self
-            def auto_commit_tx_run_message(query, config, database_name, mode, bookmark, impersonated_user)
+            def auto_commit_tx_run_message(query, config, database_name, mode, bookmarks, impersonated_user)
               metadata = Request::TransactionMetadataBuilder.build_metadata(
                 timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
-                bookmark: bookmark, impersonated_user: impersonated_user)
+                bookmarks: bookmarks, impersonated_user: impersonated_user)
               new(query.text, query.parameters, metadata)
             end
 

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

@@ -6,9 +6,9 @@ module Neo4j::Driver
           MODE_READ_VALUE = 'r'
 
           class << self
-            def build_metadata(timeout:, tx_metadata:, mode:, bookmark:, impersonated_user:,
+            def build_metadata(timeout:, tx_metadata:, mode:, bookmarks:, impersonated_user:,
                                database_name: DatabaseNameUtil.default_database)
-              { bookmarks: bookmark.presence,
+              { bookmarks: bookmarks.presence,
                 tx_timeout: timeout&.then(&DurationNormalizer.method(:milliseconds)),
                 tx_metadata: tx_metadata.presence,
                 mode: (MODE_READ_VALUE if mode == AccessMode::READ),

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

@@ -30,9 +30,9 @@ module Neo4j::Driver
             message_dispatcher.prepare_to_close_channel
           end
 
-          def begin_transaction(connection, bookmark, config)
+          def begin_transaction(connection, bookmarks, config)
             verify_database_name_before_transaction(connection.database_name)
-            begin_message = Request::BeginMessage.new(bookmark, config, connection.database_name, connection.mode, connection.impersonated_user)
+            begin_message = Request::BeginMessage.new(bookmarks, config, connection.database_name, connection.mode, connection.impersonated_user)
             connection.write_and_flush(begin_message, Handlers::BeginTxResponseHandler.new)
           end
 
@@ -51,7 +51,7 @@ module Neo4j::Driver
           def run_in_auto_commit_transaction(connection, query, bookmark_holder, config, fetch_size)
             verify_database_name_before_transaction(connection.database_name)
 
-            run_message = Request::RunWithMetadataMessage.auto_commit_tx_run_message(query, config, connection.database_name, connection.mode, bookmark_holder.bookmark, connection.impersonated_user)
+            run_message = Request::RunWithMetadataMessage.auto_commit_tx_run_message(query, config, connection.database_name, connection.mode, bookmark_holder.bookmarks, connection.impersonated_user)
 
             build_result_cursor_factory(connection, query, bookmark_holder, nil, run_message, fetch_size)
           end

data/ruby/neo4j/driver/internal/packstream/pack_stream.rb

@@ -114,8 +114,6 @@ module Neo4j::Driver
               value = value.to_a
               pack_list_header(value.size)
               value.each(&method(:pack))
-            when Bookmark
-              pack(value.values)
             else
               unpackable(value)
             end

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

@@ -1,13 +1,13 @@
 module Neo4j::Driver
   module Internal
     class ReadOnlyBookmarkHolder
-      attr_reader :bookmark
+      attr_reader :bookmarks
 
-      def initialize(bookmark = InternalBookmark.empty)
-        @bookmark = bookmark
+      def initialize(bookmarks = Set[])
+        @bookmarks = bookmarks
       end
 
-      def bookmark=(_value) end
+      def bookmarks=(_value) end
     end
   end
 end

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

@@ -92,9 +92,10 @@ module Neo4j::Driver
           end
 
           work_stage.on_resolution do |fulfilled, result, completion_error|
-            if completion_error
+            error = Futures.completion_exception_cause(completion_error)
+            if error
               # work failed in async way, attempt to schedule a retry
-              retry_on_error(result_future, work, start_time, retry_delay, completion_error, errors)
+              retry_on_error(result_future, work, start_time, retry_delay, error, errors)
             else
               result_future.fulfill(result)
             end

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

@@ -13,7 +13,7 @@ module Neo4j::Driver
       end
 
       def new_instance(fetch_size: @default_fetch_size, default_access_mode: AccessMode::WRITE, **config)
-        bookmark_holder = DefaultBookmarkHolder.new(InternalBookmark.from(*config[:bookmarks]))
+        bookmark_holder = DefaultBookmarkHolder.new(Array(config[:bookmarks]).to_set)
         create_session(parse_database_name(config), default_access_mode, bookmark_holder, fetch_size, config[:impersonated_user])
       end
 

data/ruby/neo4j/driver/internal/summary/internal_notification.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Neo4j::Driver::Internal::Summary
-  class InternalNotification < Struct.new(:code, :title, :description, :severity, :position)
+  class InternalNotification < Struct.new(:code, :title, :description, :severity_level, :position)
 
     VALUE_TO_NOTIFICATION = lambda do |value|
-      severity = value[:severity] || 'N/A'
+      severity = value[:severity]
 
       position = value[:position]&.then do |pos_value|
         InternalInputPosition.new(*pos_value.values_at(:offset, :line, :column).map(&:to_i))

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

@@ -35,13 +35,7 @@ module Neo4j::Driver
               Summary::InternalDatabaseInfo::DEFAULT_DATABASE_INFO
           end
 
-          def extract_bookmarks(metadata)
-            bookmark_value = metadata[:bookmark]
-
-            return InternalBookmark.parse(bookmark_value) if bookmark_value&.is_a? String
-
-            InternalBookmark.empty
-          end
+          def extract_bookmark(metadata) = metadata[:bookmark]&.then(&InternalBookmark.method(:new))
 
           def extract_neo4j_server_version(metadata)
             server_value = extract_server(metadata)

data/ruby/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '5.7.0.alpha.6'
+    VERSION = '6.0.0.alpha.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 5.7.0.alpha.6
+  version: 6.0.0.alpha.0
 platform: ruby
 authors:
 - Heinrich Klobuczek
@@ -89,16 +89,16 @@ dependencies:
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ffaker
   requirement: !ruby/object:Gem::Requirement
@@ -203,24 +203,21 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '4.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '4.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
-description: |2
-
-
-  ==== To Install:
+        version: '7'
+description: ''
 email:
 - heinrich@mail.com
 executables: []
@@ -536,7 +533,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
-summary: "==== To Install:"
+summary: ''
 test_files: []