neo4j-ruby-driver 6.0.3.alpha.0-java → 6.2.1.beta.2-java

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

@@ -4,17 +4,26 @@ module Neo4j
   module Driver
     module Exceptions
       class Neo4jException < RuntimeError
-        attr_reader :code, :suppressed
+        attr_reader :code, :suppressed, :gql_status, :status_description,
+                    :classification, :raw_classification, :diagnostic_record, :gql_cause
 
-        def initialize(*args)
-          args, exceptions = args.partition { |arg| arg.is_a?(String) }
-          super(args.pop)
-          @code = args.pop
-          add_suppressed(*exceptions)
+        def initialize(message = nil, code: nil, suppressed: nil,
+                       gql_status: nil, status_description: nil,
+                       classification: nil, raw_classification: nil,
+                       diagnostic_record: nil, gql_cause: nil)
+          super(message)
+          @code = code
+          @suppressed = Array(suppressed)
+          @gql_status = gql_status
+          @status_description = status_description
+          @classification = classification
+          @raw_classification = raw_classification
+          @diagnostic_record = diagnostic_record
+          @gql_cause = gql_cause
         end
 
         def add_suppressed(*exceptions)
-          (@suppressed ||= []).concat(exceptions) if exceptions.any?
+          @suppressed.concat(exceptions)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Neo4j
       class NoSuchRecordException < RuntimeError
         EMPTY = 'Cannot retrieve a single record, because this result is empty.'
         TOO_MANY = 'Expected a result with a single record, but this result ' \
-          'contains at least one more. Ensure your query returns only one record.'
+                   'contains at least one more. Ensure your query returns only one record.'
         NO_MORE = 'No more records'
         NO_PEEK_PAST = 'Cannot peek past the last record'
 

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

@@ -6,11 +6,6 @@ module Neo4j
       # A signal that the contract for client-server communication has broken down.
       # The user should contact support and cannot resolve this his or herself.
       class ProtocolException < Neo4jException
-        CODE = "Protocol violation: "
-
-        def initialize(message, e = nil)
-          super(nil, "#{CODE}#{message}", e)
-        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A security exception the driver considers retryable: the auth-token
+      # manager handled the underlying security failure (e.g. an expired
+      # token), so a managed transaction may retry with a fresh token.
+      # Mirrors org.neo4j.driver.exceptions.SecurityRetryableException.
+      class SecurityRetryableException < SecurityException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # The transaction has been terminated, so the work it was running
+      # cannot continue. Mirrors
+      # org.neo4j.driver.exceptions.TransactionTerminatedException.
+      class TransactionTerminatedException < ClientException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/auth_token.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      # Adds a Ruby-friendly `to_h` to Java's `AuthToken`. The MRI
+      # driver's `AuthTokens.basic` etc. already return Hashes (so
+      # `.to_h` is the Hash identity); this mirror lets impl-agnostic
+      # callers — e.g. testkit-backend's `serialize_auth_token` —
+      # consume an AuthToken without poking at Java's `toMap` /
+      # `Value#asString`.
+      module AuthToken
+        def to_h = to_map.as_ruby_object
+      end
+    end
+  end
+end

data/{jruby → lib}/neo4j/driver/ext/auth_tokens.rb

@@ -11,7 +11,11 @@ module Neo4j
           super
         end
 
-        def custom(principal, credentials, realm, scheme, **parameters)
+        # `parameters` is a positional Hash (matching Java's Map arg and
+        # the MRI flavour), so the same call works on both impls — a
+        # `**`-kwargs signature here would reject the positional-hash
+        # calls every caller uses (testkit AuthorizationToken, specs).
+        def custom(principal, credentials, realm, scheme, parameters = {})
           super(principal, credentials, realm, scheme, to_neo(parameters))
         end
       end

data/lib/neo4j/driver/ext/bookmark_managers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      # Mirrors Java's `BookmarkManagers.defaultManager(BookmarkManagerConfig)`
+      # factory (cf. Ext::AuthTokens / Ext::GraphDatabase), but with a Ruby
+      # keyword-arg surface instead of a config builder. The supplier/consumer
+      # callbacks are plain Procs — JRuby coerces them to the Java
+      # Supplier<Set<Bookmark>> / Consumer<Set<Bookmark>> functional interfaces.
+      module BookmarkManagers
+        include ConfigConverter
+
+        def default_manager(initial_bookmarks: nil, bookmarks_supplier: nil, bookmarks_consumer: nil)
+          super(to_java_config(Neo4j::Driver::BookmarkManagerConfig, initial_bookmarks:, bookmarks_supplier:,
+                                                                     bookmarks_consumer:))
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/client_certificates.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      # Ruby-friendly surface over org.neo4j.driver.ClientCertificates,
+      # prepended onto its singleton class (cf. Ext::GraphDatabase /
+      # Ext::BookmarkManagers) rather than shadowing the Java class. Lets the
+      # flavour-agnostic testkit backend call
+      # ClientCertificates.of(certpath, keypath[, password]) with path strings;
+      # the Java factory takes java.io.File, so wrap and delegate via super.
+      module ClientCertificates
+        def of(certfile, keyfile, password = nil)
+          cert = java.io.File.new(certfile.to_s)
+          key = java.io.File.new(keyfile.to_s)
+          password ? super(cert, key, password) : super(cert, key)
+        end
+      end
+    end
+  end
+end

data/{jruby → lib}/neo4j/driver/ext/config_converter.rb

@@ -5,6 +5,7 @@ module Neo4j
     module Ext
       module ConfigConverter
         include NeoConverter
+        include Driver::Internal::DurationNormalizer
 
         private
 
@@ -13,29 +14,54 @@ module Neo4j
         end
 
         def apply_to(builder, **hash)
-          hash.compact.reduce(builder) { |object, (key, value)| object.send(*config_method(key, value)) }
+          # nil means "unset" (dropped) for every key except :bookmark_manager,
+          # where nil is meaningful — it disables the manager via
+          # with_bookmark_manager(null), distinct from leaving it at the default.
+          hash.reject { |key, value| value.nil? && key != :bookmark_manager }
+              .reduce(builder) { |object, (key, value)| object.send(*config_method(key, value)) }
         end
 
         def config_method(key, value)
           method = :"with_#{key}"
           unit = nil
           case key.to_s
-          when 'encryption', 'driver_metrics', 'hostname_verification'
+          when 'encryption', 'hostname_verification'
             method = :"without_#{key}" unless value
             value = nil
           when 'timeout'
-            value = java.time.Duration.ofMillis(Driver::Internal::DurationNormalizer.milliseconds(value))
+            value = java.time.Duration.ofMillis(timeout_to_milliseconds(value))
           when /time(out)?$/, 'routing_table_purge_delay'
-            value = Driver::Internal::DurationNormalizer.milliseconds(value) || -1
+            value = timeout_to_milliseconds(value) || -1
             unit = java.util.concurrent.TimeUnit::MILLISECONDS
           when 'logger'
             method = :with_logging
             value = Neo4j::Driver::Ext::Logger.new(value)
           when 'resolver'
+            # LinkedHashSet (not HashSet) preserves the order the caller's
+            # resolver returned. The Java driver's ServerAddressResolver
+            # contract is `Set<ServerAddress>`, but its routing layer
+            # iterates that Set in its natural order to pick a router to
+            # probe — with a plain HashSet that's hash-of-host:port order,
+            # so the driver effectively picks at random and tests like
+            # test_should_read_successfully_on_empty_discovery_result_using_session_run
+            # (which expect probes in the resolver-returned order) become
+            # flaky.
             proc = value
-            value = ->(address) { java.util.HashSet.new(proc.call(address)) }
+            value = ->(address) { to_java_set(proc.call(address), java.util.LinkedHashSet) }
+          when 'bookmarks_supplier'
+            proc = value
+            value = -> { to_java_set(proc.call) }
+          when 'bookmarks_consumer'
+            proc = value
+            value = ->(bookmarks) { proc.call(Set.new(bookmarks)) }
           when 'bookmarks'
             return [method, *value]
+          when 'initial_bookmarks'
+            value = to_java_set(value)
+          when 'bookmark_manager'
+            # A BookmarkManager sets it; nil disables it (with_bookmark_manager(null)).
+            # `return` skips the trailing `.compact` so a nil arg survives to the builder.
+            return [method, value]
           when 'trust_strategy'
             value = trust_strategy(**value)
           when 'revocation_strategy'
@@ -59,7 +85,7 @@ module Neo4j
             case strategy
             when :trust_custom_certificates
               Config::TrustStrategy
-                .trust_custom_certificate_signed_by(*config.delete(:cert_files).map(&java.io.File.method(:new)))
+            .trust_custom_certificate_signed_by(*config.delete(:cert_files).map(&java.io.File.method(:new)))
             else
               Config::TrustStrategy.send(strategy)
             end
@@ -71,12 +97,15 @@ module Neo4j
             value_of(org.neo4j.driver.internal.InternalNotificationSeverity, minimum_severity).or_else(nil),
             disabled_categories
               &.map { |value| value_of(org.neo4j.driver.NotificationClassification, value) }
-              &.then(&java.util.HashSet.method(:new)))
+              &.then(&method(:to_java_set))
+          )
         end
 
         def value_of(klass, value)
           klass.value_of(value&.to_s&.upcase)
         end
+
+        def to_java_set(enumerable, class_name = java.util.HashSet) = class_name.new(enumerable.to_a)
       end
     end
   end

data/{jruby → lib}/neo4j/driver/ext/exception_checkable.rb

@@ -17,9 +17,9 @@ module Neo4j
         rescue Neo4j::Driver::Exceptions::ServiceUnavailableException => e
           raise(throwable(e.cause) || Java::OrgNeo4jDriverExceptions::ServiceUnavailableException.new(e.message))
         rescue Neo4j::Driver::Exceptions::Neo4jException,
-          Neo4j::Driver::Exceptions::NoSuchRecordException,
-          Neo4j::Driver::Exceptions::UntrustedServerException,
-          Neo4j::Driver::Exceptions::IllegalStateException => e
+               Neo4j::Driver::Exceptions::NoSuchRecordException,
+               Neo4j::Driver::Exceptions::UntrustedServerException,
+               Neo4j::Driver::Exceptions::IllegalStateException => e
           raise(throwable(e.cause) || e)
         end
 

data/lib/neo4j/driver/ext/exception_mapper.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionMapper
+        java_import org.neo4j.driver.exceptions.AuthenticationException
+        java_import org.neo4j.driver.exceptions.AuthorizationExpiredException
+        java_import org.neo4j.driver.exceptions.ClientException
+        java_import org.neo4j.driver.exceptions.ConnectionReadTimeoutException
+        java_import org.neo4j.driver.exceptions.DatabaseException
+        java_import org.neo4j.driver.exceptions.DiscoveryException
+        java_import org.neo4j.driver.exceptions.FatalDiscoveryException
+        java_import org.neo4j.driver.exceptions.Neo4jException
+        java_import org.neo4j.driver.exceptions.ProtocolException
+        java_import org.neo4j.driver.exceptions.ResultConsumedException
+        java_import org.neo4j.driver.exceptions.SecurityException
+        java_import org.neo4j.driver.exceptions.SecurityRetryableException
+        java_import org.neo4j.driver.exceptions.ServiceUnavailableException
+        java_import org.neo4j.driver.exceptions.SessionExpiredException
+        java_import org.neo4j.driver.exceptions.TokenExpiredException
+        java_import org.neo4j.driver.exceptions.TransactionNestingException
+        java_import org.neo4j.driver.exceptions.TransactionTerminatedException
+        java_import org.neo4j.driver.exceptions.TransientException
+        java_import org.neo4j.driver.exceptions.UnsupportedFeatureException
+        java_import org.neo4j.driver.exceptions.UntrustedServerException
+
+        def mapped_exception(exception)
+          mapped_neo4j_exception_class(exception)
+            &.new(exception.message, **neo4j_exception_kwargs(exception)) ||
+            mapped_runtime_exception_class(exception)&.new(exception.message) || exception
+        end
+
+        # Like mapped_exception, but chains the original Java exception as
+        # `.cause`. At a `raise mapped_exception(e)` site inside a
+        # `rescue => e` block Ruby sets `.cause` to the Java exception
+        # automatically (which reverse_check round-trips on via
+        # `throwable(e.cause)`). At sites that hand the mapped exception
+        # off as a *value* (AuthTokenManager#handle_security_exception)
+        # there is no such auto-set, so do it explicitly here. Ruby has no
+        # `cause=` setter;
+        # `raise … cause:` is the only way to attach one.
+        def mapped_exception_with_cause(exception)
+          mapped = mapped_exception(exception)
+          return mapped if mapped.equal?(exception) # unmapped passthrough — no self-cause
+
+          raise mapped, cause: exception
+        rescue StandardError => e
+          # Only the mapped exception we just raised becomes a return
+          # value; anything else (e.g. a bug in mapped_exception) must
+          # propagate rather than be silently turned into a value.
+          raise unless e.equal?(mapped)
+
+          e
+        end
+
+        private
+
+        def suppressed(e)
+          e.suppressed.map(&method(:mapped_exception))
+        end
+
+        # Pull through the GQL fields the testkit DriverError schema
+        # asserts on (gql_status, status_description, classification,
+        # raw_classification, diagnostic_record). All of these were
+        # added to org.neo4j.driver.exceptions.Neo4jException in the
+        # GQL-aware Bolt 5.7+ work; auto-aliased on JRuby.
+        #
+        # Java's accessors return Optional<T> for the nullable fields;
+        # unwrap to nil/value here so the Ruby exception only ever
+        # exposes plain Ruby values — the JRuby driver isn't allowed to
+        # leak Java types over the public API.
+        def neo4j_exception_kwargs(e)
+          {
+            code: effective_code(e),
+            suppressed: suppressed(e),
+            gql_status: unwrap_optional(e.gql_status),
+            status_description: unwrap_optional(e.status_description),
+            classification: unwrap_optional(e.classification)&.to_s,
+            raw_classification: unwrap_optional(e.raw_classification),
+            diagnostic_record: unwrap_optional(e.diagnostic_record)&.to_h,
+            gql_cause: gql_cause(e)
+          }
+        end
+
+        # The GQL cause chain (Neo4jException#gqlCause), mapped recursively so
+        # the Ruby exception carries the nested cause the testkit error shape
+        # asserts on. Each cause is itself a Neo4jException, so mapped_exception
+        # recurses (its own gqlCause included) until the chain ends.
+        def gql_cause(e)
+          cause = unwrap_optional(e.gql_cause)
+          cause && mapped_exception(cause)
+        end
+
+        def unwrap_optional(v)
+          v.respond_to?(:or_else) ? v.or_else(nil) : v
+        end
+
+        # A driver-generated wrapper — e.g. the SessionExpiredException raised
+        # for a write against a read-only database — reports code "N/A" but
+        # chains the original failure (the shaded BoltFailureException, which
+        # carries the real Neo4j code) as its cause. testkit asserts on that
+        # original code, so walk the cause chain to the first real code — or
+        # nil when none carries one ('N/A' is Java's no-code sentinel, which
+        # the Ruby API represents as nil, the same as MRI).
+        def effective_code(e)
+          return unless e
+
+          code = e.code if e.respond_to?(:code)
+          return code if code && code != 'N/A'
+
+          effective_code(e.cause)
+        end
+
+        def mapped_neo4j_exception_class(exception_class)
+          case exception_class
+          when AuthenticationException
+            Neo4j::Driver::Exceptions::AuthenticationException
+          when AuthorizationExpiredException
+            Neo4j::Driver::Exceptions::AuthorizationExpiredException
+          when FatalDiscoveryException
+            Neo4j::Driver::Exceptions::FatalDiscoveryException
+          when ResultConsumedException
+            Neo4j::Driver::Exceptions::ResultConsumedException
+          when TokenExpiredException
+            Neo4j::Driver::Exceptions::TokenExpiredException
+          when SecurityRetryableException # subclass of SecurityException — match first
+            Neo4j::Driver::Exceptions::SecurityRetryableException
+          when SecurityException
+            Neo4j::Driver::Exceptions::SecurityException
+          when TransactionNestingException
+            Neo4j::Driver::Exceptions::TransactionNestingException
+          when UnsupportedFeatureException
+            Neo4j::Driver::Exceptions::UnsupportedFeatureException
+          when TransactionTerminatedException # subclass of ClientException — match first
+            Neo4j::Driver::Exceptions::TransactionTerminatedException
+          when ClientException
+            Neo4j::Driver::Exceptions::ClientException
+          when ConnectionReadTimeoutException
+            Neo4j::Driver::Exceptions::ConnectionReadTimeoutException
+          when DatabaseException
+            Neo4j::Driver::Exceptions::DatabaseException
+          when DiscoveryException
+            Neo4j::Driver::Exceptions::DiscoveryException
+          when ProtocolException
+            Neo4j::Driver::Exceptions::ProtocolException
+          when ServiceUnavailableException
+            Neo4j::Driver::Exceptions::ServiceUnavailableException
+          when SessionExpiredException
+            Neo4j::Driver::Exceptions::SessionExpiredException
+          when TransientException
+            Neo4j::Driver::Exceptions::TransientException
+          when Neo4jException # base — catches plain GQL-cause exceptions (must be last)
+            Neo4j::Driver::Exceptions::Neo4jException
+          end
+        end
+
+        def mapped_runtime_exception_class(exception_class)
+          case exception_class
+          when Java::OrgNeo4jDriverExceptions::NoSuchRecordException
+            Neo4j::Driver::Exceptions::NoSuchRecordException
+          when Java::OrgNeo4jDriverExceptions::UntrustedServerException
+            Neo4j::Driver::Exceptions::UntrustedServerException
+          when Java::JavaLang::IllegalStateException
+            Neo4j::Driver::Exceptions::IllegalStateException
+          when Java::JavaLang::IllegalArgumentException
+            ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/graph_database.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module GraphDatabase
+        extend AutoCloseable
+        include ConfigConverter
+        include ExceptionCheckable
+
+        auto_closeable :driver
+
+        def driver(uri, auth_token = nil, auth_token_manager: nil, **config)
+          check do
+            java_config = to_java_config(Neo4j::Driver::Config, **config)
+            auth_class = auth_token_manager ? org.neo4j.driver.AuthTokenManager : org.neo4j.driver.AuthToken
+            auth = auth_token_manager || auth_token || Driver::AuthTokens.none
+            java_method(:driver, [java.lang.String, auth_class, org.neo4j.driver.Config])
+              .call(uri.to_s, auth, java_config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/clock_adapter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        # `java.time.Clock` adapter that delegates to any Ruby
+        # `clock` object responding to `#now_millis`. Used by
+        # `Internal::DriverFactory#to_clock` so testkit-backend's
+        # pure-Ruby `TestkitClock` can plug straight into Java's
+        # `DriverFactory#create_clock` seam.
+        class ClockAdapter < java.time.Clock
+          def initialize(ruby_clock)
+            super()
+            @ruby_clock = ruby_clock
+          end
+
+          def get_zone
+            raise java.lang.UnsupportedOperationException.new
+          end
+
+          def with_zone(_zone)
+            raise java.lang.UnsupportedOperationException.new
+          end
+
+          def instant
+            java.time.Instant.of_epoch_milli(@ruby_clock.now_millis)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/cluster/routing_table_registry_impl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Ext
+  module Internal
+    module Cluster
+      module RoutingTableRegistryImpl
+        def routing_table_handler(database)
+          if database
+            it = get_routing_table_handler(Neo4j::Driver::Internal::DatabaseName.database(database))
+            raise KeyError, "No routing table for database #{database.inspect}" unless it.present?
+
+            it.get
+          else
+            # The default/home database is keyed under the server-resolved
+            # name, not defaultDatabase(); in the single-table stub case
+            # (testkit's get_routing_table() with no database) return it.
+            handlers = Reflection.field(self, 'routingTableHandlers').values
+            unless handlers.size == 1
+              raise KeyError, "Cannot resolve default routing table (#{handlers.size} present; specify a database)"
+            end
+
+            handlers.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/driver_factory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        # Ruby-side helpers prepended onto Java's
+        # `org.neo4j.driver.internal.DriverFactory` (aliased as
+        # `Neo4j::Driver::Internal::DriverFactory`). Lets further Ruby
+        # subclasses — testkit-backend's
+        # `DriverFactoryWithDomainNameResolver` — override the
+        # `protected` `getDomainNameResolver` / `create_clock` seams
+        # without naming any Java type: testkit hands its Ruby Proc /
+        # `TestkitClock` to the converter and gets back something the
+        # Java driver consumes (a `DomainNameResolver` SAM /
+        # `java.time.Clock`).
+        #
+        # `new_instance` is a Ruby-friendly wrapper over Java's 4-arg
+        # `newInstance` — takes a Ruby Hash config and an optional
+        # `ClientCertificateManager` (mutual TLS), and `super`s into the
+        # Java method.
+        module DriverFactory
+          include Ext::ConfigConverter
+          include Ext::ExceptionCheckable
+
+          def to_domain_name_resolver(resolver_proc)
+            return nil unless resolver_proc
+
+            lambda do |name|
+              resolver_proc.call(name).map do |addr|
+                java.net.InetAddress.get_by_name(addr)
+              rescue java.net.UnknownHostException => e
+                raise java.lang.RuntimeException.new(e)
+              end
+            end
+          end
+
+          def to_clock(clock)
+            ClockAdapter.new(clock)
+          end
+
+          def new_instance(uri, auth_token_manager, client_certificate_manager: nil, **config)
+            check do
+              super(java.net.URI.create(uri.to_s),
+                    auth_token_manager,
+                    client_certificate_manager,
+                    to_java_config(Neo4j::Driver::Config, **config))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/internal_notification_severity.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module InternalNotificationSeverity
+          extend Forwardable
+
+          delegate name: :type
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/reflection.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        # Read a private field off a Java object. Used to reach internal
+        # driver state the 6.x public API no longer exposes (the routing
+        # table registry chain consumed by testkit's GetRoutingTable).
+        module Reflection
+          def self.field(object, name)
+            object.java_class.declared_field(name).tap { |f| f.accessible = true }.get(object)
+          end
+
+          def self.field?(object, name)
+            object.java_class.declared_fields.any? { |f| f.name == name }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/summary/internal_gql_notification.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          # A GqlStatusObject that is also a notification. Unwraps the Java
+          # Optionals so the backend sees plain Ruby (an InputPosition or nil,
+          # and parsed name strings) — mirroring the InternalNotification ext.
+          module InternalGqlNotification
+            def position = super.or_else(nil)
+            def classification = super.or_else(nil)&.name
+            def raw_classification = super.or_else(nil)
+            def severity = super.or_else(nil)&.name
+            def raw_severity = super.or_else(nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/ext/internal/summary/internal_gql_status_object.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          # A GqlStatusObject. Hydrate the Java Map<String, Value> diagnostic
+          # record to a plain (symbol-keyed) Ruby hash, like the rest of the
+          # summary; the GqlNotification subtype adds position/severity/…
+          module InternalGqlStatusObject
+            def diagnostic_record = super.as_ruby_object
+          end
+        end
+      end
+    end
+  end
+end