neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

data/jruby/neo4j/driver/ext/exception_checkable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionCheckable
+        include ExceptionMapper
+
+        def check
+          yield
+        rescue Java::JavaLang::RuntimeException => e
+          raise mapped_exception(e)
+        end
+
+        def reverse_check
+          yield
+        rescue Neo4j::Driver::Exceptions::ServiceUnavailableException => e
+          raise(throwable(e.cause) || Java::OrgNeo4jDriverExceptions::ServiceUnavailableException.new(e.message))
+        rescue Neo4j::Driver::Exceptions::Neo4jException,
+          Neo4j::Driver::Exceptions::NoSuchRecordException,
+          Neo4j::Driver::Exceptions::UntrustedServerException,
+          Neo4j::Driver::Exceptions::IllegalStateException => e
+          raise(throwable(e.cause) || e)
+        end
+
+        private
+
+        def throwable(e)
+          e if e.is_a? Java::JavaLang::Throwable
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/exception_mapper.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionMapper
+        java_import org.neo4j.driver.exceptions.AuthenticationException
+        java_import org.neo4j.driver.exceptions.AuthorizationExpiredException
+        java_import org.neo4j.driver.exceptions.ClientException
+        java_import org.neo4j.driver.exceptions.ConnectionReadTimeoutException
+        java_import org.neo4j.driver.exceptions.DatabaseException
+        java_import org.neo4j.driver.exceptions.DiscoveryException
+        java_import org.neo4j.driver.exceptions.FatalDiscoveryException
+        java_import org.neo4j.driver.exceptions.ProtocolException
+        java_import org.neo4j.driver.exceptions.ResultConsumedException
+        java_import org.neo4j.driver.exceptions.SecurityException
+        java_import org.neo4j.driver.exceptions.ServiceUnavailableException
+        java_import org.neo4j.driver.exceptions.SessionExpiredException
+        java_import org.neo4j.driver.exceptions.TokenExpiredException
+        java_import org.neo4j.driver.exceptions.TransactionNestingException
+        java_import org.neo4j.driver.exceptions.TransientException
+        java_import org.neo4j.driver.exceptions.UnsupportedFeatureException
+        java_import org.neo4j.driver.exceptions.UntrustedServerException
+
+        def mapped_exception(exception)
+          mapped_neo4j_exception_class(exception)&.new(*arguments(exception)) ||
+            mapped_runtime_exception_class(exception)&.new(exception.message) || exception
+        end
+
+        def arguments(e)
+          [e.code, e.message, *e.suppressed.map(&method(:mapped_exception))]
+        end
+
+        private
+
+        def mapped_neo4j_exception_class(exception_class)
+          case exception_class
+          when AuthenticationException
+            Neo4j::Driver::Exceptions::AuthenticationException
+          when AuthorizationExpiredException
+            Neo4j::Driver::Exceptions::AuthorizationExpiredException
+          when FatalDiscoveryException
+            Neo4j::Driver::Exceptions::FatalDiscoveryException
+          when ResultConsumedException
+            Neo4j::Driver::Exceptions::ResultConsumedException
+          when TokenExpiredException
+            Neo4j::Driver::Exceptions::TokenExpiredException
+          when SecurityException
+            Neo4j::Driver::Exceptions::SecurityException
+          when TransactionNestingException
+            Neo4j::Driver::Exceptions::TransactionNestingException
+          when UnsupportedFeatureException
+            Neo4j::Driver::Exceptions::UnsupportedFeatureException
+          when ClientException
+            Neo4j::Driver::Exceptions::ClientException
+          when ConnectionReadTimeoutException
+            Neo4j::Driver::Exceptions::ConnectionReadTimeoutException
+          when DatabaseException
+            Neo4j::Driver::Exceptions::DatabaseException
+          when DiscoveryException
+            Neo4j::Driver::Exceptions::DiscoveryException
+          when ProtocolException
+            Neo4j::Driver::Exceptions::ProtocolException
+          when ServiceUnavailableException
+            Neo4j::Driver::Exceptions::ServiceUnavailableException
+          when SessionExpiredException
+            Neo4j::Driver::Exceptions::SessionExpiredException
+          when TransientException
+            Neo4j::Driver::Exceptions::TransientException
+          else
+            nil
+          end
+        end
+
+        def mapped_runtime_exception_class(exception_class)
+          case exception_class
+          when Java::OrgNeo4jDriverExceptions::NoSuchRecordException
+            Neo4j::Driver::Exceptions::NoSuchRecordException
+          when Java::OrgNeo4jDriverExceptions::UntrustedServerException
+            Neo4j::Driver::Exceptions::UntrustedServerException
+          when Java::JavaLang::IllegalStateException
+            Neo4j::Driver::Exceptions::IllegalStateException
+          when Java::JavaLang::IllegalArgumentException
+            ArgumentError
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/graph_database.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module GraphDatabase
+        extend AutoCloseable
+        include ConfigConverter
+        include ExceptionCheckable
+
+        auto_closeable :driver
+
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, **config)
+          check do
+            java_method(:driver, [java.lang.String, org.neo4j.driver.AuthToken, org.neo4j.driver.Config])
+              .call(uri.to_s, auth_token, to_java_config(Neo4j::Driver::Config, **config))
+          end
+        end
+
+        def internal_driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, **config, &domain_name_resolver)
+          check do
+            java_uri = java.net.URI.create(uri.to_s)
+            java_config = to_java_config(Neo4j::Driver::Config, **config)
+            Internal::DriverFactory
+              .new(&domain_name_resolver)
+              .new_instance(java_uri, org.neo4j.driver.internal.security.StaticAuthTokenManager.new(auth_token),
+                            java_config)
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/abstract_query_runner.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module AbstractQueryRunner
+          include ExceptionCheckable
+          include RunOverride
+
+          def run(statement, **parameters)
+            check { super(to_statement(statement, parameters)) }
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/async/internal_async_session.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Async
+          module InternalAsyncSession
+            include ConfigConverter
+            include RunOverride
+            include AsyncConverter
+
+            def run_async(statement, parameters = {}, config = {})
+              to_future(
+                java_method(:runAsync, [org.neo4j.driver.Query, org.neo4j.driver.TransactionConfig])
+                  .call(to_statement(statement, parameters), to_java_config(Neo4j::Driver::TransactionConfig, **config)))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/cluster/routing_table_registry_impl.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Ext
+  module Internal
+    module Cluster
+      module RoutingTableRegistryImpl
+        def routing_table_handler(database)
+          get_routing_table_handler(org.neo4j.driver.internal.bolt.api.DatabaseName.database(database)).then do |it|
+            it.get if it.present?
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/cursor/disposable_async_result_cursor.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Ext
+  module Internal
+    module Cursor
+      module DisposableAsyncResultCursor
+        include AsyncConverter
+
+        def next_async
+          to_future(super)
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/driver_factory.rb

@@ -0,0 +1,24 @@
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        class DriverFactory < org.neo4j.driver.internal.DriverFactory
+          def initialize(&domain_name_resolver)
+            super()
+            @domain_name_resolver = ->(name) do
+              domain_name_resolver.call(name).map do |addr|
+                java.net.InetAddress.get_by_name(addr)
+              rescue java.net.UnknownHostException => e
+                raise java.lang.RuntimeException.new(e)
+              end
+            end
+          end
+
+          def getDomainNameResolver
+            @domain_name_resolver
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/eager_result_value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module EagerResultValue
+          include InternalKeys
+
+          def records
+            super.to_a
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/metrics/internal_connection_pool_metrics.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Metrics
+          module InternalConnectionPoolMetrics
+            def address
+              java_class.declared_method('getAddress').tap { |m| m.accessible = true }.invoke(java_object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/summary/internal_notification.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          module InternalNotification
+            def severity_level
+              super.or_else(nil)
+            end
+
+            def raw_severity_level
+              super.or_else(nil)
+            end
+
+            def raw_category
+              super.or_else(nil)
+            end
+
+            def category
+              super.or_else(nil)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/summary/internal_plan.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          module InternalPlan
+            def args
+              arguments&.to_h&.transform_values(&:as_ruby_object)
+            end
+
+            def identifiers
+              super.to_a
+            end
+
+            # this part should probably be included in testkit-backend
+            def to_h
+              {operator_type:, args:, identifiers:, children: children&.map(&:to_h)}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          module InternalResultSummary
+            java_import org.neo4j.driver.summary.QueryType
+
+            %i[result_available_after result_consumed_after].each do |method|
+              define_method(method) do
+                super(Java::JavaUtilConcurrent::TimeUnit::MILLISECONDS).then { |val| val unless val == -1 }
+              end
+            end
+
+            def query_type
+              case super
+              when QueryType::READ_ONLY
+                Driver::Summary::QueryType::READ_ONLY
+              when QueryType::READ_WRITE
+                Driver::Summary::QueryType::READ_WRITE
+              when QueryType::WRITE_ONLY
+                Driver::Summary::QueryType::WRITE_ONLY
+              when QueryType::SCHEMA_WRITE
+                Driver::Summary::QueryType::SCHEMA_WRITE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalDriver
+        extend AutoCloseable
+        include ConfigConverter
+        include ExceptionCheckable
+        include AsyncConverter
+
+        auto_closeable :session
+
+        def execute_query(query, auth_token = nil, config = {}, **parameters)
+          check do
+            executable_query(query)
+              .with_auth_token(auth_token)
+              .with_config(to_java_config(Neo4j::Driver::QueryConfig, **config))
+              .with_parameters(to_neo(parameters))
+              .execute
+          end
+        end
+
+        def session(**session_config)
+          java_method(:session, [org.neo4j.driver.SessionConfig])
+            .call(to_java_config(Neo4j::Driver::SessionConfig, **session_config))
+        end
+
+        def async_session(**session_config)
+          java_method(:asyncSession, [org.neo4j.driver.SessionConfig])
+            .call(to_java_config(Neo4j::Driver::SessionConfig, **session_config))
+        end
+
+        def close_async
+          to_future(super)
+        end
+
+        def verify_connectivity
+          check { super }
+        end
+
+        def verify_authentication(auth_token)
+          check { super }
+        end
+
+        def supports_session_auth?
+          check { supports_session_auth }
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_entity.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalEntity
+        include MapConverter
+
+        alias properties to_h
+
+        def [](key)
+          get(key.to_s).as_ruby_object
+        end
+
+        def ==(other)
+          java_method(:isEqual).call(other)
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_keys.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalKeys
+        include ExceptionCheckable
+
+        def keys
+          check { super.map(&:to_sym) }
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalNode
+        def labels
+          super.map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_record.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalRecord
+        include MapConverter
+        include InternalKeys
+
+        def values
+          java_send(:values).map(&:as_ruby_object)
+        end
+
+        def [](key)
+          case key
+          when Integer
+            java_method(:get, [Java::int]).call(key)
+          else
+            java_method(:get, [java.lang.String]).call(key.to_s)
+          end.as_ruby_object
+        end
+
+        def first
+          java_method(:get, [Java::int]).call(0).as_ruby_object
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_relationship.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalRelationship
+        def type
+          super.to_sym
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalResult
+        include Enumerable
+        include ExceptionCheckable
+        include InternalKeys
+
+        %i[has_next? next single consume peek].each do |method|
+          define_method(method) do |*args, &block|
+            check { super(*args, &block) }
+          end
+        end
+
+        def each(&block)
+          check { stream.for_each(&block) }
+        end
+
+        def to_a
+          check { list.to_a }
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_session.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalSession
+        extend AutoCloseable
+        include ConfigConverter
+        include ExceptionCheckable
+        include RunOverride
+
+        auto_closeable :begin_transaction
+
+        # work around jruby issue https://github.com/jruby/jruby/issues/5603
+        Struct.new('Wrapper', :object)
+
+        %i[read write].each do |mode|
+          define_method("execute_#{mode}") do |**config, &block|
+            check do
+              super(->(tx) { Struct::Wrapper.new(reverse_check { block.call(tx) }) }, to_java_config(Neo4j::Driver::TransactionConfig, **config)).object
+            end
+          end
+        end
+
+        # end work around
+
+        def run(statement, parameters = {}, config = {})
+          check do
+            java_method(:run, [org.neo4j.driver.Query, org.neo4j.driver.TransactionConfig])
+              .call(to_statement(statement, parameters), to_java_config(Neo4j::Driver::TransactionConfig, **config))
+          end
+        end
+
+        def begin_transaction(**config)
+          check { super(to_java_config(Neo4j::Driver::TransactionConfig, **config)) }
+        end
+
+        def last_bookmarks
+          super.to_set
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_transaction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalTransaction
+        include Internal::AbstractQueryRunner
+
+        def commit
+          check { super }
+        end
+
+        def rollback
+          check { super }
+        end
+      end
+    end
+  end
+end