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

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

@@ -1,97 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    # Holds a host and port pair that denotes a Bolt server address.
-    class BoltServerAddress
-      attr_reader :host, :connection_host, :port
-      delegate :hash, to: :attributes
-
-      DEFAULT_PORT = 7687
-
-      class << self
-        def host_from(uri)
-          uri&.host || (raise invalid_address_format(uri))
-        end
-
-        def port_from(uri)
-          uri&.port || DEFAULT_PORT
-        end
-
-        def uri_from(address)
-          scheme_split = address.split('://')
-
-          if scheme_split.length == 1
-            # URI can't parse addresses without scheme, prepend fake "bolt://" to reuse the parsing facility
-            scheme = 'bolt://'
-            host_port = host_port_from(scheme_split.first)
-          elsif scheme_split.length == 2
-            scheme = "#{scheme_split.first}://"
-            host_port = host_port_from(scheme_split.second)
-          else
-            raise invalid_address_format(address)
-          end
-
-          URI(scheme + host_port)
-        end
-
-        def host_port_from(address)
-          # expected to be an IPv6 address like [::1] or [::1]:7687
-          return address if address.start_with?('[')
-
-          contains_single_colon = address.index(':') == address.rindex(':')
-
-          # expected to be an IPv4 address with or without port like 127.0.0.1 or 127.0.0.1:7687
-          return address if contains_single_colon
-
-          # address contains multiple colons and does not start with '['
-          # expected to be an IPv6 address without brackets
-          "[#{address}]"
-        end
-
-        def invalid_address_format(address)
-          ArgumentError.new("Invalid address format #{address}")
-        end
-
-        def require_valid_port(port)
-          return port if port >= 0 && port <= 65_535
-
-          raise ArgumentError, "Illegal port: #{port}"
-        end
-      end
-
-      def initialize(uri: nil, host: self.class.host_from(uri), port: self.class.port_from(uri), connection_host: host)
-        @host = Validator.require_non_nil!(host)
-        @connection_host = Validator.require_non_nil!(connection_host)
-        @port = self.class.require_valid_port(port)
-      end
-
-      LOCAL_DEFAULT = new(host: 'localhost', port: DEFAULT_PORT)
-
-      def self.from(address)
-        address.is_a?(BoltServerAddress) ? address : new(host: address.host, port: address.port)
-      end
-
-      def ==(other)
-        attributes == other&.attributes
-      end
-
-      alias eql? ==
-
-      def to_s
-        "#{host}#{"(#{connection_host})" unless host == connection_host}:#{port}"
-      end
-
-      # Create a stream of unicast addresses.
-      # <p>
-      # While this implementation just returns a stream of itself, the subclasses may provide multiple addresses.
-
-      # @return stream of unicast addresses.
-      def unicast_stream
-        Set[self]
-      end
-
-      def attributes
-        [@host, @connection_host, @port]
-      end
-    end
-  end
-end

data/lib/neo4j/driver/synchronizable.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Synchronizable
-      def sync(*methods)
-        prepend with_sync_wrapper(methods)
-      end
-
-      private
-
-      def with_sync_wrapper(methods)
-        Module.new do
-          methods.each do |method|
-            define_method(method) do |*args, **kwargs, &block|
-              Sync { super(*args, **kwargs, &block) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Types
-      class Time
-        include Comparable
-
-        delegate :hash, :to_a, to: :significant
-
-        class << self
-          def parse(date)
-            new(::Time.parse(date))
-          end
-        end
-
-        def initialize(time)
-          @time = time
-        end
-
-        def significant
-          self.class.significant_fields.map(&method(:send))
-        end
-
-        def <=>(other)
-          return unless other.is_a?(self.class)
-
-          self.class.significant_fields.reduce(0) do |acc, elem|
-            acc.zero? ? send(elem) <=> other.send(elem) : (break acc)
-          end
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem) == other.send(elem) }
-        end
-
-        alias eql? ==
-
-        def +(numeric)
-          self.class.new(@time + numeric)
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/auth_tokens.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class AuthTokens
-      class << self
-        def basic(username, password, realm = nil)
-          Internal::Validator.require_non_nil_credentials!(username, password)
-          Internal::Security::InternalAuthToken[
-            { scheme: 'basic', principal: username, credentials: password, realm: realm }.compact]
-        end
-
-        def bearer(token)
-          Internal::Validator.require_non_nil!(token, "Token")
-          Internal::Security::InternalAuthToken[scheme: 'bearer', credentials: token]
-        end
-
-        def kerberos(base64_encoded_ticket)
-          Internal::Validator.require_non_nil!(base64_encoded_ticket, "Ticket")
-          Internal::Security::InternalAuthToken[scheme: 'bearer', credentials: base64_encoded_ticket]
-        end
-
-        def custom(principal, credentials, realm, scheme, **parameters)
-          Internal::Security::InternalAuthToken[{ scheme: scheme, principal: principal, credentials: credentials,
-                                                  realm: realm, parameters: parameters.presence || nil }.compact]
-        end
-
-        def none
-          Internal::Security::InternalAuthToken[scheme: 'none']
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/bookmark.rb

@@ -1,21 +0,0 @@
-module Neo4j
-  module Driver
-    # Causal chaining is carried out by passing bookmarks between transactions.
-
-    # When starting a session with initial bookmarks, the first transaction will be ensured to run at least after
-    # the database is as up-to-date as the latest transaction referenced by the supplied bookmarks.
-
-    # Within a session, bookmark propagation is carried out automatically.
-    # Thus all transactions in a session (both managed and unmanaged) are guaranteed to be carried out one after another.
-
-    # To opt out of this mechanism for unrelated units of work, applications can use multiple sessions.
-    module Bookmark
-      # Reconstruct bookmark from \bookmarks string values.
-      # @param values values obtained from a previous bookmark.
-      # @return A bookmark.
-      def self.from(value)
-        Internal::InternalBookmark.new(value)
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/config.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class Config < Hash
-      class TrustStrategy
-        TRUST_ALL_CERTIFICATES = :trust_all_certificates
-        TRUST_CUSTOM_CA_SIGNED_CERTIFICATES = :trust_custom_certificates
-        TRUST_SYSTEM_CA_SIGNED_CERTIFICATES = :trust_system_certificates
-
-        attr_reader :strategy, :cert_files, :revocation_strategy
-
-        # Sample config:
-        # {
-        #   trust_strategy: {
-        #     strategy: :trust_custom_certificates,
-        #     cert_files: ['some_path', 'another_path'],
-        #     revocation_strategy: :no_checks, # or :verify_if_present, :strict
-        #     hostname_verification: true
-        #   },
-        #   encryption: true
-        # }
-        def initialize(**config)
-          @strategy = config[:strategy]
-          @cert_files = config[:cert_files]
-          @revocation_strategy = config[:revocation_strategy] || Neo4j::Driver::Internal::RevocationStrategy::NO_CHECKS
-          @hostname_verification_enabled = config[:hostname_verification] || false
-        end
-
-        def self.trust_all_certificates
-          new(trust_strategy: TRUST_ALL_CERTIFICATES)
-        end
-
-        def hostname_verification_enabled?
-          @hostname_verification_enabled
-        end
-      end
-
-      # Console.logger = ::Logger.new(STDOUT, level: :debug)
-      DEFAULTS = {
-        logger: ::Logger.new(nil),
-        # logger: ::Logger.new(STDOUT, level: :debug),
-        # logger: Console.logger,
-        leaked_sessions_logging: false,
-        max_connection_pool_size: Internal::Async::Pool::PoolSettings::DEFAULT_MAX_CONNECTION_POOL_SIZE,
-        idle_time_before_connection_test: Internal::Async::Pool::PoolSettings::DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST,
-        max_connection_lifetime: Internal::Async::Pool::PoolSettings::DEFAULT_MAX_CONNECTION_LIFETIME,
-        connection_acquisition_timeout: Internal::Async::Pool::PoolSettings::DEFAULT_CONNECTION_ACQUISITION_TIMEOUT,
-        routing_failure_limit: Internal::Cluster::RoutingSettings::DEFAULT.max_routing_failures,
-        routing_retry_delay: Internal::Cluster::RoutingSettings::DEFAULT.retry_timeout_delay,
-        routing_table_purge_delay: Internal::Cluster::RoutingSettings::DEFAULT.routing_table_purge_delay,
-        user_agent: "neo4j-ruby/#{Neo4j::Driver::VERSION}",
-        connection_timeout: 30.seconds,
-        driver_metrics: false,
-        fetch_size: Internal::Handlers::Pulln::FetchSizeUtil::DEFAULT_FETCH_SIZE,
-        event_loop_threads: 0,
-
-        # TODO: Still to cleanup
-        encryption: false, # :set_transport
-        keep_alive: true, # BoltSocketOptions_set_keep_alive
-        # connection_liveness_check_timeout: -1, # Not configured
-        max_transaction_retry_time: Internal::Retry::ExponentialBackoffRetryLogic::DEFAULT_MAX_RETRY_TIME,
-        metrics_enabled: false,
-        # resolver: nil # :set_address_resolver
-        trust_strategy: { strategy: :trust_all_certificates }
-      }.freeze
-
-      def initialize(**config)
-        merge!(DEFAULTS).merge!(config.compact)
-        init_security_and_trust_config
-      end
-
-      def routing_settings
-        Internal::Cluster::RoutingSettings.new(
-          *values_at(:routing_failure_limit, :routing_retry_delay, :routing_table_purge_delay))
-      end
-
-      private
-
-      def init_security_and_trust_config
-        relevant = %i[encryption trust_strategy]
-        customized = slice(*relevant) != DEFAULTS.slice(*relevant)
-        merge!(security_settings: Neo4j::Driver::Internal::SecuritySetting.new(
-          fetch(:encryption), TrustStrategy.new(**fetch(:trust_strategy)), customized),
-        )
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/graph_database.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver
-  class GraphDatabase
-    class << self
-      extend AutoCloseable
-      auto_closeable :driver, :routing_driver
-
-      def driver(uri, auth_token = nil, **config)
-        internal_driver(uri, auth_token, config)
-      end
-
-      def internal_driver(uri, auth_token, config, &domain_name_resolver)
-        uri = URI(uri)
-        config = Config.new(**config)
-
-        Internal::DriverFactory.new(&domain_name_resolver).new_instance(
-          uri,
-          auth_token || AuthTokens.none,
-          config.routing_settings,
-          config[:max_transaction_retry_time],
-          config,
-          config[:security_settings].create_security_plan(uri.scheme)
-        )
-      end
-
-      def routing_driver(routing_uris, auth_token, **config)
-        assert_routing_uris(routing_uris)
-        log = Config.new(**config)[:logger]
-
-        routing_uris.each do |uri|
-          driver = driver(uri, auth_token, **config)
-          begin
-            return driver.tap(&:verify_connectivity)
-          rescue Exceptions::ServiceUnavailableException => e
-            log.warn { "Unable to create routing driver for URI: #{uri}\n#{e}" }
-            close_driver(driver, uri, log)
-          rescue Exception => e
-            close_driver(driver, uri, log)
-            raise e
-          end
-        end
-
-        raise Exceptions::ServiceUnavailableException, 'Failed to discover an available server'
-      end
-
-      private
-
-      def bolt_version(version)
-        pad(version.split(/[.\-]/).map(&:to_i), 4).reverse
-      end
-
-      def ruby_version(bolt_version)
-        bolt_version.unpack('C*').reverse.map(&:to_s).join('.')
-      end
-
-      def bolt_versions(*versions)
-        pad(versions[0..3].map(&method(:bolt_version)).flatten, 16).pack('C*')
-      end
-
-      def pad(arr, n)
-        arr + [0] * [0, n - arr.size].max
-      end
-
-      def close_driver(driver, uri, log)
-        driver.close
-      rescue => close_error
-        log.warn { "Unable to close driver towards URI: #{uri}\n#{close_error}" }
-      end
-
-      def assert_routing_uris(uris)
-        uris.find { |uri| URI(uri).scheme != Neo4j::Driver::Internal::Scheme::NEO4J_URI_SCHEME }&.tap do |uri|
-          raise ArgumentError, "Illegal URI scheme, expected '#{Internal::Scheme::NEO4J_URI_SCHEME}' in '#{uri}'"
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/bolt_protocol_util.rb

@@ -1,51 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class BoltProtocolUtil
-          BOLT_MAGIC_PREAMBLE = 0x6060B017
-          NO_PROTOCOL_VERSION = Messaging::BoltProtocolVersion.new(0, 0)
-          CHUNK_HEADER_SIZE_BYTES = 2
-          DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = 2 ** 15 - 1
-          HANDSHAKE = [
-            BOLT_MAGIC_PREAMBLE,
-            Messaging::V5::BoltProtocolV5::VERSION.to_int,
-            Messaging::V44::BoltProtocolV44::VERSION.to_int_range(Messaging::V42::BoltProtocolV42::VERSION),
-            Messaging::V41::BoltProtocolV41::VERSION.to_int,
-            Messaging::V3::BoltProtocolV3::VERSION.to_int]
-          HANDSHAKE_BUF = HANDSHAKE.pack('N*').freeze
-
-          class << self
-            def handshake_buf
-              HANDSHAKE_BUF
-            end
-
-            def handshake_string
-              HANDSHAKE_STRING
-            end
-
-            def write_message_boundary(buf)
-              buf.write_short(0)
-            end
-
-            def write_empty_chunk_header(buf)
-              buf.write_short(0)
-            end
-
-            def write_chunk_header(buf, chunk_start_index, header_value)
-              buf.set_short(chunk_start_index, header_value)
-            end
-
-            private
-
-            def create_handshake_string
-              "[0x#{HANDSHAKE.first.to_s(16)}, %s, %s, %s, %s]" % HANDSHAKE[1, 4]
-            end
-          end
-
-          HANDSHAKE_STRING = create_handshake_string
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/bootstrap_factory.rb

@@ -1,22 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class BootstrapFactory
-          class << self
-            def new_bootstrap(thread_count: nil,
-                              event_loop_group: EventLoopGroupFactory.new_event_loop_group(thread_count))
-              # Ione::Io::IoReactor.new
-              # Io::Bootstrap.new.tap do |bootstrap|
-              #   bootstrap.group = event_loop_group
-              #   bootstrap.channel(EventLoopGroupFactory.channel_class)
-                # bootstrap.option(org.neo4j.driver.internal.shaded.io.netty.channel.ChannelOption::SO_KEEPALIVE, true)
-                # bootstrap.option(org.neo4j.driver.internal.shaded.io.netty.channel.ChannelOption::SO_REUSEADDR, true)
-              # end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_attributes.rb

@@ -1,31 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelAttributes < Hash
-          # CONNECTION_ID = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('connectionId')
-          # POOL_ID = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('poolId')
-          # PROTOCOL_VERSION = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('protocolVersion')
-          # SERVER_AGENT = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverAgent')
-          # ADDRESS = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverAddress')
-          # SERVER_VERSION = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverVersion')
-          # CREATION_TIMESTAMP = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('creationTimestamp')
-          # LAST_USED_TIMESTAMP = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('lastUsedTimestamp')
-          # MESSAGE_DISPATCHER = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('messageDispatcher')
-          # TERMINATION_REASON = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('terminationReason')
-          # AUTHORIZATION_STATE_LISTENER = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('authorizationStateListener')
-          # CONNECTION_READ_TIMEOUT = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('connectionReadTimeout')
-
-          UPDATABLE_KEYS = %i[last_used_timestamp authorization_state_listener]
-
-          def []=(key, value)
-            if !UPDATABLE_KEYS.include?(key) && key?(key)
-              raise Neo4j::Driver::Exceptions::IllegalStateException, "Unable to set #{key} because it is already set to #{self[key]}"
-            end
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_connected_listener.rb

@@ -1,32 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelConnectedListener < Struct.new(:address, :pipeline_builder, :handshake_completed_promise, :logger)
-          # include org.neo4j.driver.internal.shaded.io.netty.channel.ChannelFutureListener
-          def operationComplete(future)
-            channel = future.channel
-            log = Logging::ChannelActivityLogger.new(channel, logger, self.class)
-
-            if future.fulfilled?
-              log.debug("Channel #{channel} connected, initiating bolt handshake")
-
-              pipeline = channel.pipeline
-              pipeline.add_last(HandshakeHandler.new(pipeline_builder, handshake_completed_promise, logger))
-              log.debug("C: [Bolt Handshake] #{BoltProtocolUtil.handshake_string}")
-              channel.write_and_flush(BoltProtocolUtil.handshake_buf, channel.void_promise)
-            else
-              handshake_completed_promise.set_failure(self.class.database_unavailable_error(address, future.cause))
-            end
-          end
-
-          def self.database_unavailable_error(address, cause)
-            Neo4j::Driver::Exceptions::ServiceUnavailableException.new(
-              "Unable to connect to #{address}, ensure the database is running and that there is a working network connection to it.",
-              cause)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_connector_impl.rb

@@ -1,83 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelConnectorImpl
-          def initialize(connection_settings, security_plan, logger, clock, routing_context, pipeline_builder = ChannelPipelineBuilderImpl.new, &domain_name_resolver)
-            @user_agent = connection_settings.user_agent
-            @auth_token = self.class.require_valid_auth_token(connection_settings.auth_token)
-            @routing_context = routing_context
-            @connect_timeout_millis = connection_settings.connect_timeout_millis
-            @security_plan = Validator.require_non_nil!(security_plan)
-            @pipeline_builder = pipeline_builder
-            @logger = Validator.require_non_nil!(logger)
-            @clock = Validator.require_non_nil!(clock)
-            @domain_name_resolver = Validator.require_non_nil!(domain_name_resolver)
-          end
-
-          def connect(address)
-            socket_host = (@domain_name_resolver.call(address.connection_host).first.ip_address rescue nil) ||
-              bracketless(address.connection_host)
-
-            endpoint = ::Async::IO::Endpoint.tcp(socket_host, address.port)
-            if @security_plan.requires_encryption?
-              endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: @security_plan.ssl_context,
-                                                    hostname: address.host)
-            end
-            channel_connected = endpoint.connect
-
-            # install_channel_connected_listeners(address, channel_connected, handshake_completed)
-            # install_handshake_completed_listeners(handshake_completed, connection_initialized)
-
-            channel_connected
-          rescue Errno::ECONNREFUSED => e
-            raise Exceptions::ServiceUnavailableException, e.message
-          end
-
-          def initialize_channel(channel, protocol)
-            protocol.initialize_channel(channel, @user_agent, @auth_token, @routing_context)
-          end
-
-          private
-
-          def bracketless(host)
-            host.delete_prefix('[').delete_suffix(']')
-          end
-
-          def install_channel_connected_listeners(address, channel_connected, handshake_completed)
-            pipeline = channel_connected.channel.pipeline
-
-            # add timeout handler to the pipeline when channel is connected. it's needed to limit amount of time code
-            # spends in TLS and Bolt handshakes. prevents infinite waiting when database does not respond
-            channel_connected.add_listener { pipeline.add_first(Inbound::ConnectTimeoutHandler.new(@connect_timeout_millis)) }
-
-            # add listener that sends Bolt handshake bytes when channel is connected
-            channel_connected.add_listener(ChannelConnectedListener.new(address, @pipeline_builder, handshake_completed, @logger))
-          end
-
-          def install_handshake_completed_listeners(handshake_completed, connection_initialized)
-            pipeline = handshake_completed.channel.pipeline
-
-            # remove timeout handler from the pipeline once TLS and Bolt handshakes are completed. regular protocol
-            # messages will flow next and we do not want to have read timeout for them
-            handshake_completed.add_listener { pipeline.remove(Inbound::ConnectTimeoutHandler.java_class) }
-
-            # add listener that sends an INIT message. connection is now fully established. channel pipeline if fully
-            # set to send/receive messages for a selected protocol version
-            handshake_completed.add_listener(HandshakeCompletedListener.new(@user_agent, @auth_token, @routing_context, connection_initialized))
-          end
-
-          class << self
-            def require_valid_auth_token(token)
-              if token.is_a? Internal::Security::InternalAuthToken
-                token
-              else
-                raise Exceptions::ClientException, "Unknown authentication token, `#{token}`. Please use one of the supported tokens from `#{AuthTokens.class}`."
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_pipeline_builder_impl.rb

@@ -1,22 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelPipelineBuilderImpl
-          def build(message_format, pipeline, logger)
-            # inbound handlers
-            pipeline.add_last(Inbound::ChunkDecoder.new(logger))
-            pipeline.add_last(Inbound::MessageDecoder.new)
-            pipeline.add_last(Inbound::InboundMessageHandler.new(message_format, logger))
-
-            # outbound handlers
-            pipeline.add_last(Outbound::OutboundMessageHandler::NAME, Outbound::OutboundMessageHandler.new(message_format, logger))
-
-            # last one - error handler
-            pipeline.add_last(Inbound::ChannelErrorHandler.new(logger))
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/direct_connection.rb

@@ -1,30 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        # This is a connection used by {@link DirectConnectionProvider} to connect to a remote database.
-        class DirectConnection < Struct.new(:delegate, :database_name, :mode, :impersonated_user)
-          delegate *%i[enable_auto_read disable_auto_read reset open? release terminate_and_release server_agent
-          server_address server_version protocol flush], to: :delegate
-          alias connection delegate
-
-          def write(message1, handler1, message2 = nil, handler2 = nil)
-            if message2.present? && handler2.present?
-              delegate.write(message1, handler1, message2, handler2)
-            else
-              delegate.write(message1, handler1)
-            end
-          end
-
-          def write_and_flush(message1, handler1, message2 = nil, handler2 = nil)
-            if message2.present? && handler2.present?
-              delegate.write_and_flush(message1, handler1, message2, handler2)
-            else
-              delegate.write_and_flush(message1, handler1)
-            end
-          end
-        end
-      end
-    end
-  end
-end