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

data/lib/neo4j/driver/types/duration.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Bolt Duration. Stores months, days, seconds, nanoseconds as
+      # distinct ints — Neo4j keeps these separate because months are
+      # variable-length (no fixed conversion to seconds).
+      class Duration < TemporalValue
+        attr_reader :months, :days, :seconds, :nanoseconds
+
+        def self.significant_fields = %i[months days seconds nanoseconds]
+
+        def initialize(months, days, seconds, nanoseconds)
+          @months = months.to_i
+          @days = days.to_i
+          @seconds = seconds.to_i
+          @nanoseconds = nanoseconds.to_i
+          normalize!
+        end
+
+        # Parse ISO 8601 duration: "P1Y2M3DT4H5M6.789S", "P3M", "PT2H30M"
+        def self.parse(string)
+          unless string =~ /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/
+            raise ArgumentError, "Invalid ISO 8601 duration format: #{string}"
+          end
+
+          years = (::Regexp.last_match(1) || 0).to_i
+          months = (::Regexp.last_match(2) || 0).to_i
+          days = (::Regexp.last_match(3) || 0).to_i
+          hours = (::Regexp.last_match(4) || 0).to_i
+          minutes = (::Regexp.last_match(5) || 0).to_i
+          seconds_with_fraction = (::Regexp.last_match(6) || 0).to_f
+
+          total_months = years * 12 + months
+          whole_seconds = seconds_with_fraction.to_i
+          fractional_seconds = seconds_with_fraction - whole_seconds
+          nanos = (fractional_seconds * NANOS_PER_SECOND).round
+          total_seconds = hours * 3600 + minutes * 60 + whole_seconds
+
+          new(total_months, days, total_seconds, nanos)
+        end
+
+        def parts
+          { months: @months, days: @days, seconds: @seconds, nanoseconds: @nanoseconds }
+        end
+
+        # ISO 8601 form. Nanoseconds get a 9-digit zero-padded suffix on
+        # seconds so 1s + 5ns prints as "PT1.000000005S", not "PT1.5S".
+        def to_s
+          if @nanoseconds.zero?
+            format('P%dM%dDT%dS', @months, @days, @seconds)
+          else
+            format('P%dM%dDT%d.%09dS', @months, @days, @seconds, @nanoseconds)
+          end
+        end
+
+        private
+
+        # Normalize nanoseconds overflow/underflow into seconds:
+        # -1ns becomes -1s + 999999999ns; 1.5e9 ns becomes 1s + 5e8 ns.
+        def normalize!
+          if @nanoseconds < 0
+            sec_adjust = (@nanoseconds.abs / NANOS_PER_SECOND.to_f).ceil
+            @seconds -= sec_adjust
+            @nanoseconds += sec_adjust * NANOS_PER_SECOND
+          elsif @nanoseconds >= NANOS_PER_SECOND
+            sec_adjust = @nanoseconds / NANOS_PER_SECOND
+            @seconds += sec_adjust
+            @nanoseconds %= NANOS_PER_SECOND
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/local_date_time.rb

@@ -3,17 +3,86 @@
 module Neo4j
   module Driver
     module Types
-      class LocalDateTime < Time
-        class << self
-          FIELDS = %i[year month day hour min sec nsec].freeze
+      # Bolt LocalDateTime — a wall-clock datetime with no timezone
+      # (java.time.LocalDateTime). Stored as the wire-format pair
+      # (epoch_seconds, nanoseconds), where epoch_seconds encodes the
+      # wall-clock components as if they were UTC — so the value reads the
+      # same regardless of the host TZ.
+      #
+      # There is deliberately no #to_time: a zone-less value cannot become a
+      # zoned Ruby Time without inventing a zone, and every serious datetime
+      # library refuses that implicit conversion (Java's LocalDateTime forces
+      # .atZone/.atOffset; Python yields a naive datetime). Read the fields via
+      # the component getters instead.
+      class LocalDateTime < TemporalValue
+        PARSE_FORMATS = [
+          '%Y-%m-%d %H:%M:%S.%N',
+          '%Y-%m-%dT%H:%M:%S.%N',
+          '%Y-%m-%d %H:%M:%S',
+          '%Y-%m-%dT%H:%M:%S',
+          '%Y-%m-%d %H:%M'
+        ].freeze
 
-          def significant_fields
-            FIELDS
-          end
+        attr_reader :epoch_seconds, :nanoseconds
+
+        def self.significant_fields = %i[epoch_seconds nanoseconds]
+
+        def initialize(epoch_seconds, nanoseconds)
+          @epoch_seconds = epoch_seconds
+          @nanoseconds = nanoseconds
+        end
+
+        def self.from_epoch(epoch_seconds, nanoseconds) = new(epoch_seconds, nanoseconds)
+
+        # Store the Time's wall clock (its date and time-of-day *in its own
+        # zone*), dropping the zone. We read that wall clock off the instant
+        # using the offset the Time already carries — we never invent a zone,
+        # so from_time(t) and from_time(t.utc) differ (they show different
+        # clocks). epoch_seconds encodes it as-if-UTC per the class contract.
+        def self.from_time(time)
+          new(time.to_i + time.utc_offset, time.nsec)
+        end
+
+        def self.parse(string)
+          # Strip trailing timezone if present — naive datetime ignores it.
+          naive = string.sub(/[Z+-]\d{2}:?\d{2}?$/, '')
+          time = PARSE_FORMATS.lazy.filter_map do |fmt|
+            ::Time.strptime(naive, fmt)
+          rescue StandardError
+            nil
+          end.first
+          raise ArgumentError, "Invalid LocalDateTime format: #{string}" unless time
+
+          from_time(time)
         end
 
-        delegate(*significant_fields, to: :@time)
-        delegate :to_i, to: :@time
+        def year       = wall_clock.year
+        def month      = wall_clock.month
+        def day        = wall_clock.day
+        def hour       = wall_clock.hour
+        def minute     = wall_clock.min
+        def second     = wall_clock.sec
+        def nanosecond = @nanoseconds
+
+        # Add a numeric or ActiveSupport::Duration. A wall clock has no DST,
+        # so this is plain second arithmetic; sub-second precision preserved.
+        def +(other)
+          total = (@epoch_seconds * NANOS_PER_SECOND) + @nanoseconds +
+                  (other.to_f * NANOS_PER_SECOND).round
+          self.class.new(total / NANOS_PER_SECOND, total % NANOS_PER_SECOND)
+        end
+
+        def to_s
+          wall_clock.strftime('%Y-%m-%d %H:%M:%S.%N')
+        end
+
+        private
+
+        # epoch_seconds read back as its wall clock. UTC by construction, so
+        # the components never depend on the host TZ.
+        def wall_clock
+          ::Time.at(@epoch_seconds, @nanoseconds.to_i, :nanosecond, in: 'UTC')
+        end
       end
     end
   end

data/lib/neo4j/driver/types/local_time.rb

@@ -3,16 +3,59 @@
 module Neo4j
   module Driver
     module Types
-      class LocalTime < Time
-        class << self
-          FIELDS = %i[hour min sec nsec].freeze
+      # Bolt LocalTime — time of day without timezone, stored as
+      # nanoseconds since midnight.
+      class LocalTime < TemporalValue
+        attr_reader :nanoseconds
 
-          def significant_fields
-            FIELDS
-          end
+        def self.significant_fields = %i[nanoseconds]
+
+        def initialize(nanoseconds)
+          @nanoseconds = nanoseconds % NANOS_PER_DAY
+        end
+
+        def self.from_nanos(nanoseconds) = new(nanoseconds)
+
+        # Build from a Ruby Time, taking its displayed wall clock (so the
+        # host zone / .utc of the Time decides which time-of-day is captured).
+        # Mirrors LocalDateTime.from_time.
+        def self.from_time(time)
+          new(time.hour * NANOS_PER_HOUR + time.min * NANOS_PER_MINUTE +
+              time.sec * NANOS_PER_SECOND + time.nsec)
+        end
+
+        # Accepts "12:34:56.123456789" or any string containing such a
+        # time component (so a full datetime works too — we just take the
+        # time fields).
+        def self.parse(string)
+          match = string.match(/(\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?/)
+          raise ArgumentError, "Invalid LocalTime format: #{string}" unless match
+
+          new(parse_nanos(match[1].to_i, match[2].to_i, (match[3] || 0).to_i, match[4] || '0'))
         end
 
-        delegate(*significant_fields, to: :@time)
+        def self.parse_nanos(hour, minute, second, fraction)
+          hour * NANOS_PER_HOUR +
+            minute * NANOS_PER_MINUTE +
+            second * NANOS_PER_SECOND +
+            fraction.ljust(9, '0')[0..8].to_i
+        end
+        private_class_method :parse_nanos
+
+        def hour = (@nanoseconds / NANOS_PER_HOUR) % 24
+        def minute = (@nanoseconds / NANOS_PER_MINUTE) % 60
+        def second = (@nanoseconds / NANOS_PER_SECOND) % 60
+        def nanosecond = @nanoseconds % NANOS_PER_SECOND
+
+        # Add a numeric or ActiveSupport::Duration. Sub-second precision
+        # preserved by going through to_f (NOT to_i, which dropped 0.5s).
+        def +(other)
+          self.class.new(@nanoseconds + (other.to_f * NANOS_PER_SECOND).round)
+        end
+
+        def to_s
+          format('%02d:%02d:%02d.%09d', hour, minute, second, nanosecond)
+        end
       end
     end
   end

data/lib/neo4j/driver/types/offset_time.rb

@@ -3,16 +3,87 @@
 module Neo4j
   module Driver
     module Types
-      class OffsetTime < Time
-        class << self
-          FIELDS = %i[hour min sec nsec utc_offset].freeze
+      # Bolt OffsetTime — time of day with a fixed UTC offset, stored as
+      # nanoseconds-since-midnight (in local wall clock) plus offset
+      # seconds. Equivalent to java.time.OffsetTime. Was previously
+      # called Types::Time, which collided cosmetically with ::Time.
+      class OffsetTime < TemporalValue
+        attr_reader :nanoseconds, :tz_offset_seconds
 
-          def significant_fields
-            FIELDS
-          end
+        def self.significant_fields = %i[nanoseconds tz_offset_seconds]
+
+        def initialize(nanoseconds, tz_offset_seconds)
+          @nanoseconds = nanoseconds % NANOS_PER_DAY
+          @tz_offset_seconds = tz_offset_seconds
+        end
+
+        def self.from_nanos(nanoseconds, tz_offset_seconds) = new(nanoseconds, tz_offset_seconds)
+
+        # Build from a Ruby Time — its wall clock plus its UTC offset.
+        # Reuses LocalTime's field extraction. Mirrors LocalDateTime.from_time.
+        def self.from_time(time)
+          new(LocalTime.from_time(time).nanoseconds, time.utc_offset)
+        end
+
+        # Accepts "12:34:56.123456789+01:00", "12:34:56Z", or any string
+        # containing such a time-with-offset component.
+        def self.parse(string)
+          match = string.match(/(\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?([Z+-][\d:]*)?/)
+          raise ArgumentError, "Invalid OffsetTime format: #{string}" unless match
+
+          nanos = LocalTime.send(:parse_nanos,
+                                 match[1].to_i, match[2].to_i, (match[3] || 0).to_i, match[4] || '0')
+          new(nanos, parse_offset(match[5] || 'Z'))
+        end
+
+        def self.parse_offset(str)
+          return 0 if str == 'Z'
+          raise ArgumentError, "Invalid timezone offset: #{str}" unless str =~ /^([+-])(\d{2}):?(\d{2})?$/
+
+          sign = ::Regexp.last_match(1) == '+' ? 1 : -1
+          sign * (::Regexp.last_match(2).to_i * 3600 + (::Regexp.last_match(3) || 0).to_i * 60)
         end
+        private_class_method :parse_offset
 
-        delegate(*significant_fields, to: :@time)
+        def hour = (@nanoseconds / NANOS_PER_HOUR) % 24
+        def minute = (@nanoseconds / NANOS_PER_MINUTE) % 60
+        def second = (@nanoseconds / NANOS_PER_SECOND) % 60
+        def nanosecond = @nanoseconds % NANOS_PER_SECOND
+
+        # Add a numeric or ActiveSupport::Duration. Sub-second precision
+        # preserved (see LocalTime#+).
+        def +(other)
+          self.class.new(@nanoseconds + (other.to_f * NANOS_PER_SECOND).round, @tz_offset_seconds)
+        end
+
+        def to_s
+          # Apply the sign to the formatted offset as a whole, not to
+          # `hours` alone — Ruby integer division for `-12600 / 3600` is
+          # -4 (floor toward -∞), which would render -03:30 as -04:30.
+          abs = @tz_offset_seconds.abs
+          sign = @tz_offset_seconds.negative? ? '-' : '+'
+          format('%02d:%02d:%02d.%09d%s%02d:%02d',
+                 hour, minute, second, nanosecond,
+                 sign, abs / 3600, (abs % 3600) / 60)
+        end
+
+        # Order by underlying UTC instant. Two OffsetTimes representing
+        # the same UTC instant in different offsets compare equal under
+        # <=>; == still requires same fields (they're not the same value).
+        def <=>(other)
+          return nil unless other.is_a?(OffsetTime)
+
+          utc_nanos <=> other.utc_nanos
+        end
+
+        protected
+
+        # UTC = local − offset. Positive offset means "ahead of UTC", so
+        # the UTC instant is *earlier* (smaller nanos). The previous
+        # implementation added instead of subtracting, inverting ordering.
+        def utc_nanos
+          @nanoseconds - (@tz_offset_seconds * NANOS_PER_SECOND)
+        end
       end
     end
   end

data/lib/neo4j/driver/types/point.rb

@@ -3,36 +3,56 @@
 module Neo4j
   module Driver
     module Types
+      # Point (2D or 3D)
       class Point
-        attr_accessor :srid, :x, :y, :z
+        attr_reader :srid, :x, :y, :z
 
-        SRID = {
-          'WGS-84': 4326,
-          'WGS-84-3D': 4979,
-          cartesian: 7203,
-          'cartesian-3D': 9157
-        }.with_indifferent_access.freeze
+        # SRID constants for coordinate reference systems
+        WGS_84_2D = 4326 # Geographic 2D (longitude, latitude)
+        WGS_84_3D = 4979 # Geographic 3D (longitude, latitude, height)
+        CARTESIAN_2D = 7203 # Cartesian 2D (x, y)
+        CARTESIAN_3D = 9157 # Cartesian 3D (x, y, z)
 
-        def initialize(args)
-          self.x = args[:longitude] || args[:x]
-          self.y = args[:latitude] || args[:y]
-          self.z = args[:height] || args[:z]
-          self.srid = args[:srid] || SRID[args[:crs] || implied_crs(args[:longitude] || args[:latitude])]
+        def initialize(srid: nil, x: nil, y: nil, z: nil, longitude: nil, latitude: nil, height: nil)
+          # Handle longitude/latitude aliases for x/y
+          if longitude || latitude
+            @x = (longitude || x).to_f
+            @y = (latitude || y).to_f
+            @z = (height || z)&.to_f
+            # Use WGS-84 SRID for geographic coordinates
+            @srid = srid || (@z ? WGS_84_3D : WGS_84_2D)
+          else
+            @x = x.to_f
+            @y = y.to_f
+            @z = z&.to_f
+            # Use Cartesian SRID for x/y/z coordinates
+            @srid = srid || (@z ? CARTESIAN_3D : CARTESIAN_2D)
+          end
+        end
+
+        def dimension
+          @z.nil? ? 2 : 3
         end
 
         def coordinates
           [x, y, z].compact.map(&:to_f)
         end
 
-        private
-
-        def implied_crs(geo)
-          if geo
-            z ? :'WGS-84-3D' : :'WGS-84'
+        def to_s
+          if @z
+            "Point{srid=#{@srid}, x=#{@x}, y=#{@y}, z=#{@z}}"
           else
-            z ? :'cartesian-3D' : :cartesian
+            "Point{srid=#{@srid}, x=#{@x}, y=#{@y}}"
           end
         end
+
+        def ==(other)
+          other.is_a?(Point) &&
+            other.srid == @srid &&
+            (other.x - @x).abs < 0.00001 &&
+            (other.y - @y).abs < 0.00001 &&
+            (@z.nil? || (other.z - @z).abs < 0.00001)
+        end
       end
     end
   end

data/lib/neo4j/driver/types/temporal_value.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Shared base for the Bolt temporal value types: Duration,
+      # LocalDateTime, LocalTime, OffsetTime. Each subclass declares its
+      # `significant_fields` and gets `<=>`, `==`, `eql?`, `hash` derived
+      # from them automatically. Comparable mixed in here gives `<`, `>`,
+      # `between?`, `clamp` etc. for free.
+      class TemporalValue
+        include Comparable
+
+        NANOS_PER_SECOND = 1_000_000_000
+        NANOS_PER_MINUTE = 60 * NANOS_PER_SECOND
+        NANOS_PER_HOUR = 60 * NANOS_PER_MINUTE
+        NANOS_PER_DAY = 24 * NANOS_PER_HOUR
+
+        def self.significant_fields
+          raise NotImplementedError, "#{self} must define .significant_fields"
+        end
+
+        def significant
+          self.class.significant_fields.map { send(it) }
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(self.class)
+
+          significant <=> other.significant
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && significant == other.significant
+        end
+        alias eql? ==
+
+        def hash
+          significant.hash
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/unresolvable_zoned_date_time.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # A ZonedDateTime the driver received with a zone id its runtime's time
+      # zone database can't resolve (e.g. the server sent "Europe/Neo4j").
+      #
+      # Hydration can't build a real Time, but raising mid-record on the reader
+      # thread would break the connection and strand the whole result — so the
+      # failure is deferred into this placeholder. Any consumer that tries to
+      # interpret the value raises (naming the zone), matching the Java driver,
+      # while the record and connection stay intact so an open transaction can
+      # still roll back cleanly.
+      class UnresolvableZonedDateTime
+        attr_reader :zone_name
+
+        def initialize(zone_name)
+          @zone_name = zone_name
+        end
+
+        # The driver error this value stands in for. Raised by any consumer
+        # that tries to use it (the testkit backend on serialize; a public-API
+        # caller via #value).
+        def error
+          Exceptions::ClientException.new(
+            "The server returned a ZonedDateTime with a zone id (#{@zone_name.inspect}) " \
+            "that this runtime's time zone database does not recognise"
+          )
+        end
+
+        def value
+          raise error
+        end
+      end
+    end
+  end
+end

data/{jruby → lib}/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '6.0.3.alpha.0'
+    VERSION = '6.2.1.beta.2'
   end
 end

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

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/hash/keys'
 require 'neo4j-ruby-driver_jars'
 require 'neo4j-ruby-driver_loader'
 
 module Neo4j
   module Driver
-    Loader.load
+    Loader.load(:jruby) do |loader|
+      impl_root = File.expand_path('..', __dir__)
+      loader.ignore(File.expand_path('org', impl_root))
+      loader.ignore(File.expand_path('neo4j-ruby-driver_jars.rb', impl_root))
+    end
 
     include_package 'org.neo4j.driver'
 
@@ -17,6 +20,11 @@ module Neo4j
 
     module Internal
       java_import org.neo4j.driver.internal.shaded.bolt.connection.DatabaseName
+      java_import org.neo4j.driver.internal.DriverFactory
+
+      module Security
+        java_import org.neo4j.driver.internal.security.StaticAuthTokenManager
+      end
     end
 
     module Net
@@ -25,6 +33,7 @@ module Neo4j
 
     module Summary
       include_package 'org.neo4j.driver.summary'
+      GqlNotification = Java::OrgNeo4jDriverInternalSummary::InternalGqlNotification
     end
 
     module Types
@@ -32,31 +41,46 @@ module Neo4j
       Node = Java::OrgNeo4jDriverInternal::InternalNode
       Path = Java::OrgNeo4jDriverInternal::InternalPath
       Relationship = Java::OrgNeo4jDriverInternal::InternalRelationship
+      # Bolt 6.0 forward-compat marker. Aliasing the Java type here lets the
+      # testkit backend match it with the same `Neo4j::Driver::Types::
+      # UnsupportedType` case MRI uses (which has its own pure-Ruby class).
+      UnsupportedType = Java::OrgNeo4jDriverTypes::UnsupportedType
+      # Bolt 6.1 UUID. Native java.util.UUID (immutable, value-equal,
+      # fromString) — MRI has its own opaque Types::UUID with the same
+      # from_string / to_s surface.
+      UUID = Java::JavaUtil::UUID
     end
   end
 end
 
+Java::JavaUtil::Map.include Neo4j::Driver::Ext::PlainMapConverter
 Java::OrgNeo4jDriver::AuthTokens.singleton_class.prepend Neo4j::Driver::Ext::AuthTokens
+Java::OrgNeo4jDriver::BookmarkManagers.singleton_class.prepend Neo4j::Driver::Ext::BookmarkManagers
+Java::OrgNeo4jDriver::ClientCertificates.singleton_class.prepend Neo4j::Driver::Ext::ClientCertificates
 Java::OrgNeo4jDriver::GraphDatabase.singleton_class.prepend Neo4j::Driver::Ext::GraphDatabase
 Java::OrgNeo4jDriver::Query.prepend Neo4j::Driver::Ext::Query
+Java::OrgNeo4jDriverInternal::DelegatingTransactionContext.prepend Neo4j::Driver::Ext::Internal::AbstractQueryRunner
+Java::OrgNeo4jDriverInternal::DriverFactory.prepend Neo4j::Driver::Ext::Internal::DriverFactory
 Java::OrgNeo4jDriverInternal::EagerResultValue.prepend Neo4j::Driver::Ext::Internal::EagerResultValue
 Java::OrgNeo4jDriverInternal::InternalDriver.prepend Neo4j::Driver::Ext::InternalDriver
 Java::OrgNeo4jDriverInternal::InternalEntity.include Neo4j::Driver::Ext::InternalEntity
 Java::OrgNeo4jDriverInternal::InternalNode.prepend Neo4j::Driver::Ext::InternalNode
-Java::OrgNeo4jDriverInternal::InternalNotificationSeverity.delegate :name, to: :type
+Java::OrgNeo4jDriverInternal::InternalNotificationSeverity.include Neo4j::Driver::Ext::Internal::InternalNotificationSeverity
 Java::OrgNeo4jDriverInternal::InternalPath.include Neo4j::Driver::Ext::StartEndNaming
 Java::OrgNeo4jDriverInternal::InternalPath::SelfContainedSegment.include Neo4j::Driver::Ext::StartEndNaming
 Java::OrgNeo4jDriverInternal::InternalRecord.prepend Neo4j::Driver::Ext::InternalRecord
 Java::OrgNeo4jDriverInternal::InternalRelationship.prepend Neo4j::Driver::Ext::InternalRelationship
+Java::OrgNeo4jDriverInternal::InternalUnsupportedType.prepend Neo4j::Driver::Ext::UnsupportedType
 Java::OrgNeo4jDriverInternal::InternalResult.prepend Neo4j::Driver::Ext::InternalResult
 Java::OrgNeo4jDriverInternal::InternalSession.prepend Neo4j::Driver::Ext::InternalSession
 Java::OrgNeo4jDriverInternal::InternalTransaction.prepend Neo4j::Driver::Ext::InternalTransaction
-Java::OrgNeo4jDriverInternal::DelegatingTransactionContext.prepend Neo4j::Driver::Ext::Internal::AbstractQueryRunner
-Java::OrgNeo4jDriverInternalAsync::InternalAsyncSession.prepend Neo4j::Driver::Ext::Internal::Async::InternalAsyncSession
+Java::OrgNeo4jDriverInternalSecurity::InternalAuthToken.include Neo4j::Driver::Ext::AuthToken
 Java::OrgNeo4jDriverInternalShadedBoltConnectionRoutedImplCluster::RoutingTableRegistryImpl.include Neo4j::Driver::Ext::Internal::Cluster::RoutingTableRegistryImpl
-# Java::OrgNeo4jDriverInternalCursor::DisposableAsyncResultCursor.prepend Neo4j::Driver::Ext::Internal::Cursor::DisposableAsyncResultCursor
-Java::OrgNeo4jDriverObservationMetricsInternal::InternalConnectionPoolMetrics.include Neo4j::Driver::Ext::Internal::Metrics::InternalConnectionPoolMetrics
+Java::OrgNeo4jDriverInternalSummary::InternalGqlNotification.prepend Neo4j::Driver::Ext::Internal::Summary::InternalGqlNotification
+Java::OrgNeo4jDriverInternalSummary::InternalGqlStatusObject.prepend Neo4j::Driver::Ext::Internal::Summary::InternalGqlStatusObject
 Java::OrgNeo4jDriverInternalSummary::InternalNotification.prepend Neo4j::Driver::Ext::Internal::Summary::InternalNotification
 Java::OrgNeo4jDriverInternalSummary::InternalPlan.prepend Neo4j::Driver::Ext::Internal::Summary::InternalPlan
+Java::OrgNeo4jDriverInternalSummary::InternalQueryProfile.prepend Neo4j::Driver::Ext::Internal::Summary::InternalQueryProfile
 Java::OrgNeo4jDriverInternalSummary::InternalResultSummary.prepend Neo4j::Driver::Ext::Internal::Summary::InternalResultSummary
 Java::OrgNeo4jDriverInternalValue::ValueAdapter.include Neo4j::Driver::Ext::RubyConverter
+Java::OrgNeo4jDriverObservationMetricsInternal::InternalConnectionPoolMetrics.include Neo4j::Driver::Ext::Internal::Metrics::InternalConnectionPoolMetrics

data/lib/neo4j-ruby-driver_jars.rb

@@ -0,0 +1,14 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'org/neo4j/driver/neo4j-java-driver-all/6.2.1/neo4j-java-driver-all-6.2.1.jar'
+  require 'org/reactivestreams/reactive-streams/1.0.4/reactive-streams-1.0.4.jar'
+  require 'org/neo4j/driver/neo4j-java-driver-observation-metrics/6.2.1/neo4j-java-driver-observation-metrics-6.2.1.jar'
+end
+
+if defined? Jars
+  require_jar 'org.neo4j.driver', 'neo4j-java-driver-all', '6.2.1'
+  require_jar 'org.reactivestreams', 'reactive-streams', '1.0.4'
+  require_jar 'org.neo4j.driver', 'neo4j-java-driver-observation-metrics', '6.2.1'
+end