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

data/lib/neo4j/driver/transaction.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    # Represents an explicit transaction
+    class Transaction
+      attr_reader :connection
+
+      def initialize(connection, session, bookmarks = [], options = {}, telemetry_api: nil, telemetry_ack: nil,
+                     pipelined: false, on_begin: nil, on_release: nil)
+        @connection = connection
+        @session = session
+        @options = options
+        # executeQuery pipelines BEGIN + RUN + PULL (Optimization:ExecuteQueryPipelining):
+        # BEGIN's reply is read only after the first RUN+PULL are flushed, not eagerly.
+        @pipelined = pipelined
+        @on_begin = on_begin # called with the BEGIN reply (home-db cache update)
+        @on_release = on_release # called once when the connection is no longer needed
+        @open = true
+        @committed = false
+        @rolled_back = false
+        @failed = false
+        @terminating_error = nil # the classified error that terminated this tx (a RUN/commit failure)
+        @current_result = nil
+        # Every result opened in this tx, in order. Bolt lets multiple stay open
+        # and streaming concurrently (qid multiplexing); a new RUN no longer
+        # force-buffers the previous one, so we track them all here to discard
+        # any still-open at commit/rollback and to spot a mid-stream failure.
+        @open_results = []
+
+        # Begin the transaction
+        # Drop blank values so the serialised BEGIN map matches what
+        # testkit's stub scripts expect (e.g. `BEGIN {"db": "adb"}`,
+        # not `BEGIN {"db": "adb", "tx_metadata": {}}`).
+        begin_extra = {
+          bookmarks: bookmarks,
+          db: options[:database],
+          mode: options[:access_mode],
+          tx_timeout: options[:timeout],
+          tx_metadata: options[:metadata],
+          imp_user: options[:impersonated_user]
+        }
+        begin_extra.reject!(&Internal::Extras::BLANK)
+
+        # TELEMETRY (api = 0 managed / 1 explicit / 3 executeQuery) pipelined
+        # ahead of BEGIN when the server opted in and the driver didn't disable
+        # it; its SUCCESS is read first (see #ack_begin!).
+        @telemetry_sent = @connection.telemetry(telemetry_api, disabled: options[:telemetry_disabled])
+        @telemetry_ack = telemetry_ack
+        # Session-level NotificationsConfig rides on BEGIN (5.2+); the tx's own
+        # RUNs carry none. nil / pre-5.2 => no notification keys on the wire.
+        @connection.send_message(@connection.protocol.build_begin(begin_extra,
+                                                                  notification_config: options[:notification_config]))
+        @connection.flush
+
+        # Non-pipelined: read BEGIN's reply now, a plain round-trip (unchanged).
+        # Pipelined (executeQuery): defer it so the first #run can flush RUN+PULL
+        # before we block — a pipelining server withholds BEGIN's SUCCESS until it
+        # has all three. #ack_begin! drains it after that flush.
+        @begin_acked = false
+        ack_begin! unless @pipelined
+      rescue Exceptions::Neo4jException => e
+        # Classify first so the auth-token manager is notified and the
+        # connection is flagged for discard on an auth failure (the server
+        # closes it). BEGIN failed → server is in FAILED state; RESET to
+        # make it reusable, unless it's being discarded (a security
+        # failure: the server closes it and RESET would just error).
+        classified = @connection.classify_failure(e)
+        @connection.reset! unless @connection.auth_failed
+        @open = false
+        release_connection
+        raise classified
+      rescue StandardError
+        # Transport-level failure (IO/socket). RESET will likely fail
+        # too on a dead connection, but release the lease so it doesn't
+        # leak; pool reuse will surface the breakage to the next caller.
+        @open = false
+        release_connection
+        raise
+      end
+
+      def run(query, **parameters)
+        Internal::Validator.require_query_text!(query)
+        # A server failure terminated this transaction; further work is
+        # rejected locally (no wire traffic) as a TransactionTerminatedException
+        # — a ClientException subclass, matching the Java driver. Covers both a
+        # failed RUN (sets @failed) and a result that failed mid-stream during
+        # the user's own iteration (@current_result.failed?). Message wording
+        # stays "rolled back" to match the Java flavor (a shared integration spec
+        # asserts it on both impls); only the exception class becomes specific.
+        if terminated?
+          raise Exceptions::TransactionTerminatedException,
+                'Cannot run more queries in this transaction, it has been rolled back'
+        end
+        unless @open
+          # Mirror the Java/JRuby messages so the closed-state reason
+          # (committed vs rolled back) is reported the same on both impls.
+          raise Exceptions::ClientException,
+                "Cannot run more queries in this transaction, it has been #{@committed ? 'committed' : 'rolled back'}"
+        end
+
+        # A new query becomes current; the previous result must now name its qid
+        # explicitly on further PULL/DISCARD (the server defaults them to the last
+        # opened query). We keep it open and streaming rather than buffering it —
+        # that's the qid multiplexing the nested-result tests exercise.
+        @current_result&.demote!
+
+        fetch_size = effective_fetch_size
+
+        # send/flush are inside the begin block so a transport-level
+        # failure surfacing on fetch_response still sets @failed and
+        # goes through classify_failure. Connection#send_message and
+        # #flush both defer peer-closed errors so a buffered server
+        # FAILURE is read before fetch_response can raise its own
+        # EOF-driven ServiceUnavailableException — JRuby surfaces
+        # EPIPE eagerly, MRI tends to defer it naturally. Without
+        # this rescue placement, session.close's subsequent rollback
+        # path takes the ROLLBACK-message branch (rather than
+        # rollback_via_reset) and re-fails on the dead connection.
+        buffer = Bolt::RecordBuffer.new(fetch_size: fetch_size)
+        handler = Bolt::StreamHandler.new(buffer)
+        run_response =
+          begin
+            @connection.send_message(@connection.protocol.build_run(query, parameters, {}))
+            @connection.send_message(@connection.protocol.build_pull(n: fetch_size), handler)
+            @connection.flush
+            # Drain the pipelined BEGIN (+telemetry) reply now that RUN+PULL are on
+            # the wire — no-op unless this is the pipelined first run. A BEGIN that
+            # failed surfaces here and is handled as a run failure below; the tx
+            # then rolls back on its way out, resetting the connection.
+            ack_begin!
+            @connection.fetch_response.assert_success!
+          rescue Exceptions::Neo4jException => e
+            @failed = true
+            # Remember the terminating error: sibling results still open must
+            # raise it (not pull) once this RUN fails — the connection is FAILED.
+            raise(@terminating_error = @connection.classify_failure(e))
+          end
+
+        keys = (run_response.metadata[:fields] || run_response.metadata['fields'] || []).map(&:to_sym)
+
+        @current_result = Result.new(@connection, keys, buffer: buffer, handler: handler,
+                                                        query_text: query, parameters: parameters,
+                                                        run_metadata: run_response.metadata, fetch_size: fetch_size,
+                                                        qid: run_response.metadata[:qid],
+                                                        terminated_error: method(:terminating_error))
+        @open_results << @current_result
+        @current_result
+      end
+
+      def commit
+        # Java/JRuby-aligned messages for the already-closed states.
+        raise Exceptions::ClientException, 'Can\'t commit, transaction has been committed' if @committed
+        raise Exceptions::ClientException, 'Can\'t commit, transaction has been rolled back' if @rolled_back
+        raise Exceptions::ClientException, 'Transaction is already closed' unless @open
+
+        if terminated?
+          rollback_via_reset
+          raise Exceptions::TransactionTerminatedException,
+                "Transaction can't be committed. It has been rolled back"
+        end
+
+        begin
+          discard_open_results
+        rescue Exceptions::Neo4jException
+          rollback_via_reset
+          raise
+        end
+
+        # send/flush inside the begin block — see Transaction#run for
+        # the rationale on JRuby vs MRI socket-write timing.
+        response =
+          begin
+            @connection.send_message(Bolt::Message.commit)
+            @connection.flush
+            @connection.fetch_response.assert_success!
+          rescue Exceptions::Neo4jException => e
+            @failed = true
+            # Classify first so a security failure flags the connection
+            # for discard before rollback_via_reset releases it.
+            classified = @connection.classify_failure(e)
+            rollback_via_reset
+            raise classified
+          end
+
+        @committed = true
+        @open = false
+
+        bookmarks = response.metadata[:bookmark]
+        @session.update_bookmarks(bookmarks) if bookmarks
+        release_connection
+      end
+
+      def rollback
+        raise Exceptions::ClientException, 'Transaction is already closed' unless @open
+
+        # A pipelined executeQuery tx whose query never ran (e.g. local validation
+        # failed before RUN/PULL were sent) left BEGIN's reply unread — and a
+        # pipelining server may withhold it until RUN/PULL arrive, which now never
+        # will. RESET rolls the tx back and drains any pending reply without a
+        # blocking read that could deadlock; there are no open results to discard.
+        return rollback_via_reset unless @begin_acked
+
+        # A terminated tx left the connection FAILED: don't drain open results
+        # (that would send PULL/DISCARD the server rejects) — just RESET.
+        if terminated?
+          rollback_via_reset
+          return
+        end
+
+        begin
+          discard_open_results
+        rescue Exceptions::Neo4jException
+          # Failures surfaced while draining a pending result are expected
+          # during rollback — the tx is being discarded anyway. @failed is
+          # set; RESET path below will clean up the connection.
+        end
+
+        if @failed
+          rollback_via_reset
+          return
+        end
+
+        begin
+          @connection.send_message(Bolt::Message.rollback)
+          @connection.flush
+          @connection.fetch_response.assert_success!
+        rescue Exceptions::ServiceUnavailableException, Exceptions::SessionExpiredException
+          # Rolling back on a broken/dead connection is a no-op — the
+          # server discards the tx when the link dies. Swallow these so
+          # session.close's rollback path stays clean.
+        rescue Exceptions::Neo4jException => e
+          # A server FAILURE on ROLLBACK (e.g. DatabaseUnavailable) is a
+          # real error: the connection is now in FAILED state. RESET it
+          # back to READY, then surface the failure through the routing
+          # classifier — same as commit/run — so routing side effects
+          # (e.g. deactivate on DatabaseUnavailable) fire and the surfaced
+          # type is consistent. No-op for direct connections.
+          @connection.reset!
+          raise @connection.classify_failure(e)
+        ensure
+          @rolled_back = true
+          @open = false
+          release_connection
+        end
+      end
+
+      def close
+        rollback if @open && !@committed
+      end
+
+      def open?
+        @open
+      end
+
+      def failed?
+        @failed
+      end
+
+      private
+
+      # Read the deferred BEGIN acknowledgement (and the telemetry SUCCESS
+      # pipelined ahead of it). Idempotent: called once — eagerly in #initialize
+      # for a normal tx, or after the first RUN+PULL flush for a pipelined
+      # executeQuery (and defensively before ROLLBACK if that query never ran).
+      def ack_begin!
+        return if @begin_acked
+
+        @begin_acked = true
+
+        if @telemetry_sent
+          @connection.fetch_response.assert_success!
+          # The server acknowledged telemetry; a managed-tx retry won't re-send it.
+          @telemetry_ack&.call
+        end
+        begin_response = @connection.fetch_response.assert_success!
+        # A home-db BEGIN that sent db=nil comes back with the resolved name.
+        @on_begin&.call(begin_response)
+        begin_response
+      end
+
+      # The transaction is terminated once a server failure has hit it — either
+      # a tx method caught it (@failed) or any open result failed during the
+      # user's own iteration (its failure hasn't passed through a tx method).
+      def terminated? = @failed || @open_results.any?(&:failed?)
+
+      # The error that terminated this tx, or nil. A RUN/commit failure records
+      # it directly; a result that failed mid-iteration (the user's own PULL)
+      # carries it on the result. Passed to each result as its terminated_error
+      # so a sibling raises it instead of pulling on a FAILED connection.
+      def terminating_error = @terminating_error || @open_results.find(&:failed?)&.failure
+
+      # See Session#effective_fetch_size. Transactions inherit the session
+      # options at open, so the same default rules apply.
+      def effective_fetch_size
+        size = @options[:fetch_size]
+        size.nil? ? 1000 : size
+      end
+
+      # At tx end (commit/rollback) every still-open result goes out of scope,
+      # so discard each — DISCARD abandons remaining records (essential when a
+      # result is unbounded) rather than streaming them into memory, and leaves
+      # each raising ResultConsumedException on later access. Demoted results
+      # DISCARD by their qid; the current one omits it (targets the last query).
+      def discard_open_results
+        @open_results.each do |result|
+          begin
+            result.consume
+          rescue Exceptions::Neo4jException => e
+            @failed = true
+            # A wire error during PULL streaming (e.g. a reader connection
+            # interrupted mid-stream) raises ServiceUnavailable straight from
+            # fetch_response, not via Result#on_failure — so it never saw the
+            # routing classifier. Run it through here so a routed connection
+            # failure surfaces as SessionExpired (idempotent if already classified).
+            raise @connection.classify_failure(e)
+          end
+
+          # consume is a no-op when the result was already drained by the user;
+          # surface any stored failure so callers can react.
+          @failed = true if result.failed?
+        end
+      end
+
+      # Recover a failed transaction by asking the server to RESET the
+      # connection. RESET transitions the server from FAILED back to READY
+      # and implicitly rolls back the open transaction.
+      def rollback_via_reset
+        # Skip RESET on a connection being discarded (auth failure: the
+        # server closes it, RESET would just error); release then honors
+        # the discard flag so it isn't pooled.
+        @connection.reset! unless @connection.auth_failed
+        @rolled_back = true
+        @open = false
+        release_connection
+      end
+
+      def release_connection
+        @on_release&.call
+        @on_release = nil # idempotent
+      end
+    end
+  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 = (::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/entity.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Base for graph entities — a Node or a Relationship. Holds the shared
+      # identity (id / element_id) and property map, mirroring
+      # org.neo4j.driver.types.Entity, which the JRuby flavour exposes as
+      # Types::Entity. Kept as a real superclass (not just to de-duplicate
+      # Node/Relationship) because downstream gems and applications type-check
+      # against Neo4j::Driver::Types::Entity.
+      class Entity
+        attr_reader :id, :element_id, :properties
+
+        # element_id defaults to the stringified id — the Bolt 4.x wire carries
+        # no element_id, and callers always expect a value (matches Java).
+        def initialize(id, properties, element_id = nil)
+          @id = id
+          @properties = properties
+          @element_id = element_id || id.to_s
+        end
+
+        # Property lookup. PackStream hydration symbolizes every map key
+        # (Unpacker#unpack_map), so properties are symbol-keyed. Coerce the key
+        # so a string caller works too — the Java flavour accepts strings.
+        def [](key) = @properties[key.to_sym]
+
+        # Entities compare by identity within their own type (a Node is never
+        # equal to a Relationship), matching the Java driver. eql?/hash track
+        # == so entities work as Hash/Set keys.
+        def ==(other)
+          other.is_a?(self.class) && other.id == @id
+        end
+        alias eql? ==
+
+        def hash = @id.hash
+      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/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Represents a Node in the Neo4j graph. Mirrors
+      # org.neo4j.driver.types.Node — an Entity with a set of labels.
+      class Node < Entity
+        attr_reader :labels
+
+        def initialize(id, labels, properties, element_id = nil)
+          super(id, properties, element_id)
+          @labels = labels
+        end
+      end
+    end
+  end
+end