activecypher 0.5.0 → 0.6.1

data/lib/active_cypher/model/destruction.rb

@@ -2,9 +2,8 @@
 
 module ActiveCypher
   module Model
-    # @!parse
-    #   # Destruction: The module that lets you banish records from existence with a single incantation.
-    #   # Uses a blend of Ruby sorcery, a dash of witchcraft, and—on rare occasions—some back magick when nothing else will do.
+    # Destruction: The module that lets you banish records from existence with a single incantation.
+    # Uses a blend of Ruby sorcery, a dash of witchcraft, and—on rare occasions—some back magick when nothing else will do.
     module Destruction
       extend ActiveSupport::Concern
 
@@ -13,7 +12,6 @@ module ActiveCypher
       # Runs a Cypher `DETACH DELETE` query on the node.
       # Freezes the object to prevent further use, as a kind of ceremonial burial.
       # Because nothing says "closure" like a frozen Ruby object.
-      # If this works and you can't explain why, that's probably back magick.
       #
       # @raise [RuntimeError] if the record is new or already destroyed.
       # @return [Boolean] true if the record was successfully destroyed, false if something caught on fire.
@@ -23,29 +21,29 @@ module ActiveCypher
           raise 'Record already destroyed' if destroyed?
 
           n = :n
-          # Use all labels for database operations
           labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
-          query  = Cyrel.match(Cyrel.node(n, labels: labels))
-                        .where(Cyrel.element_id(n).eq(internal_id))
-                        .detach_delete(n)
-                        .return_('count(*) as deleted')
+          label_string = labels.map { |l| ":#{l}" }.join
 
-          cypher, params = query.to_cypher
-          params ||= {}
+          cypher = <<~CYPHER
+            MATCH (#{n}#{label_string})
+            WHERE id(#{n}) = #{internal_id}
+            DETACH DELETE #{n}
+            RETURN count(*) AS deleted
+          CYPHER
 
-          # Here lies the true sorcery: one line to erase a node from existence.
-          # If the database still remembers it, you may need to consult your local witch.
-          result = self.class.connection.execute_cypher(cypher, params, 'Destroy')
-          if result.present? && result.first.present? && (result.first[:deleted] || 0).positive?
+          result = self.class.connection.execute_cypher(cypher, {}, 'Destroy')
+
+          if result.present? && result.first[:deleted].to_i.positive?
             @destroyed = true
-            freeze # To make sure you can't Frankenstein it back to life. Lightning not included.
+            freeze
             true
           else
             false
           end
         end
-      rescue StandardError
-        false # Something went wrong. Don't ask. Just walk away. Or blame the database, that's always fun. If it keeps happening, suspect back magick.
+      rescue StandardError => e
+        warn "[Destruction] Destroy failed: #{e.class}: #{e.message}"
+        false
       end
 
       # Returns true if this object has achieved full existential closure.

data/lib/active_cypher/model/labelling.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module Model
+    module Labelling
+      extend ActiveSupport::Concern
+
+      included do
+        # Use array instead of set to preserve insertion order of labels
+        class_attribute :custom_labels, default: []
+      end
+
+      class_methods do
+        # Define a label for the model. Can be called multiple times to add multiple labels.
+        # @param label_name [Symbol, String] The label name
+        # @return [Array] The collection of custom labels
+        def label(label_name)
+          label_sym = label_name.to_sym
+          self.custom_labels = custom_labels.dup << label_sym unless custom_labels.include?(label_sym)
+          custom_labels
+        end
+
+        # Get all labels for this model
+        # @return [Array<Symbol>] All labels for this model
+        def labels
+          custom_labels.empty? ? [default_label] : custom_labels
+        end
+
+        # Returns the primary label for the model
+        # @return [Symbol] The primary label
+        def label_name
+          custom_labels.any? ? custom_labels.first : default_label
+        end
+
+        # Computes the default label for the model based on class name
+        # Strips 'Node' or 'Record' suffix, returns as symbol, capitalized
+        def default_label
+          base = name.split('::').last
+          base = base.sub(/(Node|Record)\z/, '')
+          base.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/active_cypher/model/persistence.rb

@@ -14,10 +14,13 @@ module ActiveCypher
       # If it already exists, we patch up its regrets.
       # If it fails, we return false, like cowards.
       #
+      # @param validate [Boolean] whether to run validations (default: true)
       # @return [Boolean] true if saved successfully, false if the database ghosted us.
       # Because nothing says "robust" like pretending persistence is easy.
       # If this works and you can't explain why, that's probably back magick.
-      def save
+      def save(validate: true)
+        return false if validate && !valid?
+
         # before_/after_create
         _run(:save) do
           if new_record?
@@ -112,17 +115,6 @@ module ActiveCypher
 
       private
 
-      # # Internal method to initialize a record from the database
-      # # @param attributes [Hash] The attributes from the database
-      # # @return [self]
-      # def init_with_attributes(attrs)
-      #   binding.irb
-      #   assign_attributes(**attrs) if attrs
-      #   @new_record = false # Mark as not new when loading from DB
-      #   clear_changes_information
-      #   self
-      # end
-
       # Creates the record in the database using Cypher.
       #
       # @return [Boolean] true if the database accepted your offering.
@@ -135,16 +127,31 @@ module ActiveCypher
         # Use all labels for database operations
         labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name.to_s]
 
-        # Create node with all labels
-        node = Cyrel.node(n, labels: labels, properties: props)
-        query = Cyrel.create(node).return_(Cyrel.element_id(n).as(:internal_id))
-        cypher, params = query.to_cypher
-        params ||= {}
+        # For Memgraph, construct direct Cypher query
+        label_string = labels.map { |l| ":#{l}" }.join
+
+        # Handle properties for Cypher query
+        props_str = props.map do |k, v|
+          value_str = if v.nil?
+                        'NULL'
+                      elsif v.is_a?(String)
+                        "'#{v.gsub("'", "\\\\'")}'"
+                      elsif v.is_a?(Numeric) || v.is_a?(TrueClass) || v.is_a?(FalseClass)
+                        v.to_s
+                      else
+                        "'#{v.to_s.gsub("'", "\\\\'")}'"
+                      end
+          "#{k}: #{value_str}"
+        end.join(', ')
+
+        cypher = "CREATE (#{n}#{label_string} {#{props_str}}) " \
+                 "RETURN id(#{n}) AS internal_id"
+
+        data = self.class.connection.execute_cypher(cypher, {}, 'Create')
 
-        data = self.class.connection.execute_cypher(cypher, params, 'Create')
         return false if data.blank? || !data.first.key?(:internal_id)
 
-        self.internal_id = data.first[:internal_id].to_s
+        self.internal_id = data.first[:internal_id]
         @new_record = false
         changes_applied
         true
@@ -169,33 +176,32 @@ module ActiveCypher
         changes = changes_to_save
         return true if changes.empty?
 
-        n = :n
-
         # Use all labels for database operations
         labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
 
-        # Match node with all labels
-        query = Cyrel.match(Cyrel.node(n, labels: labels))
-                     .where(Cyrel.element_id(n).eq(internal_id)) # Use element_id explicitly
-
-        # Create separate SET clauses for each property to avoid overwriting existing properties
-        changes.each do |property, value|
-          query = query.set(Cyrel.prop(n, property) => value)
-        end
-
-        query = query.return_(n) # Return the updated node to confirm success
+        label_string = labels.map { |l| ":#{l}" }.join
+        set_clauses = changes.map do |property, value|
+          # Handle different value types appropriately
+          if value.nil?
+            "n.#{property} = NULL"
+          elsif value.is_a?(String)
+            "n.#{property} = '#{value.gsub("'", "\\\\'")}'"
+          elsif value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            "n.#{property} = #{value}"
+          else
+            "n.#{property} = '#{value.to_s.gsub("'", "\\\\'")}'"
+          end
+        end.join(', ')
 
-        cypher, params = query.to_cypher
-        params ||= {}
+        cypher = "MATCH (n#{label_string}) " \
+                 "WHERE id(n) = #{internal_id} " \
+                 "SET #{set_clauses} " \
+                 'RETURN n'
 
-        result = self.class.connection.execute_cypher(cypher, params, 'Update')
+        self.class.connection.execute_cypher(cypher, {}, 'Update')
 
-        if result.present? && result.first.present?
-          changes_applied
-          true
-        else
-          false
-        end
+        changes_applied
+        true
       end
     end
   end

data/lib/active_cypher/model/querying.rb

@@ -2,19 +2,14 @@
 
 module ActiveCypher
   module Model
-    # @!parse
-    #   # Querying: The module that lets you pretend your graph is just a really weird table.
-    #   # Because what’s more fun than chaining scopes and pretending you’re not writing Cypher by hand?
+    # Querying: The module that lets you pretend your graph is just a really weird table.
+    # Because what's more fun than chaining scopes and pretending you're not writing Cypher by hand?
     module Querying
       extend ActiveSupport::Concern
 
       class_methods do
-        # -- default label -----------------------------------------------
-        # Returns the symbolic label name for the model, e.g., :user_node
-        # @return [Symbol] The label name for the model
-        def label_name = model_name.element.to_sym
+        # -- Basic Query Builders ----------------------------------------
 
-        # -- basic query builders ----------------------------------------
         # Return a base Relation, applying the default scope if it exists
         # @return [Relation] The base relation for the model
         # Because nothing says "default" like a scope you forgot you set.
@@ -29,35 +24,38 @@ module ActiveCypher
         # @return [Relation]
         def where(conditions) = all.where(conditions)
 
-        # @param val [Integer] The limit value
-        # @return [Relation]
-        def limit(val)        = all.limit(val)
+        def limit(val) = all.limit(val)
 
-        # @return [Relation]
-        def order(*)          = all.order(*)
+        def order(*) = all.order(*)
+
+        # -- find / create ------------------------------------------------
 
-        # -- find / create -----------------------------------------------
         # Find a node by internal DB ID. Returns the record or dies dramatically.
-        # @param internal_db_id [String] The internal database ID
-        # @return [Object] The found record
-        # @raise [ActiveCypher::RecordNotFound] if not found
         # Because sometimes you want to find a node, and sometimes you want to find existential dread.
         def find(internal_db_id)
+          internal_db_id = internal_db_id.to_i if internal_db_id.respond_to?(:to_i)
           node_alias = :n
 
-          # Use all labels if available, otherwise fall back to the primary label
           labels = respond_to?(:labels) ? self.labels : [label_name]
+          Cyrel.match(Cyrel.node(node_alias, labels: labels)).limit(1)
+          label_string = labels.map { |l| ":#{l}" }.join
+          cypher = <<~CYPHER
+            MATCH (#{node_alias}#{label_string})
+            WHERE id(#{node_alias}) = #{internal_db_id}
+            RETURN #{node_alias}, id(#{node_alias}) AS internal_id
+            LIMIT 1
+          CYPHER
 
-          query = Cyrel
-                  .match(Cyrel.node(node_alias, labels: labels))
-                  .where(Cyrel.element_id(node_alias).eq(internal_db_id))
-                  .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
-                  .limit(1)
-          query.to_cypher
+          result = connection.execute_cypher(cypher)
+          record = result.first
 
-          Relation.new(self, query).first or
-            raise ActiveCypher::RecordNotFound,
-                  "#{name} with internal_id=#{internal_db_id.inspect} not found"
+          if record
+            attrs = _hydrate_attributes_from_memgraph_record(record, node_alias)
+            return instantiate(attrs)
+          end
+
+          raise ActiveCypher::RecordNotFound,
+                "#{name} with internal_id=#{internal_db_id.inspect} not found. Perhaps it's in another castle, or just being 'graph'-ty."
         end
 
         # Instantiates and immediately saves a new record. YOLO mode.
@@ -65,6 +63,28 @@ module ActiveCypher
         # @return [Object] The new, possibly persisted record
         # Because sometimes you just want to live dangerously.
         def create(attrs = {}) = new(attrs).tap(&:save)
+
+        private
+
+        def _hydrate_attributes_from_memgraph_record(record, node_alias)
+          attrs = {}
+          node_data = record[node_alias] || record[node_alias.to_s]
+
+          if node_data.is_a?(Array) && node_data.length >= 2
+            properties_container = node_data[1]
+            if properties_container.is_a?(Array) && properties_container.length >= 3
+              properties = properties_container[2]
+              properties.each { |k, v| attrs[k.to_sym] = v } if properties.is_a?(Hash)
+            end
+          elsif node_data.is_a?(Hash)
+            node_data.each { |k, v| attrs[k.to_sym] = v }
+          elsif node_data.respond_to?(:properties)
+            attrs = node_data.properties.symbolize_keys
+          end
+
+          attrs[:internal_id] = record[:internal_id] || record['internal_id']
+          attrs
+        end
       end
     end
   end

data/lib/active_cypher/railtie.rb

@@ -16,12 +16,47 @@ module ActiveCypher
     end
 
     initializer 'active_cypher.load_multi_db' do |_app|
-      configs = ActiveCypher::CypherConfig.for('*') # entire merged hash
-      %i[writing reading analytics].each do |role|
-        next unless (cfg = configs[role])
+      configs = ActiveCypher::CypherConfig.for('*')
 
-        pool = ActiveCypher::ConnectionPool.new(cfg)
-        ActiveCypher::Base.connection_handler.set(role, :default, pool)
+      # First, create pools for all configurations
+      connection_pools = {}
+      configs.each do |name, cfg|
+        connection_pools[name.to_sym] = ActiveCypher::ConnectionPool.new(cfg)
+      end
+
+      # Register all pools under their own names with the database key
+      connection_pools.each do |name, pool|
+        # Store the pool with db_key only
+        ActiveCypher::Base.connection_handler.set(name, pool)
+      end
+
+      # Register default roles (writing, reading)
+      # Use primary pool if available, otherwise use the first pool
+      default_db_key = :primary
+      default_pool = connection_pools[:primary] || connection_pools.values.first
+      default_db_key = connection_pools.keys.first unless connection_pools.key?(:primary)
+
+      if default_pool
+        # Store the default pool with db_key only
+        ActiveCypher::Base.connection_handler.set(default_db_key, default_pool)
+      end
+
+      # Find all abstract node base classes with connects_to mappings
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < ActiveCypher::Base
+        next unless klass.respond_to?(:abstract_class?) && klass.abstract_class?
+        next unless klass.respond_to?(:connects_to_mappings) && klass.connects_to_mappings.present?
+
+        # Register pools for each role in connects_to mapping
+        klass.connects_to_mappings.each_value do |conn_name|
+          conn_name = conn_name.to_s.to_sym
+          pool = connection_pools[conn_name]
+          next unless pool
+
+          # Only create a new pool if one doesn't exist for this role and db_key combination
+          # Format: set(db_key, role, shard, pool)
+          ActiveCypher::Base.connection_handler.set(conn_name, pool) unless ActiveCypher::Base.connection_handler.pool(conn_name)
+        end
       end
     end
 

data/lib/active_cypher/relationship.rb

@@ -47,7 +47,7 @@ module ActiveCypher
     # --------------------------------------------------------------
     # Attributes
     # --------------------------------------------------------------
-    attribute :internal_id, :string
+    attribute :internal_id, :integer
 
     # --------------------------------------------------------------
     # Connection fallback
@@ -59,6 +59,11 @@ module ActiveCypher
     #   WorksAtRelationship.connection  # -> PersonNode.connection
     #
     def self.connection
+      # If a node_base_class is set (directly or by convention), always delegate to its connection
+      if (klass = node_base_class)
+        return klass.connection
+      end
+
       return @connection if defined?(@connection) && @connection
 
       begin
@@ -74,10 +79,51 @@ module ActiveCypher
     class_attribute :_from_class_name,   instance_writer: false
     class_attribute :_to_class_name,     instance_writer: false
     class_attribute :_relationship_type, instance_writer: false
+    class_attribute :_node_base_class,   instance_writer: false
 
     class << self
       attr_reader :last_internal_id
 
+      # DSL for setting or getting the node base class for connection delegation
+      def node_base_class(klass = nil)
+        if klass.nil?
+          # If not set, try convention: XxxRelationship -> XxxNode
+          return _node_base_class if _node_base_class
+
+          if name&.end_with?('Relationship')
+            node_base_name = name.sub(/Relationship\z/, 'Node')
+            begin
+              node_base_klass = node_base_name.constantize
+              if node_base_klass.respond_to?(:abstract_class?) && node_base_klass.abstract_class?
+                self._node_base_class = node_base_klass
+                return node_base_klass
+              end
+            rescue NameError
+              # Do nothing, fallback to nil
+            end
+          end
+          return _node_base_class
+        end
+        # Only allow setting on abstract relationship base classes
+        raise "Cannot set node_base_class on non-abstract relationship class #{name}" unless abstract_class?
+        unless klass.respond_to?(:abstract_class?) && klass.abstract_class?
+          raise ArgumentError, "node_base_class must be an abstract node base class (got #{klass})"
+        end
+
+        self._node_base_class = klass
+      end
+
+      # Prevent subclasses from overriding node_base_class
+      def inherited(subclass)
+        super
+        return unless _node_base_class
+
+        subclass._node_base_class = _node_base_class
+        def subclass.node_base_class(*)
+          raise "Cannot override node_base_class in subclass #{name}; it is locked to #{_node_base_class}"
+        end
+      end
+
       # -- endpoints ------------------------------------------------
       def from_class(value = nil)
         return _from_class_name if value.nil?
@@ -160,8 +206,10 @@ module ActiveCypher
         raise 'Cannot destroy a new relationship' if new_record?
         raise 'Relationship already destroyed'    if destroyed?
 
-        cypher = 'MATCH ()-[r]-() WHERE elementId(r) = $id DELETE r'
-        params = { id: internal_id }
+        adapter = self.class.connection.id_handler
+
+        cypher = "MATCH ()-[r]-() WHERE #{adapter.with_direct_id(internal_id)} DELETE r"
+        params = {}
 
         self.class.connection.execute_cypher(cypher, params, 'Destroy Relationship')
         @destroyed = true
@@ -186,22 +234,31 @@ module ActiveCypher
       rel_ty = self.class.relationship_type
       arrow  = '->' # outgoing by default
 
-      parts  = []
-      parts << 'MATCH (a) WHERE elementId(a) = $from_id'
-      parts << 'MATCH (b) WHERE elementId(b) = $to_id'
-      parts << "CREATE (a)-[r:#{rel_ty}]#{arrow}(b)"
+      adapter = self.class.connection.id_handler
+      parts = []
+
+      # Build the Cypher query based on the adapter
+      id_clause = adapter.with_direct_node_ids(from_node.internal_id, to_node.internal_id)
+      parts << "MATCH (p), (h) WHERE #{id_clause}"
+      parts << "CREATE (p)-[r:#{rel_ty}]#{arrow}(h)"
       parts << 'SET r += $props' unless props.empty? # only if we have props
-      parts << 'RETURN elementId(r) AS rid'
+      parts << "RETURN #{adapter.return_id}"
 
       cypher = parts.join(' ')
-      params = {
-        from_id: from_node.internal_id,
-        to_id: to_node.internal_id,
-        props: props
-      }
+      params = { props: props }
+
+      # Execute Cypher query
+      result = self.class.connection.execute_cypher(cypher, params, 'Create Relationship')
+
+      row = result.first
 
-      row = self.class.connection.execute_cypher(cypher, params, 'Create Relationship').first
-      rid = row && (row[:rid] || row['rid']) or raise 'Relationship creation returned no id'
+      # Try different ways to access the ID
+      rid_sym = row && row[:rid]
+      rid_str = row && row['rid']
+
+      rid = rid_sym || rid_str
+
+      raise 'Relationship creation returned no id' if rid.nil?
 
       self.internal_id = rid
       self.class.instance_variable_set(:@last_internal_id, rid)
@@ -217,11 +274,14 @@ module ActiveCypher
       changes = changes_to_save
       return true if changes.empty?
 
+      adapter = self.class.connection.id_handler
+
       cypher = <<~CYPHER
-        MATCH ()-[r]-() WHERE elementId(r) = $id
+        MATCH ()-[r]-() WHERE #{adapter.with_direct_id(internal_id)}
         SET r += $props
       CYPHER
-      params = { id: internal_id, props: changes }
+
+      params = { props: changes }
 
       self.class.connection.execute_cypher(cypher, params, 'Update Relationship')
       changes_applied

data/lib/active_cypher/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.5.0'
+  VERSION = '0.6.1'
 end

data/lib/activecypher.rb

@@ -101,7 +101,10 @@ loader.ignore("#{__dir__}/active_cypher/railtie.rb")
 loader.ignore("#{__dir__}/active_cypher/generators")
 loader.ignore("#{__dir__}/activecypher.rb")
 loader.ignore("#{__dir__}/cyrel.rb")
-loader.inflector.inflect('activecypher' => 'ActiveCypher')
+loader.inflector.inflect(
+  'activecypher' => 'ActiveCypher',
+  'dsl_context' => 'DSLContext'
+)
 loader.push_dir("#{__dir__}/cyrel", namespace: Cyrel)
 loader.setup
 

data/lib/cyrel/functions.rb

@@ -22,7 +22,9 @@ module Cyrel
       Expression::FunctionCall.new(:elementId, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
-    alias id element_id
+    def id(node_variable)
+      Expression::FunctionCall.new(:id, Clause::Return::RawIdentifier.new(node_variable.to_s))
+    end
 
     # Because apparently, COUNT(*) isn’t obvious enough.
     # Handles the 'give me everything and make it snappy' use case.

data/lib/cyrel/logging.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'active_support/tagged_logging'
+
+module Cyrel
+  # Basic logging support for Cyrel.
+  # Debug logging is disabled by default.
+  module Logging
+    LOG_TAG = 'Cyrel'
+
+    class << self
+      # @return [Logger] the configured logger
+      attr_accessor :backend
+
+      def resolve_log_level(log_level_str)
+        Logger.const_get(log_level_str.upcase)
+      rescue StandardError
+        Logger::UNKNOWN
+      end
+
+      def logger
+        self.backend ||= begin
+          log_level = ENV.fetch('CYREL_LOG_LEVEL', 'unknown')
+          logger_base = Logger.new($stdout)
+          logger_base.level = resolve_log_level(log_level)
+
+          # Return a TaggedLogging instance without calling 'tagged!'
+          ActiveSupport::TaggedLogging.new(logger_base)
+        end
+      end
+    end
+
+    def logger
+      Logging.logger.tagged(LOG_TAG)
+    end
+
+    def log_debug(msg) = logger.debug { msg }
+    def log_info(msg)  = logger.info  { msg }
+    def log_warn(msg)  = logger.warn  { msg }
+    def log_error(msg) = logger.error { msg }
+  end
+end

data/lib/cyrel/query.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+# Base DSL components
 require 'cyrel/parameterizable'
-# Require necessary clause and pattern types
+require 'cyrel/logging'
 
 # Require all clause types for DSL methods
 
@@ -19,6 +20,7 @@ module Cyrel
   #   # Manages clauses, parameters, and final query generation, because string interpolation is for amateurs.
   class Query
     include Parameterizable
+    include Logging
     attr_reader :parameters, :clauses # Expose clauses for merge logic
 
     def initialize
@@ -59,6 +61,9 @@ module Cyrel
                         .reject(&:blank?)
                         .join("\n")
 
+        log_debug("QUERY: #{cypher_string}")
+        log_debug("PARAMS: #{@parameters.inspect}") unless @parameters.empty?
+
         [cypher_string, @parameters]
       end
     end