activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/migrations/runner.rb

@@ -0,0 +1,195 @@
+module Neo4j
+  module Migrations
+    class Runner
+      STATUS_TABLE_FORMAT = '%-10s %-20s %s'.freeze
+      SEPARATOR = '--------------------------------------------------'.freeze
+      FILE_MISSING = '**** file missing ****'.freeze
+      STATUS_TABLE_HEADER = ['Status'.freeze, 'Migration ID'.freeze, 'Migration Name'.freeze].freeze
+      UP_MESSAGE = 'up'.freeze
+      DOWN_MESSAGE = 'down'.freeze
+      INCOMPLETE_MESSAGE = 'incomplete'.freeze
+      MIGRATION_RUNNING = {up: 'running'.freeze, down: 'reverting'.freeze}.freeze
+      MIGRATION_DONE = {up: 'migrated'.freeze, down: 'reverted'.freeze}.freeze
+
+      def initialize(options = {})
+        @silenced = options[:silenced] || !!ENV['MIGRATIONS_SILENCED']
+        label = SchemaMigration.mapped_label
+        label.create_constraint(:migration_id, type: :unique) unless label.constraint?(:migration_id)
+        @schema_migrations = SchemaMigration.all.to_a
+        @up_versions = SortedSet.new(@schema_migrations.map(&:migration_id))
+      end
+
+      def all
+        handle_incomplete_states!
+        migration_files.each do |migration_file|
+          next if up?(migration_file.version)
+          migrate(:up, migration_file)
+        end
+      end
+
+      def up(version)
+        handle_incomplete_states!
+        migration_file = find_by_version!(version)
+        return if up?(version)
+        migrate(:up, migration_file)
+      end
+
+      def down(version)
+        handle_incomplete_states!
+        migration_file = find_by_version!(version)
+        return unless up?(version)
+        migrate(:down, migration_file)
+      end
+
+      def rollback(steps)
+        handle_incomplete_states!
+        @up_versions.to_a.reverse.first(steps).each do |version|
+          down(version)
+        end
+      end
+
+      def pending_migrations
+        all_migrations.select { |migration| !up?(migration) }
+      end
+
+      def complete_migration_versions
+        @schema_migrations.map(&:migration_id)
+      end
+
+      def mark_versions_as_complete(versions)
+        Neo4j::ActiveBase.new_query
+                         .with('{versions} AS versions').params(versions: versions).break
+                         .unwind(version: :versions).break
+                         .merge('(:`Neo4j::Migrations::SchemaMigration` {migration_id: version})')
+                         .exec
+      end
+
+      def status
+        output STATUS_TABLE_FORMAT, *STATUS_TABLE_HEADER
+        output SEPARATOR
+        all_migrations.each do |version|
+          status = migration_status(version)
+          migration_file = find_by_version(version)
+          migration_name = migration_file ? migration_file.class_name : FILE_MISSING
+          output STATUS_TABLE_FORMAT, status, version, migration_name
+        end
+      end
+
+      def resolve(version)
+        SchemaMigration.find_by!(migration_id: version).update!(incomplete: false)
+        output "Migration #{version} resolved."
+      end
+
+      def reset(version)
+        SchemaMigration.find_by!(migration_id: version).destroy
+        output "Migration #{version} reset."
+      end
+
+      private
+
+      def migration_status(version)
+        return DOWN_MESSAGE unless up?(version)
+        incomplete_states.find { |v| v.migration_id == version } ? INCOMPLETE_MESSAGE : UP_MESSAGE
+      end
+
+      def handle_incomplete_states!
+        return unless incomplete_states.any?
+        incomplete_versions = incomplete_states.map(&:migration_id)
+        fail MigrationError, <<-MSG
+There are migrations struck in an incomplete states, that could not be fixed automatically:
+#{incomplete_versions.join('\n')}
+This can happen when there's a critical error inside a migration.
+
+If you think they were was completed correctly, run:
+
+#{task_migration_messages('resolve', incomplete_versions)}
+
+If you want to reset and run the migration again, run:
+
+#{task_migration_messages('reset', incomplete_versions)}
+
+MSG
+      end
+
+      def task_migration_messages(type, versions)
+        versions.map do |version|
+          "rake neo4j:migrate:#{type} VERSION=#{version}"
+        end.join("\n")
+      end
+
+      def up?(version)
+        @up_versions.include?(version)
+      end
+
+      def migrate(direction, migration_file)
+        migration_message(direction, migration_file) do
+          migration = migration_file.create(silenced: @silenced)
+          migration.migrate(direction)
+        end
+      end
+
+      def migration_message(direction, migration)
+        output_migration_message "#{migration.version} #{migration.class_name}: #{MIGRATION_RUNNING[direction]}..."
+        time = format('%.4fs', yield)
+        output_migration_message "#{migration.version} #{migration.class_name}: #{MIGRATION_DONE[direction]} (#{time})"
+        output ''
+      end
+
+      def output(*string_format)
+        puts format(*string_format) unless @silenced
+      end
+
+      def output_migration_message(message)
+        out = "== #{message} "
+        tail = '=' * [0, 80 - out.length].max
+        output "#{out}#{tail}"
+      end
+
+      def find_by_version!(version)
+        find_by_version(version) || fail(UnknownMigrationVersionError, "No such migration #{version}")
+      end
+
+      def find_by_version(version)
+        migration_files.find { |file| file.version == version }
+      end
+
+      def all_migrations
+        @up_versions + migration_files_versions
+      end
+
+      def incomplete_states
+        @incomplete_states ||= SortedSet.new(@schema_migrations.select(&:incomplete?))
+      end
+
+      delegate :migration_files, :migration_files_versions, to: :class
+
+      class <<self
+        def migration_files_versions
+          migration_files.map!(&:version)
+        end
+
+        def migration_files
+          files.map! { |file_path| MigrationFile.new(file_path) }
+        end
+
+        def latest_migration
+          migration_files.last
+        end
+
+        def files
+          Dir[files_path].sort
+        end
+
+        private
+
+        def files_path
+          app_root.join('db', 'neo4j', 'migrate', '*.rb')
+        end
+
+        def app_root
+          defined?(Rails) ? Rails.root : Pathname.new('.')
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/schema.rb

@@ -0,0 +1,44 @@
+module Neo4j
+  module Migrations
+    module Schema
+      class << self
+        def fetch_schema_data(session)
+          {constraints: fetch_constraint_descriptions(session).sort,
+           indexes: fetch_index_descriptions(session).sort}
+        end
+
+        def synchronize_schema_data(session, schema_data, remove_missing)
+          queries = []
+          queries += drop_and_create_queries(fetch_constraint_descriptions(session), schema_data[:constraints], remove_missing)
+          queries += drop_and_create_queries(fetch_index_descriptions(session), schema_data[:indexes], remove_missing)
+          session.queries do
+            queries.each { |query| append query }
+          end
+        end
+
+        private
+
+        def fetch_constraint_descriptions(session)
+          session.query('CALL db.constraints()').map(&:description)
+        end
+
+        def fetch_index_descriptions(session)
+          session.query('CALL db.indexes()').reject do |row|
+            # These indexes are created automagically when the corresponding constraints are created
+            row.type == 'node_unique_property'
+          end.map(&:description)
+        end
+
+        def drop_and_create_queries(existing, specified, remove_missing)
+          [].tap do |queries|
+            if remove_missing
+              (existing - specified).each { |description| queries << "DROP #{description}" }
+            end
+
+            (specified - existing).each { |description| queries << "CREATE #{description}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/migrations/schema_migration.rb

@@ -0,0 +1,14 @@
+module Neo4j
+  module Migrations
+    class SchemaMigration
+      include Neo4j::ActiveNode
+      id_property :migration_id
+      property :migration_id, type: String
+      property :incomplete, type: Boolean
+
+      def <=>(other)
+        migration_id <=> other.migration_id
+      end
+    end
+  end
+end

data/lib/neo4j/model_schema.rb

@@ -0,0 +1,139 @@
+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
+        return @model_constraints if @model_constraints
+
+        constraints = Neo4j::Transaction.constraints.each_with_object({}) do |row, result|
+          result[row[:label]] ||= []
+          result[row[:label]] << row[:properties]
+        end
+
+        @model_constraints = schema_elements_list(MODEL_CONSTRAINTS, constraints)
+      end
+
+      def model_indexes
+        return @model_indexes if @model_indexes
+
+        indexes = Neo4j::Transaction.indexes.each_with_object({}) do |row, result|
+          result[row[:label]] ||= []
+          result[row[:label]] << row[:properties]
+        end
+
+        @model_indexes = 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 ensure_model_data_state!
+        # If we load a new model, reset everything
+        if @previously_loaded_models_count != Neo4j::ActiveNode.loaded_classes.size
+          # Make sure we've finalized id_property details and have called
+          # add_ constraint/index methods above
+          Neo4j::ActiveNode.loaded_classes.each(&:ensure_id_property_info!)
+          reload_models_data!
+        end
+      end
+
+      def reload_models_data!
+        @previously_loaded_models_count = Neo4j::ActiveNode.loaded_classes.size
+        @model_indexes = @model_constraints = nil
+      end
+
+      def legacy_model_schema_informations
+        ensure_model_data_state!
+        data = {index: [], constraint: []}
+        each_schema_element do |type, model, label, property_name|
+          data[type] << {label: label, property_name: property_name, model: model}
+        end
+        data
+      end
+
+      def validate_model_schema!
+        ensure_model_data_state!
+        messages = {index: [], constraint: []}
+        each_schema_element do |type, model, label, property_name, exists|
+          if exists
+            log_warning!(type, model, property_name) if model.id_property_name.to_sym != property_name
+          else
+            messages[type] << force_add_message(type, label, property_name)
+          end
+        end
+
+        return if messages.values.all?(&:empty?)
+
+        fail ::Neo4j::DeprecatedSchemaDefinitionError, validation_error_message(messages)
+      end
+
+      def validation_error_message(messages)
+        <<MSG
+          Some schema elements were defined by the model (which is no longer supported), but they do not exist in the database.  Run the following to create them if you haven't already:
+
+#{messages[:constraint].join("\n")}
+#{messages[:index].join("\n")}
+
+And then run `rake neo4j:migrate`
+
+(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
+
+      private
+
+      def each_schema_element
+        [[:constraint, model_constraints], [:index, model_indexes]].each do |type, schema_elements|
+          schema_elements.each do |args|
+            yield(type, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/paginated.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  class Paginated
+    include Enumerable
+    attr_reader :items, :total, :current_page
+
+    def initialize(items, total, current_page)
+      @items = items
+      @total = total
+      @current_page = current_page
+    end
+
+    def self.create_from(source, page, per_page, order = nil)
+      target = source.node_var || source.identity
+      partial = source.skip((page - 1) * per_page).limit(per_page)
+      ordered_partial, ordered_source = if order
+                                          [partial.order_by(order), source.query.with("#{target} as #{target}").pluck("COUNT(#{target})").first]
+                                        else
+                                          [partial, source.count]
+                                        end
+      Paginated.new(ordered_partial, ordered_source, page)
+    end
+
+    delegate :each, to: :items
+    delegate :pluck, to: :items
+    delegate :size, :[], to: :items
+  end
+end

data/lib/neo4j/railtie.rb

@@ -0,0 +1,105 @@
+require 'active_support/notifications'
+require 'rails/railtie'
+# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
+require 'action_dispatch/railtie'
+require 'neo4j/core/driver'
+
+module Neo4j
+  class Railtie < ::Rails::Railtie
+    def empty_config
+      ActiveSupport::OrderedOptions.new.tap { |cfg| cfg.session = ActiveSupport::OrderedOptions.new }
+    end
+
+    config.neo4j = empty_config
+
+    if defined?(ActiveSupport::Reloader)
+      ActiveSupport::Reloader.to_prepare do
+        Neo4j::ActiveNode::Labels::Reloading.reload_models!
+      end
+    elsif const_defined?(:ActionDispatch)
+      ActionDispatch::Reloader.to_prepare do
+        Neo4j::ActiveNode::Labels::Reloading.reload_models!
+      end
+    end
+
+    # Rescue responses similar to ActiveRecord.
+    config.action_dispatch.rescue_responses.merge!(
+      'Neo4j::RecordNotFound' => :not_found,
+      'Neo4j::ActiveNode::Labels::RecordNotFound' => :not_found
+    )
+
+    # Add ActiveModel translations to the I18n load_path
+    initializer 'i18n' do
+      config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]
+    end
+
+    console do
+      Neo4j::Config[:logger] = ActiveSupport::Logger.new(STDOUT)
+      Neo4j::Config[:verbose_query_logs] = false
+    end
+
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer 'neo4j.start', after: :load_config_initializers do |app|
+      app.config.neo4j.skip_migration_check = true if Rails.env.test?
+
+      neo4j_config = ActiveSupport::OrderedOptions.new
+      app.config.neo4j.each { |k, v| neo4j_config[k] = v } if app.config.neo4j
+
+      Neo4j::Config.configuration.merge!(neo4j_config.to_h)
+
+      Neo4j::ActiveBase.on_establish_session { setup! neo4j_config }
+
+      Neo4j::Config[:logger] ||= Rails.logger
+
+      if Neo4j::Config.fail_on_pending_migrations
+        config.app_middleware.insert_after ::ActionDispatch::Callbacks, Neo4j::Migrations::CheckPending
+      end
+    end
+
+    def setup!(neo4j_config = empty_config)
+      url, path, options = final_session_config!(neo4j_config).values_at(:url, :path, :options)
+      options ||= {}
+      register_neo4j_cypher_logging
+
+      Neo4j::ActiveBase.new_driver( url || path || default_session_path_or_url, options)
+    end
+
+    def final_session_config!(neo4j_config)
+      (neo4j_config[:session].empty? ? yaml_config_data : neo4j_config[:session]).dup
+    end
+
+    def default_session_path_or_url
+      ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] || 'http://localhost:7474'
+    end
+
+    def yaml_config_data
+      @yaml_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
+
+    def register_neo4j_cypher_logging
+      return if @neo4j_cypher_logging_registered
+
+      Neo4j::Core::Query.pretty_cypher = Neo4j::Config[:pretty_logged_cypher_queries]
+
+      logger_proc = ->(message) do
+        (Neo4j::Config[:logger] ||= Rails.logger).debug message
+      end
+      Neo4j::Transaction.subscribe_to_query(&logger_proc)
+      Neo4j::Transaction.subscribe_to_request(&logger_proc)
+
+      @neo4j_cypher_logging_registered = true
+    end
+  end
+end