activegraph 11.0.0.beta.1-java

data/lib/active_graph/migrations/runner.rb

@@ -0,0 +1,195 @@
+module ActiveGraph
+  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)
+        ActiveGraph::Base.new_query
+                         .with('$versions AS versions').params(versions: versions).break
+                         .unwind(version: :versions).break
+                         .merge('(:`ActiveGraph::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/active_graph/migrations/schema.rb

@@ -0,0 +1,64 @@
+module ActiveGraph
+  module Migrations
+    module Schema
+      class << self
+        def fetch_schema_data
+          {constraints: fetch_constraint_descriptions.sort,
+           indexes: fetch_index_descriptions.sort}
+        end
+
+        def synchronize_schema_data(schema_data, remove_missing)
+          queries = []
+          queries += drop_and_create_queries(fetch_constraint_descriptions, schema_data[:constraints], remove_missing)
+          queries += drop_and_create_queries(fetch_index_descriptions, schema_data[:indexes], remove_missing)
+          ActiveGraph::Base.write_transaction do
+            queries.each(&ActiveGraph::Base.method(:query))
+          end
+        end
+
+        private
+
+        def fetch_constraint_descriptions
+          ActiveGraph::Base.query('CALL db.constraints() YIELD description').map(&:first)
+        end
+
+        def fetch_index_descriptions
+          result = ActiveGraph::Base.query('CALL db.indexes()')
+          if result.keys.include?(:description)
+            v3_indexes(result)
+          else
+            v4_indexes(result)
+          end
+        end
+
+        def v3_indexes(result)
+          result.reject do |row|
+            # These indexes are created automagically when the corresponding constraints are created
+            row[:type] == 'node_unique_property'
+          end.map { |row| row[:description] }
+        end
+
+        def v4_indexes(result)
+          result.reject do |row|
+            # These indexes are created automagically when the corresponding constraints are created
+            row[:uniqueness] == 'UNIQUE'
+          end.map(&method(:description))
+        end
+
+        def description(row)
+          "INDEX FOR (n:#{row[:labelsOrTypes].first}) ON (#{row[:properties].map { |prop| "n.#{prop}" }.join(', ')})"
+        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/active_graph/migrations/schema_migration.rb

@@ -0,0 +1,14 @@
+module ActiveGraph
+  module Migrations
+    class SchemaMigration
+      include ActiveGraph::Node
+      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/active_graph/model_schema.rb

@@ -0,0 +1,139 @@
+require 'set'
+module ActiveGraph
+  # 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 = ActiveGraph::Base.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 = ActiveGraph::Base.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 != ActiveGraph::Node.loaded_classes.size
+          # Make sure we've finalized id_property details and have called
+          # add_ constraint/index methods above
+          ActiveGraph::Node.loaded_classes.each(&:ensure_id_property_info!)
+          reload_models_data!
+        end
+      end
+
+      def reload_models_data!
+        @previously_loaded_models_count = ActiveGraph::Node.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 ::ActiveGraph::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)
+        ActiveGraph::Base.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/active_graph/node.rb

@@ -0,0 +1,110 @@
+module ActiveGraph
+  # Makes Neo4j nodes and relationships behave like ActiveRecord objects.
+  # By including this module in your class it will create a mapping for the node to your ruby class
+  # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
+  # will check if there is a ruby class for the labels it has.
+  # If there Ruby class with the same name as the label then the Neo4j node will be wrapped
+  # in a new object of that class.
+  #
+  # = ClassMethods
+  # * {ActiveGraph::Node::Labels::ClassMethods} defines methods like: <tt>index</tt> and <tt>find</tt>
+  # * {ActiveGraph::Node::Persistence::ClassMethods} defines methods like: <tt>create</tt> and <tt>create!</tt>
+  # * {ActiveGraph::Node::Property::ClassMethods} defines methods like: <tt>property</tt>.
+  #
+  # @example Create a Ruby wrapper for a Neo4j Node
+  #   class Company
+  #      include ActiveGraph::Node
+  #      property :name
+  #   end
+  #   company = Company.new
+  #   company.name = 'My Company AB'
+  #   Company.save
+  #
+  module Node
+    extend ActiveSupport::Concern
+
+    MARSHAL_INSTANCE_VARIABLES = [:@attributes, :@_persisted_obj, :@default_property_value]
+
+    include ActiveGraph::Shared
+    include ActiveGraph::Shared::Identity
+    include ActiveGraph::Shared::Marshal
+    include ActiveGraph::Node::Initialize
+    include ActiveGraph::Node::IdProperty
+    include ActiveGraph::Shared::SerializedProperties
+    include ActiveGraph::Node::Property
+    include ActiveGraph::Node::Reflection
+    include ActiveGraph::Node::Persistence
+    include ActiveGraph::Node::Validations
+    include ActiveGraph::Node::Callbacks
+    include ActiveGraph::Node::Query
+    include ActiveGraph::Node::Labels
+    include ActiveGraph::Node::Rels
+    include ActiveGraph::Node::Unpersisted
+    include ActiveGraph::Node::HasN
+    include ActiveGraph::Node::Scope
+    include ActiveGraph::Node::Dependent
+    include ActiveGraph::Node::Enum
+    include ActiveGraph::Shared::PermittedAttributes
+    include ActiveGraph::Node::DependentCallbacks
+    include ActiveGraph::Transactions
+
+    def initialize(args = nil)
+      self.class.ensure_id_property_info! # So that we make sure all objects have an id_property
+
+      args = sanitize_input_parameters(args)
+      super(args)
+    end
+
+    def neo4j_obj
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
+    end
+
+    LOADED_CLASSES = []
+
+    def self.loaded_classes
+      LOADED_CLASSES
+    end
+
+    module ClassMethods
+      def nodeify(object)
+        if object.is_a?(::ActiveGraph::Node) || object.nil?
+          object
+        else
+          self.find(object)
+        end
+      end
+    end
+
+    included do
+      include ActiveGraph::Timestamps if ActiveGraph::Config[:record_timestamps]
+      LOADED_CLASSES << self
+
+      def self.inherited?
+        !!@inherited
+      end
+
+      def self.inherited(other)
+        ActiveGraph::Node::Labels.clear_wrapped_models
+
+        LOADED_CLASSES << other
+        other.instance_variable_set('@inherited', true)
+        inherit_id_property(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+
+        ActiveGraph::Node::Labels.add_wrapped_class(other)
+        super
+      end
+
+      def self.inherit_id_property(other)
+        return if other.manual_id_property? || !self.id_property?
+        id_prop = self.id_property_info
+        conf = id_prop[:type].empty? && id_prop[:name] != :neo_id ? {auto: :uuid} : id_prop[:type]
+        other.id_property id_prop[:name], conf, true
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:node, self)
+  end
+end