activegraph 11.5.0.beta.1 → 12.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c217d68abf8f640ef01f10e2d7a5b96c6fe7b6f3c4499d24da58718a90646acc
-  data.tar.gz: d8bcda3316fd7cdc1422eb47b186f6eb7d853752d138f014e53a0e425c2f3e4f
+  metadata.gz: 5980a6fcd4bee8de9d49abdc805f45292b507d76b6d4299eb3424b57fd33dd98
+  data.tar.gz: 16a8d463cf9b8cf88d814b4a9fd33db8f83e92b3ab4cd2e903377e420b4acd24
 SHA512:
-  metadata.gz: fa79ae2d367a183fb0a5a26363f352d15767540288ae080558fc876854100ecf01815fb76be5460d1f638c3c1a8799a5b44f09e7ce5d0efc8faa8a74baf9c187
-  data.tar.gz: e39a318db8e56067cffbd7ba216d3951184124cb36b48da420334475472d63d17bff7d70027d4d7a9e495d7cb4cb7d4dd8b27b9a4c3bf44e265b24503802b2fd
+  metadata.gz: 02bb5a53486be92a3a8724a42525b02148065fb0461fe9400d31c95d3bf7cbe351028cd955fea96dd22ec587baae8abe6c4e9498d131a7019bbee0bb2c78d093
+  data.tar.gz: a98acca7075481e24e9926bfcbb8cb6fadefc9e11cef963fa146fc7c543e8682d7fcb8639e681c3fb5971738d01568623f59456cb93ce36de7c0eaf7a6500abf

data/CHANGELOG.md

@@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [12.0.0.beta.1] 2024-01-01
+
+## Added
+
+- removed deprecated usage of id (neo_id), replaced with element_id, requires neo4j-ruby-driver 5
+- removed the possibility of using neo_id as id_property
+- added id_property to relationships
+
 ## [11.5.0.beta.1] 2023-12-29
 
 ## Added

data/activegraph.gemspec

@@ -32,7 +32,7 @@ DESCRIPTION
 
   s.add_dependency('activemodel', '>= 7')
   s.add_dependency('i18n', '!= 1.8.8') # https://github.com/jruby/jruby/issues/6547
-  s.add_dependency('neo4j-ruby-driver', '>= 4.4.1', '< 5')
+  s.add_dependency('neo4j-ruby-driver', '>= 5')
   s.add_dependency('orm_adapter', '>= 0.5.0')
   s.add_dependency('sorted_set')
   s.add_development_dependency('guard')

data/lib/active_graph/base.rb

@@ -60,6 +60,10 @@ module ActiveGraph
         ActiveGraph::Core::Label.new(label_name)
       end
 
+      def element(name, relationship: false)
+        (relationship ? Core::Type : Core::Label).new(name)
+      end
+
       def logger
         @logger ||= (ActiveGraph::Config[:logger] || ActiveSupport::Logger.new(STDOUT))
       end

data/lib/active_graph/core/element.rb

@@ -0,0 +1,142 @@
+module ActiveGraph
+  module Core
+    class Element
+      attr_reader :name
+      delegate :version?, to: ActiveGraph::Base
+
+      def initialize(name)
+        @name = name
+      end
+
+      def create_index(*properties, **options)
+        validate_index_options!(options)
+        properties = properties.map { |p| "l.#{p}" }
+        schema_query("CREATE INDEX FOR (l:`#{@name}`) ON (#{properties.join('.')})")
+      end
+
+      def drop_index(property, options = {})
+        validate_index_options!(options)
+        schema_query("SHOW INDEXES YIELD * WHERE labelsOrTypes = $labels AND properties = $properties",
+                     labels: [@name], properties: [property]).each do |record|
+          schema_query("DROP INDEX #{record[:name]}")
+        end
+      end
+
+      # Creates a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = ActiveGraph::Label.create(:person)
+      #   label.create_constraint(:name, {type: :unique})
+      #
+      def create_constraint(property, type: :key)
+        schema_query(
+          "CREATE CONSTRAINT #{constraint_name(property, type:)} FOR #{pattern("n:`#{name}`")} REQUIRE n.`#{property}` IS #{constraint_type(type:)}"
+        )
+      end
+
+      # Drops a neo4j constraint on a property
+      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
+      # @example
+      #   label = ActiveGraph::Label.create(:person)
+      #   label.create_constraint(:name, {type: :unique})
+      #   label.drop_constraint(:name, {type: :unique})
+      #
+      def drop_constraint(property, type: :key)
+        schema_query("DROP CONSTRAINT #{constraint_name(property, type:)} IF EXISTS")
+      end
+
+      def drop_uniqueness_constraint(property, options = {})
+        drop_constraint(property, type: :unique)
+      end
+
+      def indexes
+        self.class.indexes.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def drop_indexes
+        self.class.drop_indexes
+      end
+
+      def index?(property)
+        indexes.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def constraints(_options = {})
+        ActiveGraph::Base.constraints.select do |definition|
+          definition[:label] == @name.to_sym
+        end
+      end
+
+      def uniqueness_constraints(_options = {})
+        constraints.select do |definition|
+          definition[:type] == :uniqueness
+        end
+      end
+
+      def constraint?(property)
+        constraints.any? { |definition| definition[:properties] == [property.to_sym] }
+      end
+
+      def uniqueness_constraint?(property)
+        uniqueness_constraints.include?([property])
+      end
+
+      private
+
+      class << self
+        def indexes
+          ActiveGraph::Base.indexes
+        end
+
+        def drop_indexes
+          indexes.each do |definition|
+            ActiveGraph::Base.query("DROP INDEX #{definition[:name]}") unless definition[:owningConstraint]
+          end
+        end
+
+        def drop_constraints
+          result = ActiveGraph::Base.read_transaction do |tx|
+            tx.run('SHOW CONSTRAINTS YIELD *').to_a
+          end
+          ActiveGraph::Base.write_transaction do |tx|
+            result.each do |record|
+              tx.run("DROP CONSTRAINT `#{record[:name]}`")
+            end
+          end
+        end
+      end
+
+      def schema_query(cypher, **params)
+        ActiveGraph::Base.query(cypher, params)
+      end
+
+      def validate_index_options!(options)
+        return unless options[:type] && options[:type] != :exact
+        fail "Type #{options[:type]} is not supported"
+      end
+
+      def constraint_type(type:)
+        case symnolic_type(type:)
+        when :key
+          "#{element_type} KEY"
+        when :unique
+          "UNIQUE"
+        when :not_null
+          "UNIQUE"
+        else
+          ":: #{type.to_s.upcase}"
+        end
+      end
+
+      def symnolic_type(type:)
+        type == :key && !ActiveGraph::Base.enterprise? ? :unique : type
+      end
+
+      def constraint_name(property, type:)
+        "`#{element_type}_#{name}##{property}_#{symnolic_type(type:)}`"
+      end
+    end
+  end
+end

data/lib/active_graph/core/entity.rb

@@ -3,6 +3,10 @@
 module ActiveGraph
   module Core
     module Entity
+      def neo_id
+        element_id
+      end
+
       def properties
         @properties ||= super
       end

data/lib/active_graph/core/label.rb

@@ -1,173 +1,12 @@
 module ActiveGraph
   module Core
-    class Label
-      attr_reader :name
-      delegate :version?, to: ActiveGraph::Base
-
-      def initialize(name)
-        @name = name
-      end
-
-      def create_index(*properties, **options)
-        validate_index_options!(options)
-        if version?('>=4.4')
-          properties = properties.map { |p| "l.#{p}" }
-          fragment = "FOR (l:`#{@name}`) ON"
-        else
-          fragment = "ON :`#{@name}`"
-        end
-        schema_query("CREATE INDEX #{fragment} (#{properties.join('.')})")
-      end
-
-      def drop_index(property, options = {})
-        validate_index_options!(options)
-        if version?('<4.3')
-          schema_query("DROP INDEX ON :`#{@name}`(#{property})")
-        else
-          schema_query("SHOW INDEXES YIELD * WHERE labelsOrTypes = $labels AND properties = $properties",
-                       labels: [@name], properties: [property]).each do |record|
-            schema_query("DROP INDEX #{record[:name]}")
-          end
-        end
-      end
-
-      # Creates a neo4j constraint on a property
-      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
-      # @example
-      #   label = ActiveGraph::Label.create(:person)
-      #   label.create_constraint(:name, {type: :unique})
-      #
-      def create_constraint(property, constraints)
-        cypher = case constraints[:type]
-                 when :unique, :uniqueness
-                   _for, _require = version?('>=4.4') ? %w[FOR REQUIRE] : %w[ON ASSERT]
-                   "CREATE CONSTRAINT #{_for} (n:`#{name}`) #{_require} n.`#{property}` IS UNIQUE"
-                 else
-                   fail "Not supported constraint #{constraints.inspect} for property #{property} (expected :type => :unique)"
-                 end
-        schema_query(cypher)
-      end
-
-      def create_uniqueness_constraint(property, options = {})
-        create_constraint(property, options.merge(type: :unique))
-      end
-
-      # Drops a neo4j constraint on a property
-      # See http://docs.neo4j.org/chunked/stable/query-constraints.html
-      # @example
-      #   label = ActiveGraph::Label.create(:person)
-      #   label.create_constraint(:name, {type: :unique})
-      #   label.drop_constraint(:name, {type: :unique})
-      #
-      def drop_constraint(property, constraint)
-        return drop_constraint42(property, constraint) if version?('<4.3')
-        type = case constraint[:type]
-               when :unique, :uniqueness
-                 'UNIQUENESS'
-               when :exists
-                 'NODE_PROPERTY_EXISTENCE'
-               else
-                 fail "Not supported constraint #{constraint.inspect}"
-               end
-        schema_query(
-          'SHOW CONSTRAINTS YIELD * WHERE type = $type AND labelsOrTypes = $labels AND properties = $properties',
-          type: type, labels: [name], properties: [property]).first[:name].tap do |constraint_name|
-          schema_query("DROP CONSTRAINT #{constraint_name}")
-        end
-      end
-
-      def drop_uniqueness_constraint(property, options = {})
-        drop_constraint(property, options.merge(type: :unique))
-      end
-
-      def indexes
-        self.class.indexes.select do |definition|
-          definition[:label] == @name.to_sym
-        end
-      end
-
-      def drop_indexes
-        self.class.drop_indexes
-      end
-
-      def index?(property)
-        indexes.any? { |definition| definition[:properties] == [property.to_sym] }
-      end
-
-      def constraints(_options = {})
-        ActiveGraph::Base.constraints.select do |definition|
-          definition[:label] == @name.to_sym
-        end
-      end
-
-      def uniqueness_constraints(_options = {})
-        constraints.select do |definition|
-          definition[:type] == :uniqueness
-        end
-      end
-
-      def constraint?(property)
-        constraints.any? { |definition| definition[:properties] == [property.to_sym] }
-      end
-
-      def uniqueness_constraint?(property)
-        uniqueness_constraints.include?([property])
-      end
-
-      private
-
-      class << self
-        def indexes
-          ActiveGraph::Base.indexes
-        end
-
-        def drop_indexes
-          indexes.each do |definition|
-            begin
-              ActiveGraph::Base.query(
-                if definition[:name]
-                  "DROP INDEX #{definition[:name]}"
-                else
-                  "DROP INDEX ON :`#{definition[:label]}`(#{definition[:properties][0]})"
-                end)
-            rescue Neo4j::Driver::Exceptions::DatabaseException
-              # This will error on each constraint. Ignore and continue.
-              next
-            end
-          end
-        end
-
-        def drop_constraints
-          result = ActiveGraph::Base.read_transaction do |tx|
-            tx.run(ActiveGraph::Base.version?('<4.3') ? 'CALL db.constraints' : 'SHOW CONSTRAINTS YIELD *').to_a
-          end
-          ActiveGraph::Base.write_transaction do |tx|
-            result.each do |record|
-              tx.run("DROP #{record.keys.include?(:name) ? "CONSTRAINT #{record[:name]}" : record[:description]}")
-            end
-          end
-        end
-      end
-
-      def schema_query(cypher, **params)
-        ActiveGraph::Base.query(cypher, params)
-      end
-
-      def validate_index_options!(options)
-        return unless options[:type] && options[:type] != :exact
-        fail "Type #{options[:type]} is not supported"
+    class Label < Element
+      def pattern(spec)
+        "(#{spec})"
       end
 
-      def drop_constraint42(property, constraint)
-        cypher = case constraint[:type]
-                 when :unique, :uniqueness
-                   "n.`#{property}` IS UNIQUE"
-                 when :exists
-                   "exists(n.`#{property}`)"
-                 else
-                   fail "Not supported constraint #{constraint.inspect}"
-                 end
-        schema_query("DROP CONSTRAINT ON (n:`#{name}`) ASSERT #{cypher}")
+      def element_type
+        'NODE'
       end
     end
   end

data/lib/active_graph/core/node.rb

@@ -3,10 +3,6 @@
 module ActiveGraph
   module Core
     module Node
-      def neo_id
-        id
-      end
-
       def labels
         @labels ||= super
       end

data/lib/active_graph/core/query_clauses.rb

@@ -158,7 +158,7 @@ module ActiveGraph
           end
 
           def from_key_and_single_value(key, value)
-            value.to_sym == :neo_id ? "ID(#{key})" : "#{key}.#{value}"
+            value.to_sym == :neo_id ? "elementId(#{key})" : "#{key}.#{value}"
           end
         end
 
@@ -200,7 +200,7 @@ module ActiveGraph
         end
 
         def array_value?(value, is_set)
-          value.is_a?(Array) && !is_set
+          value.is_a?(Enumerable) && !is_set
         end
 
         def format_label(label_arg)
@@ -316,8 +316,8 @@ module ActiveGraph
         def hash_key_value_string(key, value, previous_keys)
           value.map do |k, v|
             if k.to_sym == :neo_id
-              v = Array(v).map { |item| (item.respond_to?(:neo_id) ? item.neo_id : item).to_i }
-              key_value_string("ID(#{key})", v)
+              v = Array(v).map { |item| item.respond_to?(:neo_id) ? item.neo_id : item }
+              key_value_string("elementId(#{key})", v)
             else
               "#{key}.#{from_key_and_value(k, v, previous_keys + [key])}"
             end

data/lib/active_graph/core/schema.rb

@@ -1,21 +1,20 @@
 module ActiveGraph
   module Core
     module Schema
-      FILTER = {
-        3 => [:type, 'node_unique_property'],
-        4 => [:uniqueness, 'UNIQUE'],
-      }
-
       def version
-        @version ||= read_transaction do
-          # BTW: community / enterprise could be retrieved via `result.first.edition`
-          query('CALL dbms.components()', {}, skip_instrumentation: true).first[:versions][0]
-            .then(&Gem::Version.method(:new))
-        end
+        Gem::Version.new(component[:versions][0])
+      end
+
+      def edition
+        component[:edition]
+      end
+
+      def enterprise?
+        edition == 'enterprise'
       end
 
       def version?(requirement)
-        Gem::Requirement.create(requirement).satisfied_by?(Gem::Version.new(version))
+        Gem::Requirement.create(requirement).satisfied_by?(version)
       end
 
       def indexes
@@ -24,17 +23,12 @@ module ActiveGraph
 
       def normalize(result, *extra)
         result.map do |row|
-          definition(row, version?('<4') ? :index_cypher_v3 : :index_cypher)
-            .merge(extra.to_h { |key| [key, row[key].to_sym] })
+          definition(row, :index_cypher).merge(extra.to_h { |key| [key, row[key].to_sym] })
         end
       end
 
       def constraints
-        if version?('<4.3')
-          raw_indexes.select(&method(:constraint_owned?))
-        else
-          raw_constraints.select(&method(:constraint_filter))
-        end.map { |row| definition(row, :constraint_cypher).merge(type: :uniqueness) }
+        raw_constraints.select(&method(:constraint_filter)).map { |row| definition(row, :constraint_cypher).merge(type: :uniqueness) }
       end
 
       private def raw_constraints
@@ -45,27 +39,28 @@ module ActiveGraph
 
       def raw_indexes
         read_transaction do
-          query(version?('<4.3') ? 'CALL db.indexes()' : 'SHOW INDEXES YIELD *', {}, skip_instrumentation: true)
-            .reject { |row| row[:type] == 'LOOKUP' }
+          query('SHOW INDEXES YIELD *', {}, skip_instrumentation: true).reject { |row| row[:type] == 'LOOKUP' }
         end
       end
 
       def constraint_owned?(record)
-        FILTER[major]&.then { |(key, value)| record[key] == value } || record[:owningConstraint]
+        record[:owningConstraint]
       end
 
       private
 
+      def component
+        @component ||= read_transaction do
+          query('CALL dbms.components()', {}, skip_instrumentation: true).first
+        end
+      end
+
       def major
         @major ||= version.segments.first
       end
 
       def constraint_filter(record)
-        %w[UNIQUENESS RELATIONSHIP_PROPERTY_EXISTENCE NODE_PROPERTY_EXISTENCE NODE_KEY].include?(record[:type])
-      end
-
-      def index_cypher_v3(label, properties)
-        "INDEX ON :#{label}#{com_sep(properties, nil)}"
+        %w[UNIQUENESS RELATIONSHIP_UNIQUENESS RELATIONSHIP_PROPERTY_EXISTENCE NODE_PROPERTY_EXISTENCE NODE_KEY RELATIONSHIP_KEY].include?(record[:type])
       end
 
       def index_cypher(label, properties)
@@ -82,11 +77,11 @@ module ActiveGraph
 
       def definition(row, template)
         { label: label(row), properties: properties(row), name: row[:name],
-          create_statement: row[:createStatement] || send(template,label(row), row[:properties]) }
+          create_statement: row[:createStatement] || send(template, label(row), row[:properties]) }
       end
 
       def label(row)
-        row[version?('>=4') ? :labelsOrTypes : :tokenNames].first.to_sym
+        row[:labelsOrTypes].first.to_sym
       end
 
       def properties(row)

data/lib/active_graph/core/type.rb

@@ -0,0 +1,13 @@
+module ActiveGraph
+  module Core
+    class Type < Element
+      def pattern(spec)
+        "()-[#{spec}]-()"
+      end
+
+      def element_type
+        'RELATIONSHIP'
+      end
+    end
+  end
+end

data/lib/active_graph/migrations/helpers/schema.rb

@@ -6,18 +6,16 @@ module ActiveGraph
         MISSING_CONSTRAINT_OR_INDEX = 'No such %{type} for %{label}#%{property}'.freeze
         DUPLICATE_CONSTRAINT_OR_INDEX = 'Duplicate %{type} for %{label}#%{property}'.freeze
 
-        def add_constraint(label, property, options = {})
-          force = options[:force] || false
-          type = options[:type] || :uniqueness
-          label_object = ActiveGraph::Base.label_object(label)
-          if label_object.constraint?(property)
+        def add_constraint(name, property, relationship: false, type: :key, force: false)
+          element = ActiveGraph::Base.element(name, relationship:)
+          if element.constraint?(property)
             if force
-              label_object.drop_constraint(property, type: type)
+              element.drop_constraint(property, type:)
             else
-              fail_duplicate_constraint_or_index!(:constraint, label, property)
+              fail_duplicate_constraint_or_index!(:constraint, name, property)
             end
           end
-          label_object.create_constraint(property, type: type)
+          element.create_constraint(property, type:)
         end
 
         def add_index(label, property, options = {})
@@ -33,11 +31,10 @@ module ActiveGraph
           label_object.create_index(property)
         end
 
-        def drop_constraint(label, property, options = {})
-          type = options[:type] || :uniqueness
-          label_object = ActiveGraph::Base.label_object(label)
-          fail_missing_constraint_or_index!(:constraint, label, property) if !options[:force] && !label_object.constraint?(property)
-          label_object.drop_constraint(property, type: type)
+        def drop_constraint(name, property, type: :key, relationship: false, force: false)
+          element = ActiveGraph::Base.element(name, relationship:)
+          fail_missing_constraint_or_index!(:constraint, name, property) unless force || element.constraint?(property)
+          element.drop_constraint(property, type:)
         end
 
         def drop_index(label, property, options = {})

data/lib/active_graph/model_schema.rb

@@ -55,7 +55,7 @@ module ActiveGraph
       # 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
+          label = model.mapped_element_name.to_sym
           property_names.map do |property_name|
             exists = db_results[label] && db_results[label].include?([property_name])
             [model, label, property_name, exists]

data/lib/active_graph/node/has_n.rb

@@ -286,7 +286,7 @@ module ActiveGraph::Node
       query_proxy = self.class.as(:previous).where(neo_id: result_cache.map(&:neo_id))
       query_proxy = self.class.send(:association_query_proxy, association_name, previous_query_proxy: query_proxy, node: :next, optional: true)
 
-      Hash[*query_proxy.pluck('ID(previous)', 'collect(next)').flatten(1)].each_value do |records|
+      Hash[*query_proxy.pluck('elementId(previous)', 'collect(next)').flatten(1)].each_value do |records|
         records.each do |record|
           record.instance_variable_set('@source_proxy_result_cache', records)
         end

data/lib/active_graph/node/labels.rb

@@ -108,7 +108,7 @@ module ActiveGraph
 
         # Deletes all nodes and connected relationships from Cypher.
         def delete_all
-          neo4j_query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
+          neo4j_query("MATCH (n:`#{mapped_label_name}`) DETACH DELETE n")
         end
 
         # Returns each node to Ruby and calls `destroy`. Be careful, as this can be a very slow operation if you have many nodes. It will generate at least
@@ -127,11 +127,15 @@ module ActiveGraph
           @mapped_label_name || label_for_model
         end
 
+        alias mapped_element_name mapped_label_name
+
         # @return [ActiveGraph::Label] the label for this class
         def mapped_label
           ActiveGraph::Core::Label.new(mapped_label_name)
         end
 
+        alias mapped_element mapped_label
+
         def base_class
           unless self < ActiveGraph::Node
             fail "#{name} doesn't belong in a hierarchy descending from Node"
@@ -160,6 +164,7 @@ module ActiveGraph
 
           self.mapped_label_name = name
         end
+
         # rubocop:enable Naming/AccessorMethodName
 
         private
@@ -184,20 +189,18 @@ module ActiveGraph
         end
 
         def label_for_model
-          (self.name.nil? ? object_id.to_s.to_sym : decorated_label_name)
+          name.nil? ? object_id.to_s.to_sym : decorated_label_name
         end
 
         def decorated_label_name
-          name =  case ActiveGraph::Config[:module_handling]
-                  when :demodulize
-                    self.name.demodulize
-                  when Proc
-                    ActiveGraph::Config[:module_handling].call self.name
-                  else
-                    self.name
-                  end
-
-          name.to_sym
+          case ActiveGraph::Config[:module_handling]
+          when :demodulize
+            name.demodulize
+          when Proc
+            ActiveGraph::Config[:module_handling].call name
+          else
+            name
+          end.to_sym
         end
       end
     end