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

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

@@ -3,17 +3,61 @@
 module Neo4j
   module Driver
     module Types
-      class LocalDateTime < Time
-        class << self
-          FIELDS = %i[year month day hour min sec nsec].freeze
+      # Bolt LocalDateTime — wall-clock datetime without timezone.
+      # Stored as the wire-format pair (epoch_seconds, nanoseconds), where
+      # epoch_seconds is the wall-clock components encoded as if they were
+      # UTC. Two LocalDateTimes representing the same wall-clock value
+      # always have the same field values regardless of the host TZ.
+      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)
+
+        def self.from_time(time)
+          new(time.to_i, ((time.to_f - time.to_i) * NANOS_PER_SECOND).round)
+        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 { |fmt| ::Time.strptime(naive, fmt) rescue nil }.first
+          raise ArgumentError, "Invalid LocalDateTime format: #{string}" unless time
+          from_time(::Time.utc(*time_components(time)))
         end
 
-        delegate(*significant_fields, to: :@time)
-        delegate :to_i, to: :@time
+        def self.time_components(time)
+          [time.year, time.month, time.day, time.hour, time.min, time.sec, time.subsec * 1_000_000]
+        end
+        private_class_method :time_components
+
+        def to_time
+          ::Time.at(@epoch_seconds, @nanoseconds.to_i, :nanosecond)
+        end
+
+        # Add a numeric or ActiveSupport::Duration. Sub-second precision
+        # preserved by going through to_f.
+        def +(seconds)
+          self.class.from_time(to_time + seconds.to_f)
+        end
+
+        def to_s
+          to_time.strftime('%Y-%m-%d %H:%M:%S.%N')
+        end
       end
     end
   end

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

@@ -3,16 +3,51 @@
 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)
+
+        # 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 +(seconds)
+          self.class.new(@nanoseconds + (seconds.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,80 @@
 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)
+
+        # 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
 
-        delegate(*significant_fields, to: :@time)
+        def self.parse_offset(str)
+          return 0 if str == 'Z'
+          raise ArgumentError, "Invalid timezone offset: #{str}" unless str =~ /^([+\-])(\d{2}):?(\d{2})?$/
+
+          sign = $1 == '+' ? 1 : -1
+          sign * ($2.to_i * 3600 + ($3 || 0).to_i * 60)
+        end
+        private_class_method :parse_offset
+
+        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 +(seconds)
+          self.class.new(@nanoseconds + (seconds.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,43 @@
+# 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.1.alpha.0'
+    VERSION = '6.2.1.beta.1'
   end
 end

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

@@ -1,22 +1,30 @@
 # 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'
 
     EagerResult = Java::OrgNeo4jDriverInternal::EagerResultValue
     Record = Java::OrgNeo4jDriverInternal::InternalRecord
     Result = Java::OrgNeo4jDriverInternal::InternalResult
-    Transaction = Java::OrgNeo4jDriverInternal::InternalTransaction
+    Transaction = Java::OrgNeo4jDriverInternal::DelegatingTransactionContext
 
     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::DelegatingTransactionContext
-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

data/lib/neo4j-ruby-driver_loader.rb

@@ -1,32 +1,46 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/isolated_execution_state' if Gem::Requirement.create('>= 7').satisfied_by?(Gem.loaded_specs["activesupport"].version) # TODO: this should not be necessary https://github.com/rails/rails/issues/43851
-require 'active_support/deprecator' if Gem::Requirement.create('>= 7.1').satisfied_by?(Gem.loaded_specs["activesupport"].version)
-require 'active_support/deprecation'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/duration'
-require 'active_support/time'
 require 'date'
+require 'forwardable'
+require 'time'
 require 'uri'
 require 'zeitwerk'
 
 module Neo4j
   module Driver
     class Loader
-      def self.load
-        loader = Zeitwerk::Loader.new
-        loader.tag = 'neo4j-ruby-driver'
-        loader.push_dir(File.expand_path(__dir__))
-        driver_specific_dir = File.dirname(File.dirname(caller_locations(1..1).first.path))
-        loader.push_dir(driver_specific_dir)
-        yield loader if block_given?
-        loader.ignore(File.expand_path('neo4j*ruby*driver*.rb', __dir__))
-        loader.ignore(File.expand_path('org', __dir__))
-        loader.inflector = Zeitwerk::GemInflector.new(File.expand_path('neo4j/driver', driver_specific_dir))
-        loader.setup
-        loader.eager_load
+      class << self
+        # `__dir__` resolves to:
+        #   dev:           lib/shared  → shared_root = lib/shared
+        #   installed gem: lib         → shared_root = lib (the impl dir is
+        #                                       merged in by the staged build, so
+        #                                       impl_root below is missing and the
+        #                                       conditional push is skipped)
+        def load(impl)
+          @impl = impl
+          shared_root = File.expand_path(__dir__)
+          impl_root = File.expand_path("../#{impl}", shared_root)
+
+          loader = Zeitwerk::Loader.new
+          loader.tag = 'neo4j-ruby-driver'
+          loader.inflector = Zeitwerk::GemInflector.new(File.expand_path('neo4j/driver', __dir__))
+          loader.inflector.inflect('packstream' => 'PackStream', 'uuid' => 'UUID')
+          loader.push_dir(shared_root)
+          loader.push_dir(impl_root) if File.directory?(impl_root)
+          yield loader if block_given?
+          # ignore the Bundler.require-friendly entry files (neo4j-ruby-driver.rb, neo4j-ruby-driver_loader.rb,
+          # neo4j_ruby_driver.rb) since Zeitwerk would otherwise try to
+          # autoload them as constants with the wrong names.
+          loader.ignore(File.expand_path(__FILE__))
+          loader.ignore(File.expand_path('neo4j-ruby-driver.rb', __dir__))
+          loader.ignore(File.expand_path('neo4j_ruby_driver.rb', __dir__))
+          loader.setup
+          loader.eager_load
+        end
+
+        def jruby? = @impl == :jruby
+
+        def mri? = @impl == :mri
       end
     end
   end