neo4j-core 6.1.6 → 7.0.0.alpha.1

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

@@ -7,8 +7,6 @@ module Neo4j
         MAP = {}
 
         class Base
-          class CypherError < StandardError; end
-
           include Enumerable
 
           def each
@@ -17,6 +15,23 @@ module Neo4j
             end
           end
 
+          def wrap_by_level(none_value)
+            case @wrap_level
+            when :none
+              if none_value.is_a?(Array)
+                none_value.map(&:symbolize_keys)
+              else
+                none_value.symbolize_keys
+              end
+            when :core_entity
+              yield
+            when :proc
+              yield.wrap
+            else
+              fail ArgumentError, "Inalid wrap_level: #{@wrap_level.inspect}"
+            end
+          end
+
           def results
             fail '#results not implemented!'
           end

data/lib/neo4j/core/cypher_session/responses/bolt.rb

@@ -0,0 +1,135 @@
+require 'neo4j/core/cypher_session/responses'
+require 'active_support/core_ext/hash/keys'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        class Bolt < Base
+          attr_reader :results, :result_info
+
+          def initialize(queries, flush_messages_proc, options = {})
+            @wrap_level = options[:wrap_level] || Neo4j::Core::Config.wrapping_level
+
+            @results = queries.map do
+              fields, result_messages, _footer_messages = extract_message_groups(flush_messages_proc)
+              # @result_info = footer_messages[0].args[0]
+
+              data = result_messages.map do |result_message|
+                validate_message_type!(result_message, :record)
+
+                result_message.args[0]
+              end
+
+              result_from_data(fields, data)
+            end
+          end
+
+          def result_from_data(columns, entities_data)
+            rows = entities_data.map do |entity_data|
+              wrap_entity(entity_data)
+            end
+
+            Result.new(columns, rows)
+          end
+
+          def wrap_entity(entity_data)
+            case entity_data
+            when Array
+              entity_data.map(&method(:wrap_entity))
+            when PackStream::Structure
+              wrap_structure(entity_data)
+            when Hash
+              entity_data.each_with_object({}) do |(k, v), result|
+                result[k.to_sym] = wrap_entity(v)
+              end
+            else
+              entity_data
+            end
+          end
+
+          private
+
+          def extract_message_groups(flush_messages_proc)
+            fields_messages = flush_messages_proc.call
+            validate_message_type!(fields_messages[0], :success)
+
+            result_messages = []
+            while (messages = flush_messages_proc.call)[0].type != :success
+              result_messages.concat(messages)
+            end
+
+            [fields_messages[0].args[0]['fields'],
+             result_messages,
+             messages]
+          end
+
+          def wrap_structure(structure)
+            case structure.signature
+            when 0x4E then wrap_node(*structure.list)
+            when 0x52 then wrap_relationship(*structure.list)
+            when 0x72 then wrap_unbound_relationship(*structure.list)
+            when 0x50 then wrap_path(*structure.list)
+            else
+              fail CypherError, "Unsupported structure signature: #{structure.signature}"
+            end
+          end
+
+          def wrap_by_level(none_value)
+            case @wrap_level
+            when :none
+              if none_value.is_a?(Array)
+                none_value.map(&:symbolize_keys)
+              else
+                none_value.symbolize_keys
+              end
+            when :core_entity
+              yield
+            when :proc
+              yield.wrap
+            else
+              fail ArgumentError, "Inalid wrap_level: #{@wrap_level.inspect}"
+            end
+          end
+
+          def wrap_node(id, labels, properties)
+            wrap_by_level(properties) { ::Neo4j::Core::Node.new(id, labels, properties) }
+          end
+
+          def wrap_relationship(id, from_node_id, to_node_id, type, properties)
+            wrap_by_level(properties) { ::Neo4j::Core::Relationship.new(id, type, properties, from_node_id, to_node_id) }
+          end
+
+          def wrap_unbound_relationship(id, type, properties)
+            wrap_by_level(properties) { ::Neo4j::Core::Relationship.new(id, type, properties) }
+          end
+
+          def wrap_path(nodes, relationships, directions)
+            none_value = nodes.zip(relationships).flatten.compact.map { |obj| obj.list.last }
+            wrap_by_level(none_value) do
+              ::Neo4j::Core::Path.new(nodes.map(&method(:wrap_entity)),
+                                      relationships.map(&method(:wrap_entity)),
+                                      directions.map(&method(:wrap_direction)))
+            end
+          end
+
+          def wrap_direction(_direction_int)
+            ''
+          end
+
+          def validate_message_type!(message, type)
+            case message.type
+            when type
+              return
+            when :failure
+              data = message.args[0]
+              throw :cypher_bolt_failure, data
+            else
+              fail "Unexpected message type: #{message.type} (#{message.inspect})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses/embedded.rb

@@ -7,7 +7,11 @@ module Neo4j
         class Embedded < Base
           attr_reader :results, :request_data
 
-          def initialize(execution_results)
+          def initialize(execution_results, options = {})
+            # validate_response!(execution_results)
+
+            @wrap_level = options[:wrap_level] || Neo4j::Core::Config.wrapping_level
+
             @results = execution_results.map do |execution_result|
               result_from_execution_result(execution_result)
             end
@@ -26,39 +30,66 @@ module Neo4j
           def wrap_entity(entity)
             if entity.is_a?(Array) ||
                entity.is_a?(Java::ScalaCollectionConvert::Wrappers::SeqWrapper)
-              entity.to_a.map { |e| wrap_entity(e) }
-            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::NodeProxy)
-              wrap_node(entity)
+              entity.to_a.map(&method(:wrap_entity))
+            else
+              _wrap_entity(entity)
+            end
+          end
+
+          def _wrap_entity(entity)
+            case @wrap_level
+            when :none then wrap_value(entity)
+            when :core_entity, :proc
+              if type = type_for_entity(entity)
+                result = send("wrap_#{type}", entity)
+
+                @wrap_level == :proc ? result.wrap : result
+              else
+                wrap_value(entity)
+              end
+            else
+              fail ArgumentError, "Inalid wrap_level: #{@wrap_level.inspect}"
+            end
+          end
+
+          def type_for_entity(entity)
+            if entity.is_a?(Java::OrgNeo4jKernelImplCore::NodeProxy)
+              :node
             elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
-              wrap_relationship(entity)
+              :relationship
             elsif entity.respond_to?(:path_entities)
-              wrap_path(entity)
-            else
-              wrap_value(entity)
+              :path
             end
           end
 
           def wrap_node(entity)
             ::Neo4j::Core::Node.new(entity.get_id,
                                     entity.get_labels.map(&:to_s),
-                                    get_entity_properties(entity)).wrap
+                                    get_entity_properties(entity))
           end
 
           def wrap_relationship(entity)
             ::Neo4j::Core::Relationship.new(entity.get_id,
                                             entity.get_type.name,
-                                            get_entity_properties(entity)).wrap
+                                            get_entity_properties(entity),
+                                            entity.get_start_node.neo_id,
+                                            entity.get_end_node.neo_id)
           end
 
           def wrap_path(entity)
             ::Neo4j::Core::Path.new(entity.nodes.map(&method(:wrap_node)),
                                     entity.relationships.map(&method(:wrap_relationship)),
-                                    nil).wrap
+                                    nil)
           end
 
           def wrap_value(entity)
             if entity.is_a?(Java::ScalaCollectionConvert::Wrappers::MapWrapper)
               entity.each_with_object({}) { |(k, v), r| r[k.to_sym] = v }
+            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::NodeProxy) ||
+                  entity.is_a?(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+              entity.property_keys.each_with_object({}) { |key, hash| hash[key.to_sym] = entity.get_property(key) }
+            elsif entity.respond_to?(:path_entities)
+              entity.to_a.map(&method(:wrap_value))
             else
               # Convert from Java?
               entity
@@ -70,6 +101,10 @@ module Neo4j
               result[key.to_sym] = entity.get_property(key)
             end
           end
+
+          def validate_response!(_execution_results)
+            require 'pry'
+          end
         end
       end
     end

data/lib/neo4j/core/cypher_session/responses/http.rb

@@ -7,11 +7,14 @@ module Neo4j
         class HTTP < Base
           attr_reader :results, :request_data
 
-          def initialize(faraday_response, request_data)
+          def initialize(faraday_response, options = {})
+            @faraday_response = faraday_response
             @request_data = request_data
 
             validate_faraday_response!(faraday_response)
 
+            @wrap_level = options[:wrap_level] || Neo4j::Core::Config.wrapping_level
+
             @results = faraday_response.body[:results].map do |result_data|
               result_from_data(result_data[:columns], result_data[:data])
             end
@@ -25,79 +28,85 @@ module Neo4j
             Result.new(columns, rows)
           end
 
-          def wrap_entity(row_data, rest_data)
-            row_data.each_with_index.map do |row_datum, i|
-              rest_datum = rest_data[i]
-
-              if rest_datum.is_a?(Array)
-                wrap_entity(row_datum, rest_datum)
-              elsif (ident = identify_entity(rest_datum))
-                send("wrap_#{ident}", rest_datum, row_datum)
-              else
-                row_datum
+          def wrap_entity(row_datum, rest_datum)
+            case
+            when rest_datum.is_a?(Array)
+              row_datum.zip(rest_datum).map { |row, rest| wrap_entity(row, rest) }
+            when ident = identify_entity(rest_datum)
+              send("wrap_#{ident}", rest_datum, row_datum)
+            when rest_datum.is_a?(Hash)
+              rest_datum.each_with_object({}) do |(k, v), result|
+                result[k.to_sym] = wrap_entity(row_datum[k], v)
               end
+            else
+              row_datum
             end
           end
 
           private
 
           def identify_entity(rest_datum)
+            return if !rest_datum.is_a?(Hash)
             self_string = rest_datum[:self]
             if self_string
               type = self_string.split('/')[-2]
-              if type == 'node'
-                :node
-              elsif type == 'relationship'
-                :relationship
-              end
+              type.to_sym if %w(node relationship).include?(type)
             elsif [:nodes, :relationships, :start, :end, :length].all? { |k| rest_datum.key?(k) }
               :path
             end
           end
 
-          def wrap_node(rest_datum, _)
-            metadata_data = rest_datum[:metadata]
-            ::Neo4j::Core::Node.new(id_from_rest_datum(rest_datum),
-                                    metadata_data && metadata_data[:labels],
-                                    rest_datum[:data]).wrap
+          def wrap_node(rest_datum, row_datum)
+            wrap_by_level(row_datum) do
+              metadata_data = rest_datum[:metadata]
+              ::Neo4j::Core::Node.new(id_from_rest_datum(rest_datum),
+                                      metadata_data && metadata_data[:labels],
+                                      rest_datum[:data])
+            end
           end
 
-          def wrap_relationship(rest_datum, _)
-            metadata_data = rest_datum[:metadata]
-            ::Neo4j::Core::Relationship.new(id_from_rest_datum(rest_datum),
-                                            metadata_data && metadata_data[:type],
-                                            rest_datum[:data]).wrap
+          def wrap_relationship(rest_datum, row_datum)
+            wrap_by_level(row_datum) do
+              metadata_data = rest_datum[:metadata]
+              ::Neo4j::Core::Relationship.new(id_from_rest_datum(rest_datum),
+                                              metadata_data && metadata_data[:type],
+                                              rest_datum[:data],
+                                              id_from_url(rest_datum[:start]),
+                                              id_from_url(rest_datum[:end]))
+            end
           end
 
           def wrap_path(rest_datum, row_datum)
-            nodes = rest_datum[:nodes].each_with_index.map do |url, i|
-              Node.from_url(url, row_datum[2 * i])
-            end
-            relationships = rest_datum[:relationships].each_with_index.map do |url, i|
-              Relationship.from_url(url, row_datum[(2 * i) + 1])
-            end
+            wrap_by_level(row_datum) do
+              nodes = rest_datum[:nodes].each_with_index.map do |url, i|
+                Node.from_url(url, row_datum[2 * i])
+              end
+              relationships = rest_datum[:relationships].each_with_index.map do |url, i|
+                Relationship.from_url(url, row_datum[(2 * i) + 1])
+              end
 
-            ::Neo4j::Core::Path.new(nodes, relationships, rest_datum[:directions]).wrap
+              ::Neo4j::Core::Path.new(nodes, relationships, rest_datum[:directions])
+            end
           end
 
           def id_from_rest_datum(rest_datum)
             if rest_datum[:metadata]
               rest_datum[:metadata][:id]
             else
-              rest_datum[:self].split('/').last.to_i
+              id_from_url(rest_datum[:self])
             end
           end
 
+          def id_from_url(url)
+            url.split('/').last.to_i
+          end
+
           def validate_faraday_response!(faraday_response)
             if faraday_response.body.is_a?(Hash) && error = faraday_response.body[:errors][0]
-              error = <<-ERROR
-  Request to: #{ANSI::BOLD}#{faraday_response.env.url}#{ANSI::CLEAR}
-  #{ANSI::CYAN}#{error[:code]}#{ANSI::CLEAR}: #{error[:message]}
-ERROR
-              fail CypherError, error
+              fail CypherError.new_from(error[:code], error[:message], error[:stack_trace])
             end
 
-            return if (200..299).include?(status = faraday_response.status)
+            return if (200..299).cover?(status = faraday_response.status)
 
             fail CypherError, "Expected 200-series response for #{faraday_response.env.url} (got #{status})"
           end

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

@@ -0,0 +1,33 @@
+module Neo4j
+  module Core
+    class CypherSession
+      module Transactions
+        class Base < Neo4j::Transaction::Base
+          def query(*args)
+            options = if args[0].is_a?(::Neo4j::Core::Query)
+                        args[1] ||= {}
+                      else
+                        args[1] ||= {}
+                        args[2] ||= {}
+                      end
+            options[:transaction] ||= self
+
+            adaptor.query(@session, *args)
+          end
+
+          def queries(options = {}, &block)
+            adaptor.queries(@session, {transaction: self}.merge(options), &block)
+          end
+
+          private
+
+          # Because we're inheriting from the old Transaction class
+          # but the new adaptors work much like the old sessions
+          def adaptor
+            @session.adaptor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/transactions/bolt.rb

@@ -0,0 +1,36 @@
+require 'neo4j/core/cypher_session/transactions'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Transactions
+        class Bolt < Base
+          def initialize(*args)
+            super
+
+            tx_query('BEGIN') if root?
+          end
+
+          def commit
+            tx_query('COMMIT') if root?
+          end
+
+          def delete
+            tx_query('ROLLBACK')
+          end
+
+          def started?
+            true
+          end
+
+          private
+
+          def tx_query(cypher)
+            query = Adaptors::Base::Query.new(cypher, {}, cypher)
+            adaptor.send(:query_set, self, [query], skip_instrumentation: true)
+          end
+        end
+      end
+    end
+  end
+end