neo4j-core 8.1.4 → 9.0.0.alpha.1

data/lib/neo4j-server/cypher_relationship.rb

@@ -1,142 +0,0 @@
-module Neo4j
-  module Server
-    class CypherRelationship < Neo4j::Relationship
-      include Neo4j::Server::Resource
-      include Neo4j::Core::ActiveEntity
-
-      MARSHAL_INSTANCE_VARIABLES = %i[@rel_type @props @start_node_neo_id @end_node_neo_id @id]
-
-      def initialize(session, value)
-        @session = session
-        @response_hash = value
-        @rel_type = @response_hash[:type]
-        @props = @response_hash[:data]
-        @start_node_neo_id = neo_id_integer(@response_hash[:start])
-        @end_node_neo_id = neo_id_integer(@response_hash[:end])
-        @id = @response_hash[:id]
-      end
-
-      def ==(other)
-        other.class == self.class && other.neo_id == neo_id
-      end
-      alias eql? ==
-
-      attr_reader :id
-
-      def neo_id
-        id
-      end
-
-      def inspect
-        "CypherRelationship #{neo_id}"
-      end
-
-      def load_resource
-        return if resource_data_present?
-
-        @resource_data = @session._query_or_fail("#{match_start} RETURN n", true, neo_id: neo_id) # r.first_data
-      end
-
-      attr_reader :start_node_neo_id
-
-      attr_reader :end_node_neo_id
-
-      def _start_node_id
-        @start_node_neo_id ||= get_node_id(:start)
-      end
-
-      def _end_node_id
-        @end_node_neo_id ||= get_node_id(:end)
-      end
-
-      def _start_node
-        @_start_node ||= Neo4j::Node._load(start_node_neo_id)
-      end
-
-      def _end_node
-        load_resource
-        @_end_node ||= Neo4j::Node._load(end_node_neo_id)
-      end
-
-      def get_node_id(direction)
-        load_resource
-        resource_url_id(resource_url(direction))
-      end
-
-      def get_property(key)
-        @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
-      end
-
-      def set_property(key, value)
-        @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false,  value: value, neo_id: neo_id)
-      end
-
-      def remove_property(key)
-        @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, neo_id: neo_id)
-      end
-
-      # (see Neo4j::Relationship#props)
-      def props
-        if @props
-          @props
-        else
-          hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
-          @props = Hash[hash[:data].map { |k, v| [k, v] }]
-        end
-      end
-
-      # (see Neo4j::Relationship#props=)
-      def props=(properties)
-        @session._query_or_fail("#{match_start} SET n = { props }", false, props: properties, neo_id: neo_id)
-        properties
-      end
-
-      # (see Neo4j::Relationship#update_props)
-      def update_props(properties)
-        return if properties.empty?
-
-        params = {}
-        q = "#{match_start} SET " + properties.keys.each_with_index.map do |k, _i|
-          param = k.to_s.tr_s('^a-zA-Z0-9', '_').gsub(/^_+|_+$/, '')
-          params[param] = properties[k]
-
-          "n.`#{k}`= {#{param}}"
-        end.join(',')
-
-        @session._query_or_fail(q, false, params.merge(neo_id: neo_id))
-
-        properties
-      end
-
-      def rel_type
-        @rel_type.to_sym
-      end
-
-      def del
-        @session._query("#{match_start} DELETE n", neo_id: neo_id)
-      end
-      alias delete del
-      alias destroy del
-
-      def exist?
-        response = @session._query("#{match_start} RETURN n", neo_id: neo_id)
-        # binding.pry
-        (response.data.nil? || response.data.empty?) ? false : true
-      end
-
-      private
-
-      def match_start(identifier = 'n')
-        "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = {neo_id}"
-      end
-
-      def resource_data_present?
-        !resource_data.nil? && !resource_data.empty?
-      end
-
-      def neo_id_integer(id_or_url)
-        id_or_url.is_a?(Integer) ? id_or_url : id_or_url.split('/').last.to_i
-      end
-    end
-  end
-end

data/lib/neo4j-server/cypher_response.rb

@@ -1,248 +0,0 @@
-module Neo4j
-  module Server
-    class CypherResponse
-      attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
-
-      class ResponseError < StandardError
-        attr_reader :status, :code
-
-        def initialize(msg, status, code)
-          super(msg)
-          @status = status
-          @code = code
-        end
-      end
-
-      class ConstraintViolationError < ResponseError; end
-
-      class HashEnumeration
-        include Enumerable
-        extend Forwardable
-        def_delegator :@response, :error_msg
-        def_delegator :@response, :error_status
-        def_delegator :@response, :error_code
-        def_delegator :@response, :columns
-        def_delegator :@response, :struct
-
-        def initialize(response, query)
-          @response = response
-          @query = query
-        end
-
-        def to_s
-          @query
-        end
-
-        def inspect
-          "Enumerable query: '#{@query}'"
-        end
-
-        def each
-          @response.each_data_row { |row| yield struct_rows(row) }
-        end
-
-        def struct_rows(row)
-          struct.new.tap do |result|
-            row.each_with_index { |value, i| result[columns[i]] = value }
-          end
-        end
-      end
-
-      EMPTY_STRING = ''
-      def to_struct_enumeration(cypher = EMPTY_STRING)
-        HashEnumeration.new(self, cypher)
-      end
-
-      def to_node_enumeration(cypher = EMPTY_STRING, session = Neo4j::Session.current)
-        Enumerator.new do |yielder|
-          to_struct_enumeration(cypher).each do |row|
-            yielder << row_pair_in_struct(row, session)
-          end
-        end
-      end
-
-      def row_pair_in_struct(row, session)
-        @struct.new.tap do |result|
-          row.each_pair do |column, value|
-            result[column] = map_row_value(value, session)
-          end
-        end
-      end
-
-      def map_row_value(value, session)
-        if value.is_a?(Hash) && looks_like_an_object?(value)
-          hash_value_as_object(value, session)
-        elsif value.is_a?(Array)
-          value.map! { |v| map_row_value(v, session) }
-        else
-          value
-        end
-      end
-
-      def hash_value_as_object(value, session)
-        return value unless %i[node relationship].include?(identify_entity(value))
-        add_entity_id(value)
-
-        basic_obj = (node?(value) ? CypherNode : CypherRelationship).new(session, value)
-        unwrapped? ? basic_obj : basic_obj.wrapper
-      end
-
-      def identify_entity(data)
-        self_string = data[:self]
-        if self_string
-          if self_string.include?('node')
-            :node
-          elsif self_string.include?('relationship')
-            :relationship
-          end
-        elsif %i[nodes relationships start end length].all? { |k| data.key?(k) }
-          :path
-        end
-      end
-
-      def looks_like_an_object?(value)
-        value[:labels] || value[:type]
-      end
-
-      def unwrapped!
-        @_unwrapped_obj = true
-      end
-
-      def unwrapped?
-        !!@_unwrapped_obj
-      end
-
-      def node?(value)
-        value[:labels]
-      end
-
-      attr_reader :struct
-
-      def initialize(response, uncommited = false)
-        @response = response
-        @uncommited = uncommited
-      end
-
-      def entity_data(id = nil)
-        if @uncommited
-          data = @data.first[:row].first
-          data.is_a?(Hash) ? {data: data, id: id} : data
-        else
-          data = @data[0][0]
-          data.is_a?(Hash) ? add_entity_id(data) : data
-        end
-      end
-
-      def first_data
-        if @uncommited
-          @data.first[:row].first
-        else
-          data = @data[0][0]
-          data.is_a?(Hash) ? add_entity_id(data) : data
-        end
-      end
-
-      def add_entity_id(data)
-        data[:id] = if data[:metadata] && data[:metadata][:id]
-                      data[:metadata][:id]
-                    else
-                      data[:self].split('/')[-1].to_i
-                    end
-        data
-      end
-
-      def error?
-        !!@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?
-        RETRYABLE_ERROR_STATUSES.include?(@error_status)
-      end
-
-      def data?
-        !response.body[:data].nil?
-      end
-
-      def raise_unless_response_code(code)
-        fail "Response code #{response.status}, expected #{code} for #{response.headers[:location]}, #{response.body}" unless response.status == code
-      end
-
-      def each_data_row
-        data.each do |r|
-          yieldable = if @uncommitted
-                        r[:row]
-                      else
-                        transaction_row?(r) ? r[:rest] : r
-                      end
-          yield yieldable
-        end
-      end
-
-      def transaction_response?
-        response.respond_to?(:body) && !response.body[:commit].nil?
-      end
-
-      def set_data(response)
-        @data = response[:data]
-        @columns = response[:columns]
-        @struct = @columns.empty? ? Object.new : Struct.new(*@columns.map(&:to_sym))
-        self
-      end
-
-      def set_error(error)
-        @error = true
-        @error_msg = error[:message]
-        @error_status = error[:status] || error[:exception] || error[:code]
-        @error_code = error[:code] || error[:fullname]
-        self
-      end
-
-      CONSTRAINT_ERROR = 'Neo.ClientError.Schema.ConstraintViolation'
-      def raise_error
-        fail 'Tried to raise error without an error' unless @error
-        error_class = constraint_error? ? ConstraintViolationError : ResponseError
-        fail error_class.new(@error_msg, @error_status, @error_code)
-      end
-
-      def constraint_error?
-        @error_code == CONSTRAINT_ERROR || (@error_msg || '').include?('already exists with')
-      end
-
-      def raise_cypher_error
-        fail 'Tried to raise error without an error' unless @error
-        fail Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
-      end
-
-
-      def self.create_with_no_tx(response)
-        case response.status
-        when 200 then new(response).set_data(response.body)
-        when 400 then new(response).set_error(response.body)
-        else
-          fail "Unknown response code #{response.status} for #{response.env[:url]}"
-        end
-      end
-
-      def self.create_with_tx(response)
-        fail "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
-
-        new(response, true).tap do |cr|
-          body = response.body
-          body[:errors].empty? ? cr.set_data(body[:results].first) : cr.set_error(body[:errors].first)
-        end
-      end
-
-      private
-
-      def transaction_row?(row)
-        row.is_a?(Hash) && row[:rest] && row[:row]
-      end
-    end
-  end
-end

data/lib/neo4j-server/cypher_session.rb

@@ -1,263 +0,0 @@
-require 'uri'
-
-module Neo4j
-  module Server
-    Neo4j::Session.register_db(:server_db) do |endpoint_url, url_opts|
-      Neo4j::Server::CypherSession.open(endpoint_url, url_opts)
-    end
-
-    class CypherSession < Neo4j::Session
-      include Resource
-
-      alias super_query query
-      attr_reader :connection
-
-      def initialize(data_url, connection)
-        @connection = connection
-        Neo4j::Session.register(self)
-        initialize_resource(data_url)
-        Neo4j::Session._notify_listeners(:session_available, self)
-      end
-
-      # @param [Hash] params could be empty or contain basic authentication user and password
-      # @return [Faraday]
-      # @see https://github.com/lostisland/faraday
-      def self.create_connection(params, url = nil)
-        init_params = params[:initialize] && params.delete(:initialize)
-        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, ::Logger.new(STDOUT), bodies: true
-
-          b.response :multi_json, symbolize_keys: true, content_type: 'application/json'
-          # b.use Faraday::Response::RaiseError
-          require 'typhoeus'
-          require 'typhoeus/adapters/faraday'
-          b.adapter :typhoeus
-          # b.adapter  Faraday.default_adapter
-        end
-        conn.headers = {'Content-Type' => 'application/json', 'User-Agent' => ::Neo4j::Session.user_agent_string}
-        conn
-      end
-
-      # Opens a session to the database
-      # @see Neo4j::Session#open
-      #
-      # @param [String] endpoint_url - the url to the neo4j server, defaults to 'http://localhost:7474'
-      # @param [Hash] params faraday params, see #create_connection or an already created faraday connection
-      def self.open(endpoint_url = nil, params = {})
-        extract_basic_auth(endpoint_url, params)
-        url = endpoint_url || 'http://localhost:7474'
-        connection = params[:connection] || create_connection(params, url)
-        response = connection.get(url)
-        fail "Server not available on #{url} (response code #{response.status})" unless response.status == 200
-        establish_session(response.body, connection)
-      end
-
-      def self.establish_session(root_data, connection)
-        data_url = root_data[:data]
-        data_url << '/' unless data_url.nil? || data_url.end_with?('/')
-        CypherSession.new(data_url, connection)
-      end
-
-      def self.extract_basic_auth(url, params)
-        return unless url && URI(url).userinfo
-        params[:basic_auth] = {username: URI(url).user, password: URI(url).password}
-      end
-
-      private_class_method :extract_basic_auth
-
-      def db_type
-        :server_db
-      end
-
-      def to_s
-        "#{self.class} url: '#{@resource_url}'"
-      end
-
-      def inspect
-        "#{self} version: '#{version}'"
-      end
-
-      def version
-        resource_data ? resource_data[:neo4j_version] : ''
-      end
-
-      def initialize_resource(data_url)
-        response = @connection.get(data_url)
-        expect_response_code!(response, 200)
-        data_resource = response.body
-        fail "No data_resource for #{response.body}" unless data_resource
-        # store the resource data
-        init_resource_data(data_resource, data_url)
-      end
-
-      def self.transaction_class
-        Neo4j::Server::CypherTransaction
-      end
-
-      # 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 = [])
-        label_string = labels.empty? ? '' : (':' + labels.map { |k| "`#{k}`" }.join(':'))
-        if !props.nil?
-          prop = '{props}'
-          props.each_key { |k| props.delete(k) if props[k].nil? }
-        end
-
-        id = _query_or_fail("CREATE (n#{label_string} #{prop}) RETURN ID(n)", true, props: props)
-        CypherNode.new(self, props.nil? ? id : {id: id, metadata: {labels: labels}, data: props})
-      end
-
-      def load_node(neo_id)
-        query.unwrapped.match(:n).where(n: {neo_id: neo_id}).pluck(:n).first
-      end
-
-      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 =~ /not found$/
-
-        raise cypher_error
-      end
-
-      def create_label(name)
-        CypherLabel.new(self, name)
-      end
-
-      def uniqueness_constraints(label)
-        schema_properties("/db/data/schema/constraint/#{label}/uniqueness")
-      end
-
-      def indexes(label)
-        schema_properties("/db/data/schema/index/#{label}")
-      end
-
-      def schema_properties(query_string)
-        response = @connection.get(query_string)
-        expect_response_code!(response, 200)
-        {property_keys: response.body.map! { |row| row[:property_keys].map(&:to_sym) }}
-      end
-
-      def find_all_nodes(label_name)
-        search_result_to_enumerable_first_column(_query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)"))
-      end
-
-      def find_nodes(label_name, key, value)
-        value = "'#{value}'" if value.is_a? String
-
-        response = _query_or_fail("MATCH (n:`#{label_name}`) WHERE n.#{key} = #{value} RETURN ID(n)")
-        search_result_to_enumerable_first_column(response)
-      end
-
-      def query(*args)
-        if [[String], [String, Hash]].include?(args.map(&:class))
-          response = _query(*args)
-          response.raise_error if response.error?
-          response.to_node_enumeration(args[0])
-        else
-          options = args[0] || {}
-          Neo4j::Core::Query.new(options.merge(session: self))
-        end
-      end
-
-      def _query_data(query)
-        r = _query_or_fail(query, true)
-        Neo4j::Transaction.current ? r : r[:data]
-      end
-
-      DEFAULT_RETRY_COUNT = ENV['NEO4J_RETRY_COUNT'].nil? ? 10 : ENV['NEO4J_RETRY_COUNT'].to_i
-
-      def _query_or_fail(query, single_row = false, params = {}, retry_count = DEFAULT_RETRY_COUNT)
-        query, params = query_and_params(query, params)
-
-        response = _query(query, params)
-        if response.error?
-          _retry_or_raise(query, params, single_row, retry_count, response)
-        else
-          single_row ? response.first_data : response
-        end
-      end
-
-      def query_and_params(query_or_query_string, params)
-        if query_or_query_string.is_a?(::Neo4j::Core::Query)
-          cypher = query_or_query_string.to_cypher
-          [cypher, query_or_query_string.send(:merge_params).merge(params)]
-        else
-          [query_or_query_string, params]
-        end
-      end
-
-      def _retry_or_raise(query, params, single_row, retry_count, response)
-        response.raise_error unless response.retryable_error?
-        retry_count > 0 ? _query_or_fail(query, single_row, params, retry_count - 1) : response.raise_error
-      end
-
-      def _query_entity_data(query, id = nil, params = {})
-        _query(query, params).tap(&:raise_if_cypher_error!).entity_data(id)
-      end
-
-      def _query(query, params = {}, options = {})
-        query, params = query_and_params(query, params)
-
-        ActiveSupport::Notifications.instrument('neo4j.cypher_query', params: params, context: options[:context],
-                                                                      cypher: query, pretty_cypher: options[:pretty_cypher]) do
-          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)
-            CypherResponse.create_with_no_tx(response)
-          end
-        end
-      end
-
-      def search_result_to_enumerable_first_column(response)
-        return [] unless response.data
-
-        Enumerator.new do |yielder|
-          response.data.each do |data|
-            if current_transaction
-              data[:row].each do |id|
-                yielder << CypherNode.new(self, id).wrapper
-              end
-            else
-              yielder << CypherNode.new(self, data[0]).wrapper
-            end
-          end
-        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].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}")
-        end
-      end
-    end
-  end
-end