neo4j-core 6.1.6 → 7.0.0.alpha.1

data/lib/neo4j-embedded/embedded_transaction.rb

@@ -1,12 +1,11 @@
 module Neo4j
   module Embedded
-    class EmbeddedTransaction
+    class EmbeddedTransaction < Neo4j::Transaction::Base
       attr_reader :root_tx
-      include Neo4j::Transaction::Instance
 
-      def initialize(root_tx)
-        @root_tx = root_tx
-        register_instance
+      def initialize(session)
+        super
+        @root_tx = @session.begin_tx
       end
 
       def acquire_read_lock(entity)
@@ -17,11 +16,6 @@ module Neo4j
         @root_tx.acquire_write_lock(entity)
       end
 
-
-      def inspect
-        "EmbeddedTransaction [nested: #{@pushed_nested} failed?: #{failure?} active: #{Neo4j::Transaction.current == self}]"
-      end
-
       def delete
         @root_tx.failure
         @root_tx.close

data/lib/neo4j-server/cypher_node.rb

@@ -32,7 +32,7 @@ module Neo4j
       # (see Neo4j::Node#create_rel)
       def create_rel(type, other_node, props = nil)
         q = @session.query.match(:a, :b).where(a: {neo_id: neo_id}, b: {neo_id: other_node.neo_id})
-            .create("(a)-[r:`#{type}`]->(b)").break.set(r: props).return(r: :neo_id)
+                    .create("(a)-[r:`#{type}`]->(b)").break.set(r: props).return(r: :neo_id)
 
         id = @session._query_or_fail(q, true)
 
@@ -138,8 +138,8 @@ module Neo4j
         @session._query_or_fail(query, false)
       end
 
-      alias_method :delete, :del
-      alias_method :destroy, :del
+      alias delete del
+      alias destroy del
 
       # (see Neo4j::Node#exist?)
       def exist?
@@ -193,10 +193,11 @@ module Neo4j
 
       private
 
+      DEFAULT_RELATIONSHIP_ARROW_DIRECTION = :both
       def relationship_arrow(match)
         rel_spec = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
 
-        case match[:dir] || :both
+        case match[:dir] || DEFAULT_RELATIONSHIP_ARROW_DIRECTION
         when :outgoing then "-#{rel_spec}->"
         when :incoming then "<-#{rel_spec}-"
         when :both then "-#{rel_spec}-"

data/lib/neo4j-server/cypher_relationship.rb

@@ -19,7 +19,7 @@ module Neo4j
       def ==(other)
         other.class == self.class && other.neo_id == neo_id
       end
-      alias_method :eql?, :==
+      alias eql? ==
 
       attr_reader :id
 
@@ -115,8 +115,8 @@ module Neo4j
       def del
         @session._query("#{match_start} DELETE n", neo_id: neo_id)
       end
-      alias_method :delete, :del
-      alias_method :destroy, :del
+      alias delete del
+      alias destroy del
 
       def exist?
         response = @session._query("#{match_start} RETURN n", neo_id: neo_id)

data/lib/neo4j-server/cypher_response.rb

@@ -155,6 +155,10 @@ module Neo4j
         !!@error
       end
 
+      def raise_if_cypher_error!
+        raise_cypher_error if error?
+      end
+
       RETRYABLE_ERROR_STATUSES = %w(DeadlockDetectedException AcquireLockTimeoutException ExternalResourceFailureException UnknownFailureException)
       def retryable_error?
         return unless error?

data/lib/neo4j-server/cypher_session.rb

@@ -9,7 +9,7 @@ module Neo4j
     class CypherSession < Neo4j::Session
       include Resource
 
-      alias_method :super_query, :query
+      alias super_query query
       attr_reader :connection
 
       def initialize(data_url, connection)
@@ -27,7 +27,7 @@ module Neo4j
         conn = Faraday.new(url, init_params) do |b|
           b.request :basic_auth, params[:basic_auth][:username], params[:basic_auth][:password] if params[:basic_auth]
           b.request :multi_json
-          # b.response :logger
+          # b.response :logger, ::Logger.new(STDOUT), bodies: true
 
           b.response :multi_json, symbolize_keys: true, content_type: 'application/json'
           # b.use Faraday::Response::RaiseError
@@ -90,14 +90,25 @@ module Neo4j
         init_resource_data(data_resource, data_url)
       end
 
-      def close
-        super
-        Neo4j::Transaction.unregister_current
+      def self.transaction_class
+        Neo4j::Server::CypherTransaction
       end
 
-      def begin_tx
-        Neo4j::Transaction.current ? Neo4j::Transaction.current.push_nested! : wrap_resource(@connection)
-        Neo4j::Transaction.current
+      # Duplicate of CypherSession::Adaptor::Base#transaction
+      def transaction
+        return self.class.transaction_class.new(self) if !block_given?
+
+        begin
+          tx = transaction
+
+          yield tx
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          tx.mark_failed
+
+          raise e
+        ensure
+          tx.close
+        end
       end
 
       def create_node(props = nil, labels = [])
@@ -118,7 +129,7 @@ module Neo4j
       def load_relationship(neo_id)
         query.unwrapped.optional_match('(n)-[r]-()').where(r: {neo_id: neo_id}).pluck(:r).first
       rescue Neo4j::Session::CypherError => cypher_error
-        return nil if cypher_error.message.match(/not found$/)
+        return nil if cypher_error.message =~ /not found$/
 
         raise cypher_error
       end
@@ -154,12 +165,9 @@ module Neo4j
 
       def query(*args)
         if [[String], [String, Hash]].include?(args.map(&:class))
-          query = args[0]
-          params = args[1]
-
-          response = _query(query, params)
+          response = _query(*args)
           response.raise_error if response.error?
-          response.to_node_enumeration(query)
+          response.to_node_enumeration(args[0])
         else
           options = args[0] || {}
           Neo4j::Core::Query.new(options.merge(session: self))
@@ -199,19 +207,16 @@ module Neo4j
       end
 
       def _query_entity_data(query, id = nil, params = {})
-        _query(query, params).tap do |response|
-          response.raise_error if response.error?
-        end.entity_data(id)
+        _query(query, params).tap(&:raise_if_cypher_error!).entity_data(id)
       end
 
       def _query(query, params = {}, options = {})
         query, params = query_and_params(query, params)
 
-        curr_tx = Neo4j::Transaction.current
         ActiveSupport::Notifications.instrument('neo4j.cypher_query', params: params, context: options[:context],
                                                                       cypher: query, pretty_cypher: options[:pretty_cypher]) do
-          if curr_tx
-            curr_tx._query(query, params)
+          if current_transaction
+            current_transaction._query(query, params)
           else
             query = params.nil? ? {'query' => query} : {'query' => query, 'params' => params}
             response = @connection.post(resource_url(:cypher), query)
@@ -225,7 +230,7 @@ module Neo4j
 
         Enumerator.new do |yielder|
           response.data.each do |data|
-            if Neo4j::Transaction.current
+            if current_transaction
               data[:row].each do |id|
                 yielder << CypherNode.new(self, id).wrapper
               end
@@ -236,12 +241,16 @@ module Neo4j
         end
       end
 
+      def current_transaction
+        Neo4j::Transaction.current_for(self)
+      end
+
       EMPTY = ''
       NEWLINE_W_SPACES = "\n  "
       def self.log_with
         ActiveSupport::Notifications.subscribe('neo4j.cypher_query') do |_, start, finish, _id, payload|
           ms = (finish - start) * 1000
-          params_string = (payload[:params] && payload[:params].size > 0 ? "| #{payload[:params].inspect}" : EMPTY)
+          params_string = (payload[:params] && !payload[:params].empty? ? "| #{payload[:params].inspect}" : EMPTY)
           cypher = payload[:pretty_cypher] ? NEWLINE_W_SPACES + payload[:pretty_cypher].gsub(/\n/, NEWLINE_W_SPACES) : payload[:cypher]
 
           yield(" #{ANSI::CYAN}#{payload[:context] || 'CYPHER'}#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR} #{cypher} #{params_string}")

data/lib/neo4j-server/cypher_transaction.rb

@@ -7,16 +7,20 @@ module Neo4j
     # * `close` is called to end the transaction. It calls `commit` or `delete`.
     #
     # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
-    class CypherTransaction
-      include Neo4j::Transaction::Instance
+    class CypherTransaction < Neo4j::Transaction::Base
       include Resource
 
-      attr_reader :commit_url, :query_url, :base_url, :connection
+      attr_reader :commit_url, :query_url
 
-      def initialize(url, session_connection)
-        @base_url = url
-        @connection = session_connection
-        register_instance
+      def connection
+        @session.connection
+      end
+
+      def base_url
+        require 'uri'
+        URI(@session.instance_variable_get('@resource_url')).tap do |uri|
+          uri.path = ''
+        end.to_s
       end
 
       ROW_REST = %w(row REST)
@@ -31,28 +35,34 @@ module Neo4j
       end
 
       def start(body)
-        request(:post, @base_url, 201, body).tap do |response|
+        request(:post, start_url, 201, body).tap do |response|
           @commit_url = response.body[:commit]
           @query_url = response.headers[:Location]
 
           fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !@query_url || @query_url.empty?
 
-          init_resource_data(response.body, @base_url)
+          init_resource_data(response.body, base_url)
         end
       end
 
+      def start_url
+        @session.resource_data.fetch(:transaction) || base_url
+      end
+
       def query(body)
         request(:post, @query_url, 200, body)
       end
 
+      EMPTY_RESPONSE = OpenStruct.new(status: 200, body: '')
+
       def delete
-        return empty_response if !@commit_url || expired?
+        return EMPTY_RESPONSE if !@commit_url || expired?
 
         request(:delete, @query_url, 200, nil, resource_headers)
       end
 
       def commit
-        return empty_response if !@commit_url || expired?
+        return EMPTY_RESPONSE if !@commit_url || expired?
 
         request(:post, @commit_url, 200, nil, resource_headers)
       end
@@ -66,11 +76,9 @@ module Neo4j
       end
 
       def create_cypher_response(response)
-        first_result = response.body[:results][0]
-
         CypherResponse.new(response, true).tap do |cypher_response|
           if response.body[:errors].empty?
-            cypher_response.set_data(first_result)
+            cypher_response.set_data(response.body[:results][0])
           else
             first_error = response.body[:errors].first
             tx_cleanup!(first_error)
@@ -81,7 +89,7 @@ module Neo4j
 
       def tx_cleanup!(first_error)
         autoclosed!
-        mark_expired if first_error[:message].match(/Unrecognized transaction id/)
+        mark_expired if first_error[:message] =~ /Unrecognized transaction id/
       end
 
       def empty_response

data/lib/neo4j-server/resource.rb

@@ -16,14 +16,13 @@ module Neo4j
         self
       end
 
-      def wrap_resource(connection = Neo4j::Session.current)
-        url = resource_url(:transaction)
-        CypherTransaction.new(url, connection)
+      def wrap_resource(connection)
+        CypherTransaction.new(resource_url(:transaction), connection)
       end
 
       def resource_url(key = nil)
         return @resource_url if key.nil?
-        @resource_data.fetch key
+        resource_data.fetch key
       rescue KeyError
         raise "No resource key '#{key}', available #{@resource_data.keys.inspect}"
       end

data/lib/neo4j/core/cypher_session.rb

@@ -1,7 +1,8 @@
-
 module Neo4j
   module Core
     class CypherSession
+      attr_reader :adaptor
+
       def initialize(adaptor)
         fail ArgumentError, "Invalid adaptor: #{adaptor.inspect}" if !adaptor.is_a?(Adaptors::Base)
 
@@ -10,22 +11,29 @@ module Neo4j
         @adaptor.connect
       end
 
+      def transaction_class
+        Neo4j::Core::CypherSession::Transactions::Base
+      end
+
+      %w(
+        version
+      ).each do |method, &_block|
+        define_method(method) do |*args, &block|
+          @adaptor.send(method, *args, &block)
+        end
+      end
+
       %w(
         query
         queries
 
-        start_transaction
-        end_transaction
         transaction
-        transaction_started?
 
-        version
-
-        indexes_for_label
-        uniqueness_constraints_for_label
+        indexes
+        constraints
       ).each do |method, &_block|
         define_method(method) do |*args, &block|
-          @adaptor.send(method, *args, &block)
+          @adaptor.send(method, self, *args, &block)
         end
       end
     end

data/lib/neo4j/core/cypher_session/adaptors.rb

@@ -1,19 +1,61 @@
 require 'neo4j/core/cypher_session'
 require 'neo4j/core/instrumentable'
+require 'neo4j/core/label'
 
 module Neo4j
   module Core
     class CypherSession
+      class CypherError < StandardError
+        attr_reader :code, :message, :stack_trace
+
+        def self.new_from(code, message, stack_trace = nil)
+          @code = code
+          @message = message
+          @stack_trace = stack_trace
+
+          msg = <<-ERROR
+  Cypher error:
+  #{ANSI::CYAN}#{code}#{ANSI::CLEAR}: #{message}
+  #{stack_trace}
+ERROR
+
+          error_class_from(code).new(msg)
+        end
+
+        def self.error_class_from(code)
+          case code
+          when /(ConstraintValidationFailed|ConstraintViolation)/
+            SchemaErrors::ConstraintValidationFailedError
+          else
+            CypherError
+          end
+        end
+      end
+      module SchemaErrors
+        class ConstraintValidationFailedError < CypherError; end
+      end
+
       module Adaptors
         MAP = {}
 
         class Base
           include Neo4j::Core::Instrumentable
 
+          gem, version = if defined?(::Neo4j::ActiveNode)
+                           ['neo4j', ::Neo4j::VERSION]
+                         else
+                           ['neo4j-core', ::Neo4j::Core::VERSION]
+                         end
+
+
+          USER_AGENT_STRING = "#{gem}-gem/#{version} (https://github.com/neo4jrb/#{gem})"
+
           def connect(*_args)
             fail '#connect not implemented!'
           end
 
+          attr_accessor :wrap_level
+
           Query = Struct.new(:cypher, :parameters, :pretty_cypher, :context)
 
           class QueryBuilder
@@ -43,57 +85,71 @@ module Neo4j
             end
           end
 
-          def query(*args)
-            queries { append(*args) }[0]
+          def query(session, *args)
+            options = (args.size == 3 || (args[0].is_a?(::Neo4j::Core::Query) && args.size == 2)) ? args.pop : {}
+
+            queries(session, options) { append(*args) }[0]
           end
 
-          def queries(&block)
+          def queries(session, options = {}, &block)
             query_builder = QueryBuilder.new
 
             query_builder.instance_eval(&block)
 
-            query_set(query_builder.queries)
+            new_or_current_transaction(session, options[:transaction]) do |tx|
+              query_set(tx, query_builder.queries, {commit: !options[:transaction]}.merge(options))
+            end
           end
 
-          def query_set(_queries)
-            fail '#queries not implemented!'
+          [:query_set,
+           :version,
+           :indexes,
+           :constraints,
+           :connected?].each do |method|
+            define_method(method) do |*_args|
+              fail "##{method} method not implemented on adaptor!"
+            end
           end
 
-          def start_transaction(*_args)
-            fail '#start_transaction not implemented!'
-          end
+          # If called without a block, returns a Transaction object
+          # which can be used to call query/queries/mark_failed/commit
+          # If called with a block, the Transaction object is yielded
+          # to the block and `commit` is ensured.  Any uncaught exceptions
+          # will mark the transaction as failed first
+          def transaction(session)
+            return self.class.transaction_class.new(session) if !block_given?
 
-          def end_transaction(*_args)
-            fail '#end_transaction not implemented!'
-          end
+            begin
+              tx = transaction(session)
 
-          def transaction_started?(*_args)
-            fail '#transaction_started? not implemented!'
-          end
+              yield tx
+            rescue => e
+              tx.mark_failed
 
-          def version(*_args)
-            fail '#version not implemented!'
+              raise e
+            ensure
+              tx.close
+            end
           end
 
-          # Schema inspection methods
-          def indexes_for_label(*_args)
-            fail '#indexes_for_label not implemented!'
-          end
+          def logger
+            return @logger if @logger
 
-          def uniqueness_constraints_for_label(*_args)
-            fail '#uniqueness_constraints_for_label not implemented!'
+            @logger = if @options[:logger]
+                        @options[:logger]
+                      else
+                        Logger.new(logger_location).tap do |logger|
+                          logger.level = logger_level
+                        end
+                      end
           end
 
+          def setup_queries!(queries, transaction, options = {})
+            fail 'Query attempted without a connection' if !connected?
+            fail "Invalid transaction object: #{transaction.inspect}" if !transaction.is_a?(self.class.transaction_class)
 
-          # Uses #start_transaction and #end_transaction to allow
-          # execution of queries within a block to be part of a
-          # full transaction
-          def transaction
-            start_transaction
-
-            yield
-          ensure
-            end_transaction if transaction_started?
+            # context option not yet implemented
+            self.class.instrument_queries(queries) unless options[:skip_instrumentation]
           end
 
           EMPTY = ''
@@ -101,7 +157,7 @@ module Neo4j
 
           instrument(:query, 'neo4j.core.cypher_query', %w(query)) do |_, _start, _finish, _id, payload|
             query = payload[:query]
-            params_string = (query.parameters && query.parameters.size > 0 ? "| #{query.parameters.inspect}" : EMPTY)
+            params_string = (query.parameters && !query.parameters.empty? ? "| #{query.parameters.inspect}" : EMPTY)
             cypher = query.pretty_cypher ? NEWLINE_W_SPACES + query.pretty_cypher.gsub(/\n/, NEWLINE_W_SPACES) : query.cypher
 
             " #{ANSI::CYAN}#{query.context || 'CYPHER'}#{ANSI::CLEAR} #{cypher} #{params_string}"
@@ -113,6 +169,33 @@ module Neo4j
                 instrument_query(query) {}
               end
             end
+
+            def transaction_class
+              fail '.transaction_class method not implemented on adaptor!'
+            end
+          end
+
+          private
+
+          def new_or_current_transaction(session, tx, &block)
+            if tx
+              yield(tx)
+            else
+              transaction(session, &block)
+            end
+          end
+
+          def validate_query_set!(transaction, _queries, _options = {})
+            fail 'Query attempted without a connection' if !connected?
+            fail "Invalid transaction object: #{transaction}" if !transaction.is_a?(self.class.transaction_class)
+          end
+
+          def logger_location
+            @options[:logger_location] || STDOUT
+          end
+
+          def logger_level
+            @options[:logger_level] || Logger::WARN
           end
         end
       end