neo4j-core 6.1.6 → 7.0.0.alpha.1

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

@@ -1,14 +1,19 @@
 require 'neo4j/core/cypher_session/adaptors'
 require 'neo4j/core/cypher_session/responses/embedded'
+require 'active_support/hash_with_indifferent_access'
 
 module Neo4j
   module Core
     class CypherSession
       module Adaptors
         class Embedded < Base
+          attr_reader :graph_db, :path
+
           def initialize(path, options = {})
             fail 'JRuby is required for embedded mode' if RUBY_PLATFORM != 'java'
-            fail ArgumentError, "Invalid path: #{path}" if !File.directory?(path)
+            # TODO: Will this cause an error if a new path is specified?
+            fail ArgumentError, "Invalid path: #{path}" if File.file?(path)
+            FileUtils.mkdir_p(path)
 
             @path = path
             @options = options
@@ -23,38 +28,16 @@ module Neo4j
             @graph_db = db_service.newGraphDatabase
           end
 
-          def query_set(queries)
+          def query_set(transaction, queries, options = {})
             # I think that this is the best way to do a batch in embedded...
             # Should probably do within a transaction in case of errors...
+            setup_queries!(queries, transaction, options)
 
-            transaction do
-              self.class.instrument_transaction do
-                self.class.instrument_queries(queries)
-
-                execution_results = queries.map do |query|
-                  engine.execute(query.cypher, indifferent_params(query))
-                end
-
-                Responses::Embedded.new(execution_results).results
-              end
+            self.class.instrument_transaction do
+              Responses::Embedded.new(execution_results(queries), wrap_level: options[:wrap_level] || @options[:wrap_level]).results
             end
-          end
-
-          def start_transaction
-            @transaction = @graph_db.begin_tx
-          end
-
-          def end_transaction
-            if @transaction.nil?
-              fail 'Cannot close transaction without starting one'
-            end
-
-            @transaction.success
-            @transaction.close
-          end
-
-          def transaction_started?
-            !!@transaction
+          rescue Java::OrgNeo4jCypher::CypherExecutionException, Java::OrgNeo4jCypher::SyntaxException => e
+            raise CypherError.new_from(e.status.to_s, e.message) # , e.stack_track.to_a
           end
 
           def version
@@ -67,6 +50,41 @@ module Neo4j
             end
           end
 
+          def indexes(session, _label = nil)
+            Transaction.run(session) do
+              graph_db = session.adaptor.graph_db
+
+              graph_db.schema.get_indexes.map do |definition|
+                {properties: definition.property_keys.map(&:to_sym),
+                 label: definition.label.to_s.to_sym}
+              end
+            end
+          end
+
+          CONSTRAINT_TYPES = {
+            'UNIQUENESS' => :uniqueness
+          }
+          def constraints(session)
+            Transaction.run(session) do
+              all_labels(session).flat_map do |label|
+                graph_db.schema.get_constraints(label).map do |definition|
+                  {label: label.to_s.to_sym,
+                   properties: definition.property_keys.map(&:to_sym),
+                   type: CONSTRAINT_TYPES[definition.get_constraint_type.to_s]}
+                end
+              end
+            end
+          end
+
+          def self.transaction_class
+            require 'neo4j/core/cypher_session/transactions/embedded'
+            Neo4j::Core::CypherSession::Transactions::Embedded
+          end
+
+          def connected?
+            !!@graph_db
+          end
+
           instrument(:transaction, 'neo4j.core.embedded.transaction', []) do |_, start, finish, _id, _payload|
             ms = (finish - start) * 1000
 
@@ -75,6 +93,16 @@ module Neo4j
 
           private
 
+          def execution_results(queries)
+            queries.map do |query|
+              engine.execute(query.cypher, indifferent_params(query))
+            end
+          end
+
+          def all_labels(session)
+            Java::OrgNeo4jTooling::GlobalGraphOperations.at(session.adaptor.graph_db).get_all_labels.to_a
+          end
+
           def indifferent_params(query)
             params = query.parameters
             params.each { |k, v| params[k] = HashWithIndifferentAccess.new(params[k]) if v.is_a?(Hash) && !v.respond_to?(:nested_under_indifferent_access) }
@@ -84,6 +112,9 @@ module Neo4j
           def engine
             @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
           end
+
+          def constraint_definitions_for(graph_db, label)
+          end
         end
       end
     end

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

@@ -0,0 +1,63 @@
+require 'active_support/concern'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Adaptors
+        # Containing the logic for dealing with adaptors which use URIs
+        module HasUri
+          extend ActiveSupport::Concern
+
+          module ClassMethods
+            attr_reader :default_uri
+
+            def default_url(default_url)
+              @default_uri = uri_from_url!(default_url)
+            end
+
+            def validate_uri(&block)
+              @uri_validator = block
+            end
+
+            def uri_from_url!(url)
+              validate_url!(url)
+
+              @uri = url.nil? ? @default_uri : URI(url)
+
+              fail ArgumentError, "Invalid URL: #{url.inspect}" if uri_valid?(@uri)
+
+              @uri
+            end
+
+            private
+
+            def validate_url!(url)
+              fail ArgumentError, "Invalid URL: #{url.inspect}" if !(url.is_a?(String) || url.nil?)
+              fail ArgumentError, 'No URL or default URL specified' if url.nil? && @default_uri.nil?
+            end
+
+            def uri_valid?(uri)
+              @uri_validator && !@uri_validator.call(uri)
+            end
+          end
+
+          def url
+            @uri.to_s
+          end
+
+          def url=(url)
+            @uri = self.class.uri_from_url!(url)
+          end
+
+          included do
+            %w(scheme user password host port).each do |method|
+              define_method(method) do
+                (@uri && @uri.send(method)) || (self.class.default_uri && self.class.default_uri.send(method))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'neo4j/core/cypher_session/adaptors'
+require 'neo4j/core/cypher_session/adaptors/has_uri'
 require 'neo4j/core/cypher_session/responses/http'
 
 # TODO: Work with `Query` objects
@@ -7,178 +8,181 @@ module Neo4j
     class CypherSession
       module Adaptors
         class HTTP < Base
-          # @transaction_state valid states
-          # nil, :open_requested, :open, :close_requested
+          attr_reader :requestor, :url
 
-          def initialize(url, _options = {})
+          def initialize(url, options = {})
             @url = url
-            @url_components = url_components!(url)
-            @transaction_state = nil
+            @options = options
           end
 
           def connect
-            @connection ||= connection
+            @requestor = Requestor.new(@url, USER_AGENT_STRING, self.class.method(:instrument_request))
           end
 
           ROW_REST = %w(row REST)
 
-          def query_set(queries)
-            fail 'Query attempted without a connection' if @connection.nil?
+          def query_set(transaction, queries, options = {})
+            setup_queries!(queries, transaction)
 
-            statements_data = queries.map do |query|
-              {statement: query.cypher, parameters: query.parameters || {},
-               resultDataContents: ROW_REST}
-            end
-            request_data = {statements: statements_data}
-
-            # context option not implemented
-            self.class.instrument_queries(queries)
+            return unless path = transaction.query_path(options.delete(:commit))
 
-            return unless url = full_transaction_url
+            faraday_response = @requestor.post(path, queries)
 
-            faraday_response = self.class.instrument_request(url, request_data) do
-              @connection.post(url, request_data)
-            end
+            transaction.apply_id_from_url!(faraday_response.env[:response_headers][:location])
 
-            store_transaction_id!(faraday_response)
-
-            Responses::HTTP.new(faraday_response, request_data).results
+            wrap_level = options[:wrap_level] || @options[:wrap_level]
+            Responses::HTTP.new(faraday_response, wrap_level: wrap_level).results
           end
 
-          def start_transaction
-            case @transaction_state
-            when :open
-              return
-            when :close_requested
-              fail 'Cannot start transaction when a close has been requested'
-            end
-
-            @transaction_state = :open_requested
+          def version
+            @version ||= @requestor.get('db/data/').body[:neo4j_version]
           end
 
-          def end_transaction
-            if @transaction_state.nil?
-              fail 'Cannot close transaction without starting one'
-            end
+          # Schema inspection methods
+          def indexes(_session)
+            response = @requestor.get('db/data/schema/index')
 
-            # This needs thought through more...
-            @transaction_state = :close_requested
-            query_set([])
-            @transaction_state = nil
-            @transaction_id = nil
+            list = response.body || []
 
-            true
+            list.map do |item|
+              {label: item[:label].to_sym,
+               properties: item[:property_keys].map(&:to_sym)}
+            end
           end
 
-          def transaction_started?
-            !!@transaction_id
+          CONSTRAINT_TYPES = {
+            'UNIQUENESS' => :uniqueness
+          }
+          def constraints(_session, _label = nil, _options = {})
+            response = @requestor.get('db/data/schema/constraint')
+
+            list = response.body || []
+            list.map do |item|
+              {type: CONSTRAINT_TYPES[item[:type]],
+               label: item[:label].to_sym,
+               properties: item[:property_keys].map(&:to_sym)}
+            end
           end
 
-          def version
-            @version ||= @connection.get(db_data_url).body[:neo4j_version]
+          def self.transaction_class
+            require 'neo4j/core/cypher_session/transactions/http'
+            Neo4j::Core::CypherSession::Transactions::HTTP
           end
 
           # Schema inspection methods
           def indexes_for_label(label)
             url = db_data_url + "schema/index/#{label}"
-            response = @connection.get(url)
-
-            if response.body && response.body[0]
-              response.body[0][:property_keys].map(&:to_sym)
-            else
-              []
-            end
-          end
-
-          def uniqueness_constraints_for_label(label)
-            url = db_data_url + "schema/constraint/#{label}/uniqueness"
-            response = @connection.get(url)
-
-            if response.body && response.body[0]
-              response.body[0][:property_keys].map(&:to_sym)
-            else
-              []
-            end
+            @connection.get(url)
           end
 
-
-          instrument(:request, 'neo4j.core.http.request', %w(url body)) do |_, start, finish, _id, payload|
+          instrument(:request, 'neo4j.core.http.request', %w(method url body)) do |_, start, finish, _id, payload|
             ms = (finish - start) * 1000
+            " #{ANSI::BLUE}HTTP REQUEST:#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR} #{payload[:method].upcase} #{payload[:url]} (#{payload[:body].size} bytes)"
+          end
 
-            " #{ANSI::BLUE}HTTP REQUEST:#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR} #{payload[:url]}"
+          def connected?
+            !!@requestor
           end
 
-          private
+          # Basic wrapper around HTTP requests to standard Neo4j HTTP endpoints
+          #  - Takes care of JSONifying objects passed as body (Hash/Array/Query)
+          #  - Sets headers, including user agent string
+          class Requestor
+            include Adaptors::HasUri
+            default_url('http://neo4:neo4j@localhost:7474')
+            validate_uri { |uri| uri.is_a?(URI::HTTP) }
 
-          def store_transaction_id!(faraday_response)
-            location = faraday_response.env[:response_headers][:location]
+            def initialize(url, user_agent_string, instrument_proc)
+              self.url = url
+              @user = user
+              @password = password
+              @user_agent_string = user_agent_string
+              @faraday = faraday_connection
+              @instrument_proc = instrument_proc
+            end
 
-            return if !location
+            REQUEST_HEADERS = {'Accept'.to_sym => 'application/json; charset=UTF-8',
+                               'Content-Type'.to_sym => 'application/json'}
+
+            # @method HTTP method (:get/:post/:delete/:put)
+            # @path Path part of URL
+            # @body Body for the request.  If a Query or Array of Queries,
+            #       it is automatically converted
+            def request(method, path, body = '', _options = {})
+              request_body = request_body(body)
+              url = url_from_path(path)
+              @instrument_proc.call(method, url, request_body) do
+                @faraday.run_request(method, url, request_body, REQUEST_HEADERS) do |req|
+                  # Temporary
+                  # req.options.timeout = 5
+                  # req.options.open_timeout = 5
+                end
+              end
+            end
 
-            @transaction_id = location.split('/').last.to_i
-          end
+            # Convenience method to #request(:post, ...)
+            def post(path, body = '', options = {})
+              request(:post, path, body, options)
+            end
 
-          def full_transaction_url
-            path = ''
-            path << "/#{@transaction_id}" if [:open, :close_requested].include?(@transaction_state)
-            path << '/commit' if [nil, :close_requested].include?(@transaction_state)
-            path = nil if @transaction_state == :close_requested && !@transaction_id
+            # Convenience method to #request(:get, ...)
+            def get(path, body = '', options = {})
+              request(:get, path, body, options)
+            end
 
-            db_data_url + 'transaction' + path if path
-          end
+            private
 
-          def db_data_url
-            url_base + 'db/data/'
-          end
+            def faraday_connection
+              require 'faraday'
+              require 'faraday_middleware/multi_json'
 
-          def url_base
-            "#{scheme}://#{host}:#{port}/"
-          end
+              Faraday.new(url) do |c|
+                c.request :basic_auth, user, password
+                c.request :multi_json
 
-          def connection
-            Faraday.new(@url) do |c|
-              c.request :basic_auth, user, password
-              c.request :multi_json
+                c.response :multi_json, symbolize_keys: true, content_type: 'application/json'
+                c.use Faraday::Adapter::NetHttpPersistent
 
-              c.response :multi_json, symbolize_keys: true, content_type: 'application/json'
-              c.use Faraday::Adapter::NetHttpPersistent
+                # c.response :logger, ::Logger.new(STDOUT), bodies: true
 
-              c.headers['Content-Type'] = 'application/json'
-              c.headers['User-Agent'] = user_agent_string
+                c.headers['Content-Type'] = 'application/json'
+                c.headers['User-Agent'] = @user_agent_string
+              end
             end
-          end
 
-          def url_components!(url)
-            @uri = URI(url || 'http://localhost:7474')
+            def request_body(body)
+              return body if body.is_a?(String)
 
-            if !@uri.is_a?(URI::HTTP)
-              fail ArgumentError, "Invalid URL: #{url.inspect}"
-            end
+              body_is_query_array = body.is_a?(Array) && body.all? { |o| o.respond_to?(:cypher) }
+              case body
+              when Hash, Array
+                if body_is_query_array
+                  return {statements: body.map(&self.class.method(:statement_from_query))}
+                end
 
-            true
-          end
+                body
+              else
+                {statements: [self.class.statement_from_query(body)]} if body.respond_to?(:cypher)
+              end
+            end
 
-          URI_DEFAULTS = {
-            scheme: 'http',
-            user: 'neo4j', password: 'neo4j',
-            host: 'localhost', port: 7474
-          }
+            class << self
+              private
 
-          URI_DEFAULTS.each do |method, value|
-            define_method(method) do
-              @uri.send(method) || value
+              def statement_from_query(query)
+                {statement: query.cypher,
+                 parameters: query.parameters || {},
+                 resultDataContents: ROW_REST}
+              end
             end
-          end
-
-          def user_agent_string
-            gem, version = if defined?(::Neo4j::ActiveNode)
-                             ['neo4j', ::Neo4j::VERSION]
-                           else
-                             ['neo4j-core', ::Neo4j::Core::VERSION]
-                           end
 
+            def url_base
+              "#{scheme}://#{host}:#{port}"
+            end
 
-            "#{gem}-gem/#{version} (https://github.com/neo4jrb/#{gem})"
+            def url_from_path(path)
+              url_base + (path[0] != '/' ? '/' + path : path)
+            end
           end
         end
       end