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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          # QueryProfile (driver 6.2) reports each profile stat as an
+          # Optional, so an absent stat is distinguishable from a real 0 —
+          # unlike the deprecated ProfiledPlan, whose long getters collapse
+          # absent to 0. Map empty -> nil (the backend omits nil) and
+          # present -> the value; this is what makes
+          # Feature:API:Summary:Profile:OptionalStats work. operator_type /
+          # args / identifiers / children come from the InternalPlan
+          # superclass unchanged.
+          module InternalQueryProfile
+            def db_hits = long(dbHits)
+            def records = long(rows)
+            def page_cache_hits = long(pageCacheHits)
+            def page_cache_misses = long(pageCacheMisses)
+            def page_cache_hit_ratio = double(pageCacheHitRatio)
+            def time = super.or_else(nil)&.to_nanos
+
+            private
+
+            # OptionalLong / OptionalDouble -> Integer / Float, or nil when
+            # empty. or_else(nil) can't be used: their orElse takes a
+            # primitive default, not nil.
+            def long(optional) = optional.present? ? optional.as_long : nil
+            def double(optional) = optional.present? ? optional.as_double : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          module InternalResultSummary
+            %i[result_available_after result_consumed_after].each do |method|
+              define_method(method) do
+                super(Java::JavaUtilConcurrent::TimeUnit::MILLISECONDS).then { |val| val unless val == -1 }
+              end
+            end
+
+            # Ruby-ify the 6.2 queryProfile() Optional -> the QueryProfile or
+            # nil. The presence-aware profile (Optional stats) the backend
+            # serializes; `profile` stays the deprecated ProfiledPlan.
+            def query_profile = super.or_else(nil)
+
+            # Driver::Summary::QueryType is a Ruby module in lib/shared/.
+            # include_package only fills missing constants on a module via
+            # const_missing — Java never overrides Ruby constants that
+            # already exist, regardless of load order. So our Ruby module
+            # wins on both flavours.
+            #
+            # The case selector still needs the Java enum. Fully-qualifying
+            # Java::OrgNeo4jDriverSummary::QueryType keeps readers from
+            # wondering whether `QueryType` here means the Ruby module or
+            # the Java enum, and avoids a java_import line whose only job
+            # would be to disambiguate this one method.
+            def query_type
+              case super
+              when Java::OrgNeo4jDriverSummary::QueryType::READ_ONLY    then Driver::Summary::QueryType::READ_ONLY
+              when Java::OrgNeo4jDriverSummary::QueryType::READ_WRITE   then Driver::Summary::QueryType::READ_WRITE
+              when Java::OrgNeo4jDriverSummary::QueryType::WRITE_ONLY   then Driver::Summary::QueryType::WRITE_ONLY
+              when Java::OrgNeo4jDriverSummary::QueryType::SCHEMA_WRITE then Driver::Summary::QueryType::SCHEMA_WRITE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalDriver
+        extend AutoCloseable
+        include ConfigConverter
+        include ExceptionCheckable
+
+        auto_closeable :session
+
+        # See lib/mri/.../driver.rb. auth_token is part of `config` in the
+        # published surface, but Java's builder takes it as a separate
+        # setter — pull it out before handing the rest to QueryConfig.
+        def execute_query(query, parameters = {}, config = {})
+          auth_token = config.delete(:auth_token)
+          check do
+            executable_query(query)
+              .with_auth_token(auth_token)
+              .with_config(to_java_config(Neo4j::Driver::QueryConfig, **config))
+              .with_parameters(to_neo(parameters))
+              .execute
+          end
+        end
+
+        def session(auth_token: nil, **session_config)
+          # auth_token is a per-session override (Feature:API:Session:AuthConfig);
+          # Java exposes it via Driver.session(Class<T>, SessionConfig, AuthToken).
+          # Passing null defers to the driver default — same as the
+          # 2-arg overload, so we can always take the long path.
+          java_method(:session,
+                      [java.lang.Class, org.neo4j.driver.SessionConfig, org.neo4j.driver.AuthToken])
+            .call(org.neo4j.driver.Session.java_class,
+                  to_java_config(Neo4j::Driver::SessionConfig, **session_config),
+                  auth_token)
+        end
+
+        def verify_connectivity
+          check { super }
+        end
+
+        def verify_authentication(auth_token)
+          check { super }
+        end
+
+        def supports_session_auth?
+          check { supports_session_auth }
+        end
+
+        # Routing table for `database` (testkit GetRoutingTable). Returns
+        # Java's RoutingTable (routers/writers/readers + expirationTimestamp);
+        # the path to it is the driver's business, not testkit's.
+        def routing_table(database)
+          routing_table_registry.routing_table_handler(database).routing_table
+        end
+
+        # Force a routing-table refresh (testkit ForcedRoutingTableUpdate).
+        # Drive the registry's ensureRoutingTable — a fresh/aged table is
+        # stale, so this triggers a real ROUTE and populates the handler.
+        # ImmutableObservation is an empty marker interface, so a bare impl
+        # is enough.
+        def routing_table_refresh(database, bookmarks)
+          db_name = Neo4j::Driver::Internal::DatabaseName.database(database)
+          params = Java::OrgNeo4jDriverInternalShadedBoltConnection::RoutedBoltConnectionParameters
+                   .builder
+                   .with_database_name(db_name)
+                   .with_bookmarks(java.util.HashSet.new(Array(bookmarks)))
+                   .build
+          routing_table_registry
+            .ensure_routing_table(java.util.concurrent.CompletableFuture.completed_future(db_name),
+                                  params, NOOP_OBSERVATION)
+            .to_completable_future.get
+        end
+
+        NOOP_OBSERVATION = Class.new do
+          include Java::OrgNeo4jDriverInternalShadedBoltConnectionObservation::ImmutableObservation
+        end.new
+
+        private
+
+        # Reflect from the session factory down to the RoutedBoltConnectionSource
+        # that owns the routing-table registry. The number of delegating
+        # wrappers varies by driver version (6.1.x adds a
+        # ProviderClosingBoltConnectionSource), so unwrap `delegate` until the
+        # source with a `registry` field.
+        def routing_table_registry
+          source = Internal::Reflection.field(session_factory, 'connectionSource')
+          until Internal::Reflection.field?(source, 'registry')
+            unless Internal::Reflection.field?(source, 'delegate')
+              raise KeyError, "No routing-table registry in the connection-source chain (#{source.java_class.simple_name})"
+            end
+
+            source = Internal::Reflection.field(source, 'delegate')
+          end
+          Internal::Reflection.field(source, 'registry')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      class Logger
+        include org.neo4j.driver.Logger
+        include org.neo4j.driver.Logging
+        extend Forwardable
+
+        delegate debug?: :@logger
+
+        def initialize(logger)
+          @logger = logger
+        end
+
+        def getLog(_name)
+          self
+        end
+        alias get_log getLog
+
+        def error(*args) = log(::Logger::ERROR, *args)
+
+        def info(*args) = log(::Logger::INFO, *args)
+
+        def warn(*args) = log(::Logger::WARN, *args)
+
+        def debug(*args) = log(::Logger::DEBUG, *args)
+        alias trace debug
+
+        def trace_enabled?
+          debug?
+        end
+
+        def debug_enabled
+          debug?
+        end
+
+        private
+
+        def log(level, *args)
+          @logger.add(level) { format(*args) }
+        end
+
+        def format(message, *args)
+          return message.to_s if args.empty? && !message.is_a?(java.lang.Throwable)
+          args.unshift(message)
+          args.unshift('%s%n%s') if args.last.is_a?(java.lang.Throwable)
+          java.lang.String.format(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module MapConverter
+        include PlainMapConverter
+
+        def to_h = java_method(:asMap, [java.util.function.Function]).call(&:itself).as_ruby_object
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module NeoConverter
+        private
+
+        def to_neo(object, skip_unknown: false)
+          case object
+          when Hash
+            object.map { |key, value| [key.to_s, to_neo(value)] }.to_h
+          when Types::Path
+            Exceptions::ClientException.unable_to_convert(object)
+          when Enumerable
+            object.map(&method(:to_neo))
+          when Types::UUID # native java.util.UUID; Values.value accepts it
+            object
+          when String
+            object.encoding == Encoding::BINARY ? object.to_java_bytes : object
+          when Types::Duration
+            Java::OrgNeo4jDriverInternal::InternalIsoDuration.new(object.months, object.days, object.seconds,
+                                                                  object.nanoseconds)
+          when Types::Point
+            Java::OrgNeo4jDriver::Values.point(object.srid, *object.coordinates)
+          when Types::OffsetTime
+            Java::JavaTime::OffsetTime.of(Java::JavaTime::LocalTime.of_nano_of_day(object.nanoseconds),
+                                          Java::JavaTime::ZoneOffset.of_total_seconds(object.tz_offset_seconds))
+          when Types::LocalTime
+            Java::JavaTime::LocalTime.of_nano_of_day(object.nanoseconds)
+          when Types::LocalDateTime
+            Java::JavaTime::LocalDateTime.of_epoch_second(object.epoch_seconds, object.nanoseconds,
+                                                          Java::JavaTime::ZoneOffset::UTC)
+          when defined?(ActiveSupport::TimeWithZone) && ActiveSupport::TimeWithZone
+            to_zoned_date_time(object, object.time_zone.tzinfo.identifier)
+          when Time, DateTime
+            to_zoned_date_time(object, zone_identifier_for(object))
+          when Date
+            Java::JavaTime::LocalDate.of(object.year, object.month, object.day)
+          when Symbol
+            object.to_s
+          when nil, true, false, Integer, Float
+            object
+          else
+            if skip_unknown
+              object
+            else
+              raise Exceptions::ClientException.unable_to_convert(object)
+            end
+          end
+        end
+
+        def to_zoned_date_time(object, zone)
+          # Build from the instant, not the wall-clock fields: during a DST
+          # fall-back the local time is ambiguous and ZonedDateTime.of(...)
+          # would silently pick the earlier offset, dropping the object's
+          # actual offset. ofInstant keeps the real instant (and is identical
+          # for non-ambiguous times). Use to_i/nsec (the UTC instant) rather
+          # than to_time, which triggers an ActiveSupport localtime path.
+          instant = Java::JavaTime::Instant.of_epoch_second(object.to_i, object.nsec)
+          Java::JavaTime::ZonedDateTime.of_instant(instant, Java::JavaTime::ZoneId.of(zone))
+        end
+
+        def zone_identifier_for(time)
+          zone = time.zone
+          zone.respond_to?(:identifier) ? zone.identifier : time.formatted_offset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module PlainMapConverter
+        def as_ruby_object = to_h.transform_values!(&:as_ruby_object).transform_keys!(&:to_sym)
+      end
+    end
+  end
+end

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

@@ -16,20 +16,25 @@ module Neo4j
             date = as_local_date
             Date.new(date.year, date.month_value, date.day_of_month)
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::DURATION
-            Driver::Internal::DurationNormalizer.create(*%i[months days seconds nanoseconds].map(&as_object.method(:send)))
+            Types::Duration.new(*%i[months days seconds nanoseconds].map(&as_object.method(:send)))
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::POINT
             point = as_point
             Types::Point.new(srid: point.srid, x: point.x, y: point.y, z: nullable(point.z))
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::BYTES
             String.from_java_bytes(as_byte_array).force_encoding(Encoding::BINARY)
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::TIME
-            Types::OffsetTime.parse(as_offset_time.to_string)
+            Types::OffsetTime.new(as_offset_time.to_local_time.to_nano_of_day, as_offset_time.offset.total_seconds)
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LOCAL_TIME
-            Types::LocalTime.parse(as_local_time.to_string)
+            Types::LocalTime.new(as_local_time.to_nano_of_day)
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LOCAL_DATE_TIME
-            Types::LocalDateTime.parse(as_local_date_time.to_string)
+            Types::LocalDateTime.new(as_local_date_time.to_epoch_second(Java::JavaTime::ZoneOffset::UTC),
+                                     as_local_date_time.nano)
           when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::DATE_TIME
             to_time
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::UUID
+            # Bolt 6.1 UUID -> native java.util.UUID (Types::UUID on JRuby).
+            # asObject would raise Uncoercible (UUID is not a string).
+            as_uuid
           else
             as_object
           end
@@ -44,8 +49,17 @@ module Neo4j
             Time.parse(time.to_string)
           else
             instant = time.to_instant
-            Time.at(instant.epoch_second, instant.nano, :nsec).in_time_zone(TZInfo::Timezone.get(zone_id))
+            Time.at(instant.epoch_second, instant.nano, :nsec, in: TZInfo::Timezone.get(zone_id))
           end
+        rescue Java::JavaTime::DateTimeException => e
+          # The server sent a zoned datetime whose zone the driver can't
+          # resolve (e.g. an unknown tz id); the Java value defers the
+          # failure to access time. Surface it as a driver exception
+          # (preserving the zone id in the message) instead of leaking the
+          # raw Java exception. cause: nil so the managed-tx reverse_check
+          # doesn't unwrap to (and re-raise) the raw Java DateTimeException,
+          # which the retry logic can't map back to a driver exception.
+          raise Exceptions::ClientException.new(e.message), cause: nil
         end
 
         def nullable(double)

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      # Java's UnsupportedType#message returns an Optional<String>; unwrap it to
+      # a nil-or-String so the public API matches MRI's UnsupportedType, which
+      # stores a plain nilable message.
+      module UnsupportedType
+        def message = super.or_else(nil)
+      end
+    end
+  end
+end

data/lib/neo4j/driver/internal/deprecator.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 module Neo4j
   module Driver
     module Internal
       module Deprecator
-        def self.deprecator
-          @deprecator ||= ActiveSupport::Deprecation.new('6.0', 'neo4j-ruby-driver')
-        end
+        class << self
+          def deprecator
+            self
+          end
 
-        def self.log_warning(old_method, new_method, version)
-          deprecator.deprecation_warning(old_method, new_method)
+          def behavior=(value)
+            # No-op for now
+          end
         end
       end
     end

data/lib/neo4j/driver/internal/duration_normalizer.rb

@@ -4,47 +4,20 @@ module Neo4j
   module Driver
     module Internal
       module DurationNormalizer
-        class << self
-          def normalize(object)
-            parts = object.parts.to_h
-            parts.default = 0
-            months_i, months_remainder_seconds = divmod(months(parts), ActiveSupport::Duration::SECONDS_PER_MONTH)
-            months_days, months_remainder_seconds =
-              months_remainder_seconds.divmod(ActiveSupport::Duration::SECONDS_PER_DAY)
-            days_i, days_remainder_seconds = divmod(months_days + days(parts), ActiveSupport::Duration::SECONDS_PER_DAY)
-            seconds_i, nonanoseconds = divmod(months_remainder_seconds + days_remainder_seconds + seconds(parts),
-                                              1_000_000_000)
-            [months_i, days_i, seconds_i, nonanoseconds.round]
-          end
-
-          def milliseconds(duration)
-            duration&.in_milliseconds&.round
-          end
-
-          def create(months, days, seconds, nanoseconds)
-            { months:, days:, seconds: seconds + (nanoseconds.zero? ? 0 : nanoseconds * BigDecimal('1e-9')) }
-              .sum { |key, value| ActiveSupport::Duration.send(key, value) }
-          end
-
-          private
-
-          def divmod(number, factor)
-            number_i, remainder = number.divmod(1)
-            [number_i.to_i, remainder * factor]
-          end
-
-          def months(parts)
-            parts[:years] * 12 + parts[:months]
-          end
-
-          def days(parts)
-            parts[:weeks] * 7 + parts[:days]
-          end
-
-          def seconds(parts)
-            parts[:hours] * ActiveSupport::Duration::SECONDS_PER_HOUR +
-              parts[:minutes] * ActiveSupport::Duration::SECONDS_PER_MINUTE + parts[:seconds]
-          end
+        # Convert timeout from seconds (or ActiveSupport::Duration) to
+        # milliseconds for the Bolt protocol. A negative timeout is
+        # invalid — reject it client-side (matches Java, which raises
+        # rather than sending a negative tx_timeout to the server).
+        def timeout_to_milliseconds(timeout)
+          return if timeout.nil?
+
+          # Check the sign before rounding: a tiny negative timeout
+          # (e.g. -0.4ms) would otherwise round to 0 and slip through.
+          ms = timeout.to_f * 1000
+          raise Exceptions::ClientException,
+                "Transaction timeout must not be negative, but was #{ms}ms" if ms.negative?
+
+          ms.round
         end
       end
     end

data/lib/neo4j/driver/internal/internal_auth_token_manager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      # Auth-token manager: anything responding to
+      #
+      #   get_token                                   -> AuthToken
+      #   handle_security_exception(token, exception) -> Boolean
+      #
+      # is a manager. Pass an instance to `GraphDatabase.driver` via the
+      # `:auth_token_manager` kw arg and the driver will call back into
+      # it when it needs a fresh token or when the server rejects the
+      # current one.
+      #
+      # This concrete class is the Proc-based shortcut — supply two
+      # callables and you're done. Clients that need richer behaviour
+      # subclass and override the methods; the JRuby flavour's class
+      # additionally implements `org.neo4j.driver.AuthTokenManager`, so
+      # subclasses there automatically slot into the Java driver.
+      class InternalAuthTokenManager
+        def initialize(get_token:, handle_security_exception:)
+          @get_token = get_token
+          @handle_security_exception = handle_security_exception
+        end
+
+        def get_token
+          @get_token.call
+        end
+
+        def handle_security_exception(token, exception)
+          @handle_security_exception.call(token, exception)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/internal/validator.rb

@@ -19,6 +19,16 @@ module Neo4j
           obj
         end
 
+        # Matches Java's driver-side query-text validation (the JRuby
+        # flavour gets this for free from the Java driver). A Query
+        # object carries its own text, so only bare strings are checked.
+        def self.require_query_text!(query)
+          raise ArgumentError, 'Cypher query text should not be null' if query.nil?
+          raise ArgumentError, 'Cypher query text should not be an empty string' if query.is_a?(String) && query.strip.empty?
+
+          query
+        end
+
         def self.require_non_nil_credentials!(username, password)
           require_non_nil! username, "Username"
           require_non_nil! password, "Password"

data/lib/neo4j/driver/summary/query_type.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 module Neo4j
   module Driver
     module Summary
+      # Mirrors org.neo4j.driver.summary.QueryType — coarse classification
+      # of what a query did (read, write, both, or schema mutation).
       module QueryType
         READ_ONLY = 'r'
-        READ_WRITE = 'rw'
         WRITE_ONLY = 'w'
+        READ_WRITE = 'rw'
         SCHEMA_WRITE = 's'
       end
     end

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 = ($1 || 0).to_i
+          months = ($2 || 0).to_i
+          days = ($3 || 0).to_i
+          hours = ($4 || 0).to_i
+          minutes = ($5 || 0).to_i
+          seconds_with_fraction = ($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