neo4j 7.2.3 → 8.0.0.alpha.1

data/lib/neo4j/migrations/schema_migration.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module Migrations
+    class SchemaMigration
+      include Neo4j::ActiveNode
+      id_property :migration_id
+      property :migration_id, type: String
+    end
+  end
+end

data/lib/neo4j/model_schema.rb

@@ -0,0 +1,100 @@
+require 'set'
+module Neo4j
+  # This is here to support the removed functionality of being able to
+  # defined indexes and constraints on models
+  # This code should be removed later
+  module ModelSchema
+    MODEL_INDEXES = {}
+    MODEL_CONSTRAINTS = {}
+    REQUIRED_INDEXES = {}
+
+    class << self
+      def add_defined_constraint(model, property_name)
+        MODEL_CONSTRAINTS[model] ||= Set.new
+        MODEL_CONSTRAINTS[model] << property_name.to_sym
+      end
+
+      def add_defined_index(model, property_name)
+        MODEL_INDEXES[model] ||= Set.new
+        MODEL_INDEXES[model] << property_name.to_sym
+      end
+
+      def add_required_index(model, property_name)
+        REQUIRED_INDEXES[model] ||= Set.new
+        REQUIRED_INDEXES[model] << property_name.to_sym
+      end
+
+      def defined_constraint?(model, property_name)
+        MODEL_CONSTRAINTS[model] &&
+          MODEL_CONSTRAINTS[model].include?(property_name.to_sym)
+      end
+
+      def model_constraints
+        constraints = Neo4j::ActiveBase.current_session.constraints.each_with_object({}) do |row, result|
+          result[row[:label]] ||= []
+          result[row[:label]] << row[:properties]
+        end
+
+        schema_elements_list(MODEL_CONSTRAINTS, constraints)
+      end
+
+      def model_indexes
+        indexes = Neo4j::ActiveBase.current_session.indexes.each_with_object({}) do |row, result|
+          result[row[:label]] ||= []
+          result[row[:label]] << row[:properties]
+        end
+
+        schema_elements_list(MODEL_INDEXES, indexes) +
+          schema_elements_list(REQUIRED_INDEXES, indexes).reject(&:last)
+        # reject required indexes which are already in the DB
+      end
+
+      # should be private
+      def schema_elements_list(by_model, db_results)
+        by_model.flat_map do |model, property_names|
+          label = model.mapped_label_name.to_sym
+          property_names.map do |property_name|
+            exists = db_results[label] && db_results[label].include?([property_name])
+            [model, label, property_name, exists]
+          end
+        end
+      end
+
+      def validate_model_schema!
+        messages = {index: [], constraint: []}
+        [[:constraint, model_constraints], [:index, model_indexes]].each do |type, schema_elements|
+          schema_elements.map do |model, label, property_name, exists|
+            if exists
+              log_warning!(type, model, property_name)
+            else
+              messages[type] << force_add_message(type, label, property_name)
+            end
+          end
+        end
+
+        return if messages.values.all?(&:empty?)
+
+        fail validation_error_message(messages)
+      end
+
+      def validation_error_message(messages)
+        <<MSG
+          Some schema elements were defined by the model (which is no longer support), but they do not exist in the database.  Run the following to create them:
+
+#{messages[:constraint].join("\n")}
+#{messages[:index].join("\n")}
+
+(zshell users may need to escape the brackets)
+MSG
+      end
+
+      def force_add_message(index_or_constraint, label, property_name)
+        "rake neo4j:generate_schema_migration[#{index_or_constraint},#{label},#{property_name}]"
+      end
+
+      def log_warning!(index_or_constraint, model, property_name)
+        Neo4j::ActiveBase.logger.warn "WARNING: The #{index_or_constraint} option is no longer supported (Defined on #{model.name} for #{property_name})"
+      end
+    end
+  end
+end

data/lib/neo4j/railtie.rb

@@ -1,7 +1,11 @@
 require 'active_support/notifications'
 require 'rails/railtie'
+require 'neo4j/session_manager'
 # Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
 require 'action_dispatch/railtie'
+require 'neo4j/core/cypher_session/adaptors/http'
+require 'neo4j/core/cypher_session/adaptors/bolt'
+require 'neo4j/core/cypher_session/adaptors/embedded'
 
 module Neo4j
   class Railtie < ::Rails::Railtie
@@ -39,131 +43,46 @@ module Neo4j
       load 'neo4j/tasks/migration.rake'
     end
 
-    class << self
-      def java_platform?
-        RUBY_PLATFORM =~ /java/
-      end
-
-      def setup_default_session(cfg)
-        setup_config_defaults!(cfg)
-
-        return if !cfg.sessions.empty?
-
-        cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options.merge(default: true)}
-      end
-
-      def setup_config_defaults!(cfg)
-        cfg.session_type ||= default_session_type
-        cfg.session_path ||= default_session_path
-        cfg.session_options ||= {}
-        cfg.sessions ||= []
-      end
-
-      def config_data
-        @config_data ||= if yaml_path
-                           HashWithIndifferentAccess.new(YAML.load(ERB.new(yaml_path.read).result)[Rails.env])
-                         else
-                           {}
-                         end
-      end
-
-      def yaml_path
-        @yaml_path ||= %w(config/neo4j.yml config/neo4j.yaml).map do |path|
-          Rails.root.join(path)
-        end.detect(&:exist?)
-      end
-
-      def default_session_type
-        type = ENV['NEO4J_TYPE'] || config_data[:type] || :server_db
-        type.to_sym
-      end
-
-      def default_session_path
-        ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] ||
-          config_data[:url] || config_data[:path] ||
-          'http://localhost:7474'
-      end
+    console do |app|
+      Neo4j::Config[:logger] = ActiveSupport::Logger.new(STDOUT)
 
-      def start_embedded_session(session)
-        # See https://github.com/jruby/jruby/wiki/UnlimitedStrengthCrypto
-        security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
-        restricted_field = security_class.get_declared_field('isRestricted')
-        restricted_field.accessible = true
-        restricted_field.set nil, false
-        session.start
-      end
+      register_neo4j_cypher_logging(app.config.neo4j.sessions.map { |s| s[:type] })
+    end
 
-      def open_neo4j_session(options, wait_for_connection = false)
-        type, name, default, path = options.values_at(:type, :name, :default, :path)
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer 'neo4j.start', after: :load_config_initializers do |app|
+      cfg = app.config.neo4j
+      # Set Rails specific defaults
+      Neo4j::SessionManager.setup! cfg
 
-        if !java_platform? && type == :embedded_db
-          fail "Tried to start embedded Neo4j db without using JRuby (got #{RUBY_PLATFORM}), please run `rvm jruby`"
-        end
+      Neo4j::Config[:logger] ||= Rails.logger
 
-        session = wait_for_value(wait_for_connection) do
-          if options.key?(:name)
-            Neo4j::Session.open_named(type, name, default, path)
-          else
-            Neo4j::Session.open(type, path, options[:options])
-          end
-        end
+      session_types = cfg.sessions.map { |session_opts| session_opts[:type] }
 
-        start_embedded_session(session) if type == :embedded_db
-      end
+      register_neo4j_cypher_logging(session_types)
     end
 
-    def wait_for_value(wait)
-      session = nil
-      Timeout.timeout(60) do
-        until session
-          begin
-            if session = yield
-              puts
-              return session
-            end
-          rescue Faraday::ConnectionFailed => e
-            raise e if !wait
-
-            putc '.'
-            sleep(1)
-          end
-        end
-      end
-    end
+    TYPE_SUBSCRIBERS = {
+      http: Neo4j::Core::CypherSession::Adaptors::HTTP.method(:subscribe_to_request),
+      bolt: Neo4j::Core::CypherSession::Adaptors::Bolt.method(:subscribe_to_request),
+      embedded: Neo4j::Core::CypherSession::Adaptors::Embedded.method(:subscribe_to_transaction)
+    }
 
-    def register_neo4j_cypher_logging
+    def register_neo4j_cypher_logging(session_types)
       return if @neo4j_cypher_logging_registered
 
       Neo4j::Core::Query.pretty_cypher = Neo4j::Config[:pretty_logged_cypher_queries]
 
-      Neo4j::Server::CypherSession.log_with do |message|
-        (Neo4j::Config[:logger] || Rails.logger).debug message
+      logger_proc = ->(message) do
+        (Neo4j::Config[:logger] ||= Rails.logger).debug message
       end
-
-      @neo4j_cypher_logging_registered = true
-    end
-
-    console do
-      Neo4j::Config[:logger] = ActiveSupport::Logger.new(STDOUT)
-
-      register_neo4j_cypher_logging
-    end
-
-    # Starting Neo after :load_config_initializers allows apps to
-    # register migrations in config/initializers
-    initializer 'neo4j.start', after: :load_config_initializers do |app|
-      cfg = app.config.neo4j
-      # Set Rails specific defaults
-      Neo4j::Railtie.setup_default_session(cfg)
-
-      cfg.sessions.each do |session_opts|
-        Neo4j::Railtie.open_neo4j_session(session_opts, cfg.wait_for_connection)
+      Neo4j::Core::CypherSession::Adaptors::Base.subscribe_to_query(&logger_proc)
+      session_types.map(&:to_sym).uniq.each do |type|
+        TYPE_SUBSCRIBERS[type].call(&logger_proc)
       end
-      Neo4j::Config.configuration.merge!(cfg.to_hash)
 
-      Neo4j::Config[:logger] ||= Rails.logger
-
-      register_neo4j_cypher_logging
+      @neo4j_cypher_logging_registered = true
     end
   end
 end

data/lib/neo4j/schema/operation.rb

@@ -1,10 +1,15 @@
 module Neo4j
   module Schema
     class Operation
-      attr_reader :label_name, :property, :options
+      attr_reader :label, :property, :options
+
+      def initialize(label, property, options = default_options)
+        @label = if label.is_a?(Neo4j::Core::Label)
+                   label
+                 else
+                   Neo4j::Core::Label.new(label, ActiveBase.current_session)
+                 end
 
-      def initialize(label_name, property, options = default_options)
-        @label_name = label_name.to_sym
         @property = property.to_sym
         @options = options
       end
@@ -13,14 +18,14 @@ module Neo4j
         []
       end
 
+      def label_object
+        label
+      end
+
       def create!
         drop_incompatible!
         return if exist?
-        label_object.send(:"create_#{type}", property, options)
-      end
-
-      def label_object
-        @label_object ||= Neo4j::Label.create(label_name)
+        schema_query(:"create_#{type}")
       end
 
       def incompatible_operation_classes
@@ -28,12 +33,12 @@ module Neo4j
       end
 
       def drop!
-        label_object.send(:"drop_#{type}", property, options)
+        schema_query(:"drop_#{type}")
       end
 
       def drop_incompatible!
         incompatible_operation_classes.each do |clazz|
-          operation = clazz.new(label_name, property)
+          operation = clazz.new(@label, property)
           operation.drop! if operation.exist?
         end
       end
@@ -49,6 +54,12 @@ module Neo4j
       def type
         fail 'Abstract class, not implemented'
       end
+
+      private
+
+      def schema_query(method)
+        label.send(method, property, options)
+      end
     end
 
     class ExactIndexOperation < Neo4j::Schema::Operation
@@ -61,7 +72,7 @@ module Neo4j
       end
 
       def exist?
-        label_object.indexes[:property_keys].include?([property])
+        label.index?(property)
       end
     end
 
@@ -71,7 +82,7 @@ module Neo4j
       end
 
       def type
-        'constraint'
+        'uniqueness_constraint'
       end
 
       def create!
@@ -80,7 +91,7 @@ module Neo4j
       end
 
       def exist?
-        Neo4j::Label.constraint?(label_name, property)
+        label.uniqueness_constraint?(property)
       end
 
       def default_options

data/lib/neo4j/session_manager.rb

@@ -0,0 +1,137 @@
+require 'active_support/core_ext/hash'
+require 'active_support/ordered_options'
+require 'neo4j/core/cypher_session/adaptors/http'
+require 'neo4j/core/cypher_session/adaptors/bolt'
+require 'neo4j/core/cypher_session/adaptors/embedded'
+
+module Neo4j
+  class SessionManager
+    class << self
+      def setup!(cfg = nil)
+        cfg ||= ActiveSupport::OrderedOptions.new
+
+        setup_default_session(cfg)
+
+        cfg.sessions.each do |session_opts|
+          open_neo4j_session(session_opts, cfg.wait_for_connection)
+        end
+
+        Neo4j::Config.configuration.merge!(cfg.to_h)
+      end
+
+      # TODO: Remove ability for multiple sessions?
+      # Ability to overwrite default session per-model like ActiveRecord?
+      def setup_default_session(cfg)
+        setup_config_defaults!(cfg)
+
+        return if !cfg.sessions.empty?
+
+        cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options.merge(default: true)}
+      end
+
+      # TODO: Support `session_url` config for server mode
+      def setup_config_defaults!(cfg)
+        cfg.session_type ||= default_session_type
+        cfg.session_path ||= default_session_path
+        cfg.session_options ||= {}
+        cfg.sessions ||= []
+      end
+
+      def open_neo4j_session(options, wait_for_connection = false)
+        session_type, path, url = options.values_at(:type, :path, :url)
+
+        enable_unlimited_strength_crypto! if java_platform? && session_type_is_embedded?(session_type)
+
+        adaptor = wait_for_value(wait_for_connection) do
+          cypher_session_adaptor(session_type, url || path, (options[:options] || {}).merge(wrap_level: :proc))
+        end
+
+        Neo4j::ActiveBase.current_adaptor = adaptor
+      end
+
+      protected
+
+      def session_type_is_embedded?(session_type)
+        [:embedded_db, :embedded].include?(session_type)
+      end
+
+      def enable_unlimited_strength_crypto!
+        # See https://github.com/jruby/jruby/wiki/UnlimitedStrengthCrypto
+        security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
+        restricted_field = security_class.get_declared_field('isRestricted')
+        restricted_field.accessible = true
+        restricted_field.set nil, false
+      end
+
+      def config_data
+        @config_data ||= if yaml_path
+                           HashWithIndifferentAccess.new(YAML.load(ERB.new(yaml_path.read).result)[Rails.env])
+                         else
+                           {}
+                         end
+      end
+
+      def yaml_path
+        return unless defined?(Rails)
+        @yaml_path ||= %w(config/neo4j.yml config/neo4j.yaml).map do |path|
+          Rails.root.join(path)
+        end.detect(&:exist?)
+      end
+
+      # TODO: Deprecate embedded_db and http in favor of embedded and http
+      #
+      def cypher_session_adaptor(type, path_or_url, options = {})
+        case type
+        when :embedded_db, :embedded
+          Neo4j::Core::CypherSession::Adaptors::Embedded.new(path_or_url, options)
+        when :http
+          Neo4j::Core::CypherSession::Adaptors::HTTP.new(path_or_url, options)
+        when :bolt
+          Neo4j::Core::CypherSession::Adaptors::Bolt.new(path_or_url, options)
+        else
+          extra = ' (`server_db` has been replaced by `http` or `bolt`)'
+          fail ArgumentError, "Invalid session type: #{type.inspect}#{extra if type.to_sym == :server_db}"
+        end
+      end
+
+      def default_session_type
+        if ENV['NEO4J_URL']
+          URI(ENV['NEO4J_URL']).scheme.tap do |scheme|
+            fail "Invalid scheme for NEO4J_URL: #{scheme}" if !%w(http bolt).include?(scheme)
+          end
+        else
+          ENV['NEO4J_TYPE'] || config_data[:type] || :http
+        end.to_sym
+      end
+
+      def default_session_path
+        ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] ||
+          config_data[:url] || config_data[:path] ||
+          'http://localhost:7474'
+      end
+
+      def java_platform?
+        RUBY_PLATFORM =~ /java/
+      end
+
+      def wait_for_value(wait)
+        session = nil
+        Timeout.timeout(60) do
+          until session
+            begin
+              if session = yield
+                puts
+                return session
+              end
+            rescue Faraday::ConnectionFailed => e
+              raise e if !wait
+
+              putc '.'
+              sleep(1)
+            end
+          end
+        end
+      end
+    end
+  end
+end