neo4j-ruby-driver 6.2.1.beta.1 → 6.2.1.beta.2

data/lib/neo4j/driver/result.rb

@@ -18,8 +18,8 @@ module Neo4j
                      on_summary: nil, on_release: nil)
         @connection = connection
         @keys = keys
-        @buffer = buffer          # Bolt::RecordBuffer, filled by the reader
-        @handler = handler        # the StreamHandler registered for this result's PULLs
+        @buffer = buffer # Bolt::RecordBuffer, filled by the reader
+        @handler = handler # the StreamHandler registered for this result's PULLs
         @query_text = query_text
         @parameters = parameters
         @run_metadata = run_metadata
@@ -35,17 +35,17 @@ module Neo4j
         # leaves the connection FAILED, so more wire traffic is invalid. nil for
         # auto-commit results (no enclosing transaction).
         @terminated_error = terminated_error
-        @failure = nil    # this result's own classified stream failure, if any
-        @on_summary = on_summary  # called with the built Summary when the stream ends in SUCCESS
-        @on_release = on_release  # called once when the connection is no longer needed
-        @records = []       # records pulled into memory by #buffer (not by iteration)
+        @failure = nil # this result's own classified stream failure, if any
+        @on_summary = on_summary # called with the built Summary when the stream ends in SUCCESS
+        @on_release = on_release # called once when the connection is no longer needed
+        @records = [] # records pulled into memory by #buffer (not by iteration)
         @had_record = false # any RECORD arrived on this stream — drives the GQL outcome status
         @summary = nil
-        @consumed = false   # stream fully drained (terminal seen)
-        @discarded = false  # records explicitly released; further access raises
-        @failed = false     # stream ended with a server FAILURE; connection needs RESET
+        @consumed = false # stream fully drained (terminal seen)
+        @discarded = false # records explicitly released; further access raises
+        @failed = false # stream ended with a server FAILURE; connection needs RESET
         @cancelling = false # consume(): abandon the rest — DISCARD the next batch instead of PULL
-        @list_mode = false  # to_a/list: pull all remaining in one PULL {n: -1}, ignoring fetch_size
+        @list_mode = false # to_a/list: pull all remaining in one PULL {n: -1}, ignoring fetch_size
         @peeked_record = nil
       end
 
@@ -98,11 +98,11 @@ module Neo4j
         record
       end
 
-      def each(&block)
+      def each(&)
         raise Exceptions::ResultConsumedException if @discarded
         return to_enum(:each) unless block_given?
 
-        block.call(self.next) while has_next?
+        yield(self.next) while has_next?
       end
 
       def to_a

data/lib/neo4j/driver/routing/load_balancer.rb

@@ -40,9 +40,9 @@ module Neo4j
           @clock = clock
           @domain_name_resolver = domain_name_resolver
           @routing_context = parse_routing_context(uri)
-          @pools = {}                      # ServerAddress => ConnectionPool::TimedStack
-          @routing_tables = {}             # database (str or nil) => RoutingTable
-          @cursor = Hash.new(0)            # round-robin per (database, role)
+          @pools = {} # ServerAddress => ConnectionPool::TimedStack
+          @routing_tables = {} # database (str or nil) => RoutingTable
+          @cursor = Hash.new(0) # round-robin per (database, role)
           # Per-server authorization-expired generation counters (see
           # Connection#auth_epoch and Direct::ConnectionProvider). Bumped for a
           # server when one of its connections reports AuthorizationExpired, so
@@ -79,8 +79,8 @@ module Neo4j
           @ssr_lock.synchronize do
             if conn.ssr_enabled?
               @ssr_with -= 1 if @ssr_with.positive?
-            else
-              @ssr_without -= 1 if @ssr_without.positive?
+            elsif @ssr_without.positive?
+              @ssr_without -= 1
             end
           end
         end
@@ -193,7 +193,8 @@ module Neo4j
           # routing driver surfaced the wrong error type.
           raise Exceptions::IllegalStateException, 'Driver is closed' if @closed
 
-          resolved = ensure_routing_table_is_fresh(nil, :read, bookmarks: bookmarks, imp_user: imp_user, auth: auth).database
+          resolved = ensure_routing_table_is_fresh(nil, :read, bookmarks: bookmarks, imp_user: imp_user,
+                                                               auth: auth).database
           # Remember the authoritative name (Optimization:HomeDatabaseCache) so a
           # later same-identity session can guess it and skip discovery.
           cache_home_db(imp_user, auth, resolved)
@@ -236,7 +237,9 @@ module Neo4j
           # server to re-auth. Provider-side, so it runs regardless of who
           # owns the token; the manager notification is skipped for a
           # per-session identity.
-          @refresh_lock.synchronize { @auth_epochs[address] += 1 } if error.is_a?(Exceptions::AuthorizationExpiredException)
+          if error.is_a?(Exceptions::AuthorizationExpiredException)
+            @refresh_lock.synchronize { @auth_epochs[address] += 1 }
+          end
           return false if session_scoped
 
           @auth_manager.handle_security_exception(token, error)
@@ -316,7 +319,13 @@ module Neo4j
         def close
           @refresh_lock.synchronize do
             @closed = true
-            @pools.each_value { |pool| pool.shutdown { |conn| conn.close rescue nil } }
+            @pools.each_value do |pool|
+              pool.shutdown do |conn|
+                conn.close
+              rescue StandardError
+                nil
+              end
+            end
             @pools.clear
             @routing_tables.clear
           end
@@ -368,7 +377,11 @@ module Neo4j
           @refresh_lock.synchronize do
             @routing_tables.each_value { |table| table.forget(address) }
             pool = @pools.delete(address)
-            pool&.shutdown { |conn| conn.close rescue nil }
+            pool&.shutdown do |conn|
+              conn.close
+            rescue StandardError
+              nil
+            end
           end
         end
 
@@ -442,7 +455,7 @@ module Neo4j
           raise Exceptions::ServiceUnavailableException.new(
             "Unable to retrieve routing information for database #{database.inspect}: " \
             "tried #{errors.length} router(s) without success" \
-            "#{last ? " (last: #{last.message})" : ''}",
+            "#{" (last: #{last.message})" if last}",
             suppressed: errors
           )
         end
@@ -529,7 +542,11 @@ module Neo4j
             errors << e
             # Connection (if any) is presumed dead; deactivate tears
             # down the pool so the conn's `created` slot is reclaimed.
-            conn&.close rescue nil
+            begin
+              conn&.close
+            rescue StandardError
+              nil
+            end
             deactivate(router)
             nil
           rescue Exceptions::Neo4jException => e
@@ -674,7 +691,7 @@ module Neo4j
 
         def symbolize(value)
           case value
-          when Hash  then value.transform_keys(&:to_sym).transform_values { symbolize(it) }
+          when Hash then value.transform_keys(&:to_sym).transform_values { symbolize(it) }
           when Array then value.map { symbolize(it) }
           else value
           end
@@ -683,7 +700,6 @@ module Neo4j
         def max_pool_size
           @options[:max_connection_pool_size] || Driver::DEFAULT_MAX_POOL_SIZE
         end
-
       end
     end
   end

data/lib/neo4j/driver/routing/routing_table.rb

@@ -109,7 +109,7 @@ module Neo4j
 
         def servers_for(access_mode)
           case access_mode
-          when :read  then @readers
+          when :read then @readers
           when :write then @writers
           when :route then @routers
           else raise ArgumentError, "Unknown access mode: #{access_mode.inspect}"

data/lib/neo4j/driver/session.rb

@@ -10,6 +10,7 @@ module Neo4j
     # hold a connection — only its in-flight operation does.
     class Session
       include Internal::DurationNormalizer
+
       def initialize(connection_provider, options = {}, clock: Internal::Clock.new)
         @connection_provider = connection_provider
         @options = options
@@ -21,7 +22,7 @@ module Neo4j
         # The home database this session pinned after its first resolution
         # (Optimization:HomeDatabaseCache); nil until then / for explicit-db sessions.
         @pinned_database = nil
-        @used_guess = false  # whether an operation optimistically guessed the home db
+        @used_guess = false # whether an operation optimistically guessed the home db
         @bookmark_manager = options[:bookmark_manager]
         # The bookmark snapshot we sent on the most recent BEGIN — used
         # as `previous_bookmarks` when forwarding to the manager so it
@@ -31,12 +32,12 @@ module Neo4j
         @bookmarks_used_on_begin = nil
 
         # Initialize with provided bookmarks if any
-        if options[:bookmarks]
-          initial_bookmarks = options[:bookmarks]
-          initial_bookmarks = [initial_bookmarks] unless initial_bookmarks.is_a?(Enumerable)
-          initial_bookmarks.each do |bookmark|
-            @last_bookmarks << (bookmark.is_a?(Bookmark) ? bookmark : Bookmark.from(bookmark))
-          end
+        return unless options[:bookmarks]
+
+        initial_bookmarks = options[:bookmarks]
+        initial_bookmarks = [initial_bookmarks] unless initial_bookmarks.is_a?(Enumerable)
+        initial_bookmarks.each do |bookmark|
+          @last_bookmarks << (bookmark.is_a?(Bookmark) ? bookmark : Bookmark.from(bookmark))
         end
       end
 
@@ -50,7 +51,10 @@ module Neo4j
         end
 
         raise Exceptions::ClientException, 'Session is closed' unless @open
-        raise Exceptions::ClientException, 'You cannot run a query directly on a session while a transaction is open' if @transaction&.open?
+        if @transaction&.open?
+          raise Exceptions::ClientException,
+                'You cannot run a query directly on a session while a transaction is open'
+        end
 
         drain_current_result
 
@@ -90,7 +94,7 @@ module Neo4j
         retries_left = auto_commit_retries_enabled? ? 1 : 0
 
         buffer = handler = run_response = nil
-        telemetry_sent = false    # TELEMETRY 2 = auto-commit; sent once, never resent on a retry
+        telemetry_sent = false # TELEMETRY 2 = auto-commit; sent once, never resent on a retry
         telemetry_pending = false # its (opted-in) SUCCESS is still owed
         loop do
           # A fresh stream per attempt — a prior attempt's buffer saw the IGNORED.
@@ -160,10 +164,10 @@ module Neo4j
         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,
-          on_summary: method(:harvest_auto_commit_bookmark),
-          on_release: -> { @connection_provider.release(connection) }
+                            query_text: query, parameters: parameters, run_metadata: run_response.metadata,
+                            fetch_size: fetch_size,
+                            on_summary: method(:harvest_auto_commit_bookmark),
+                            on_release: -> { @connection_provider.release(connection) }
         )
       end
 
@@ -171,7 +175,7 @@ module Neo4j
         raise Exceptions::ClientException, 'Session is closed' unless @open
         if @transaction&.open?
           raise Exceptions::ClientException,
-                "You cannot begin a transaction on a session with an open transaction; either run from within the transaction or use a different session."
+                'You cannot begin a transaction on a session with an open transaction; either run from within the transaction or use a different session.'
         end
 
         drain_current_result
@@ -201,7 +205,7 @@ module Neo4j
             # tx.commit to persist changes (matches Java driver semantics).
             @transaction.rollback if @transaction.open?
             result
-          rescue => e
+          rescue StandardError => e
             @transaction.rollback if @transaction.open?
             raise e
           ensure
@@ -212,12 +216,12 @@ module Neo4j
         end
       end
 
-      def execute_read(timeout: nil, metadata: nil, &block)
-        execute_transaction(AccessMode::READ, timeout:, metadata:, &block)
+      def execute_read(timeout: nil, metadata: nil, &)
+        execute_transaction(AccessMode::READ, timeout:, metadata:, &)
       end
 
-      def execute_write(timeout: nil, metadata: nil, &block)
-        execute_transaction(AccessMode::WRITE, timeout:, metadata:, &block)
+      def execute_write(timeout: nil, metadata: nil, &)
+        execute_transaction(AccessMode::WRITE, timeout:, metadata:, &)
       end
 
       # Close any pending result by asking the server to abandon
@@ -232,7 +236,7 @@ module Neo4j
 
         pending_error = nil
         begin
-          @transaction&.close  # tx releases its own connection
+          @transaction&.close # tx releases its own connection
           if @current_result
             connection = @current_result.connection
             begin
@@ -244,7 +248,7 @@ module Neo4j
             # the server's FAILED state; RESET so the next borrower starts
             # from a clean READY state.
             connection.reset! if @current_result.failed?
-            @current_result.discard!  # idempotent; releases the connection
+            @current_result.discard! # idempotent; releases the connection
           end
         ensure
           @open = false
@@ -257,9 +261,7 @@ module Neo4j
         @open
       end
 
-      def last_bookmarks
-        @last_bookmarks
-      end
+      attr_reader :last_bookmarks
 
       def update_bookmarks(bookmarks)
         # Replace bookmarks (don't accumulate) — matches Java driver behavior.
@@ -447,19 +449,19 @@ module Neo4j
           result.buffer
         rescue Exceptions::Neo4jException
           connection.reset!
-          result.discard!  # idempotent; routes through Result#release_connection
+          result.discard! # idempotent; routes through Result#release_connection
           raise
         end
 
-        if result.failed?
-          connection.reset!
-          result.discard!
-        end
+        return unless result.failed?
+
+        connection.reset!
+        result.discard!
+
         # Successful drain: Result already released its connection from on_success.
       end
 
-
-      def execute_transaction(access_mode, timeout: nil, metadata: nil, &block)
+      def execute_transaction(access_mode, timeout: nil, metadata: nil, &)
         raise Exceptions::ClientException, 'Session is closed' unless @open
 
         # Drain any pending auto-commit result so its connection is released
@@ -495,55 +497,53 @@ module Neo4j
         ).compact
 
         loop do
-          begin
-            # api 0 = managed tx; execute_query's session overrides it to 3
-            # (DRIVER_EXECUTE_QUERY). nil once the server has acked the report.
-            telemetry_api = telemetry_acked ? nil : (@options[:telemetry_api] || 0)
-            return run_managed_transaction(op_mode, tx_options, telemetry_api, on_telemetry_ack, &block)
-          rescue Exceptions::ServiceUnavailableException, Exceptions::SessionExpiredException,
-                 Exceptions::TransientException,
-                 # AuthorizationExpired (server authz-cache expiry) is always
-                 # retryable; SecurityRetryableException is an auth failure the
-                 # token manager has flagged retryable (token refreshed) — both
-                 # warrant another attempt on a fresh connection/identity.
-                 Exceptions::AuthorizationExpiredException, Exceptions::SecurityRetryableException => e
-            errors << e
-
-            if @clock.realtime - start_time >= max_retry_time
-              # Retries exhausted — re-raise the LAST error with its real
-              # type (SessionExpired / Transient / ServiceUnavailable)
-              # rather than flattening everything to ServiceUnavailable;
-              # Java's transaction executor likewise rethrows the last
-              # error. testkit asserts on the type (e.g. a routed reader
-              # interruption must surface as SessionExpired), so the
-              # generic wrapper masked it. Earlier attempts ride along as
-              # suppressed.
-              e.add_suppressed(*errors[0...-1])
-              raise e
-            end
-
-            # Exponential backoff: 1s, 2s, 4s, ... matching Java driver defaults
-            sleep(2 ** (errors.size - 1))
+          # api 0 = managed tx; execute_query's session overrides it to 3
+          # (DRIVER_EXECUTE_QUERY). nil once the server has acked the report.
+          telemetry_api = telemetry_acked ? nil : (@options[:telemetry_api] || 0)
+          return run_managed_transaction(op_mode, tx_options, telemetry_api, on_telemetry_ack, &)
+        rescue Exceptions::ServiceUnavailableException, Exceptions::SessionExpiredException,
+               Exceptions::TransientException,
+               # AuthorizationExpired (server authz-cache expiry) is always
+               # retryable; SecurityRetryableException is an auth failure the
+               # token manager has flagged retryable (token refreshed) — both
+               # warrant another attempt on a fresh connection/identity.
+               Exceptions::AuthorizationExpiredException, Exceptions::SecurityRetryableException => e
+          errors << e
+
+          if @clock.realtime - start_time >= max_retry_time
+            # Retries exhausted — re-raise the LAST error with its real
+            # type (SessionExpired / Transient / ServiceUnavailable)
+            # rather than flattening everything to ServiceUnavailable;
+            # Java's transaction executor likewise rethrows the last
+            # error. testkit asserts on the type (e.g. a routed reader
+            # interruption must surface as SessionExpired), so the
+            # generic wrapper masked it. Earlier attempts ride along as
+            # suppressed.
+            e.add_suppressed(*errors[0...-1])
+            raise e
           end
+
+          # Exponential backoff: 1s, 2s, 4s, ... matching Java driver defaults
+          sleep(2**(errors.size - 1))
         end
       end
 
-      def run_managed_transaction(op_mode, tx_options, telemetry_api, on_telemetry_ack, &block)
+      def run_managed_transaction(op_mode, tx_options, telemetry_api, on_telemetry_ack, &)
         if @transaction&.open?
           raise Exceptions::ClientException,
-                "You cannot begin a transaction on a session with an open transaction"
+                'You cannot begin a transaction on a session with an open transaction'
         end
 
         # TELEMETRY 0 = managed transaction function; api is nil once acked so a
         # retry doesn't repeat it.
         @transaction = open_transaction(op_mode, tx_options, telemetry_api: telemetry_api,
-                                        telemetry_ack: on_telemetry_ack)
+                                                             telemetry_ack: on_telemetry_ack)
 
         begin
           result = yield @transaction
           @transaction.commit if @transaction.open?
           result
-        rescue => e
+        rescue StandardError => e
           @transaction.rollback if @transaction.open?
           raise e
         ensure
@@ -563,12 +563,14 @@ module Neo4j
         bookmarks = current_bookmarks_for_extra
         tx_options = tx_options.merge(database: begin_db).compact
         Transaction.new(connection, self, bookmarks, tx_options, telemetry_api: telemetry_api,
-                        telemetry_ack: telemetry_ack,
-                        # executeQuery's session reports telemetry api 3 (DRIVER_EXECUTE_QUERY);
-                        # only that path pipelines BEGIN + RUN + PULL (Optimization:ExecuteQueryPipelining).
-                        pipelined: @options[:telemetry_api] == 3,
-                        on_begin: method(:cache_home_db_from),
-                        on_release: -> { @connection_provider.release(connection) })
+                                                                 telemetry_ack: telemetry_ack,
+                                                                 # executeQuery's session reports telemetry api 3 (DRIVER_EXECUTE_QUERY);
+                                                                 # only that path pipelines BEGIN + RUN + PULL (Optimization:ExecuteQueryPipelining).
+                                                                 pipelined: @options[:telemetry_api] == 3,
+                                                                 on_begin: method(:cache_home_db_from),
+                                                                 on_release: lambda {
+                                                                   @connection_provider.release(connection)
+                                                                 })
       end
     end
   end

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

@@ -12,7 +12,7 @@ module Neo4j
           @name =
             case db_data
             when String then db_data
-            when Hash   then db_data[:name]
+            when Hash then db_data[:name]
             end
         end
 

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

@@ -16,7 +16,7 @@ module Neo4j
 
         # Alias args → arguments to match JRuby's InternalPlan#args helper,
         # so cross-flavour callers can use either name.
-        alias_method :args, :arguments
+        alias args arguments
       end
     end
   end

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

@@ -74,6 +74,7 @@ module Neo4j
 
         def plan
           return @plan if defined?(@plan)
+
           @plan =
             if @metadata[:plan]
               Plan.new(@metadata[:plan])
@@ -87,6 +88,7 @@ module Neo4j
 
         def profile
           return @profile if defined?(@profile)
+
           @profile = @metadata[:profile] ? Profile.new(@metadata[:profile]) : nil
         end
 

data/lib/neo4j/driver/transaction.rb

@@ -14,13 +14,13 @@ module Neo4j
         # 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
+        @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)
+        @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
@@ -88,8 +88,10 @@ module Neo4j
         # 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.
-        raise Exceptions::TransactionTerminatedException,
-              'Cannot run more queries in this transaction, it has been rolled back' if terminated?
+        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.
@@ -138,10 +140,10 @@ module Neo4j
         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))
+                                                        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
@@ -263,6 +265,7 @@ module Neo4j
       # executeQuery (and defensively before ROLLBACK if that query never ran).
       def ack_begin!
         return if @begin_acked
+
         @begin_acked = true
 
         if @telemetry_sent
@@ -334,7 +337,7 @@ module Neo4j
 
       def release_connection
         @on_release&.call
-        @on_release = nil  # idempotent
+        @on_release = nil # idempotent
       end
     end
   end

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

@@ -25,12 +25,12 @@ module Neo4j
             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
+          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

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