activecypher 0.3.0 → 0.6.0

data/lib/active_cypher/model/connection_owner.rb

@@ -3,48 +3,56 @@
 module ActiveCypher
   module Model
     # Mixin for anything that “owns” a connection (nodes, relationships, maybe
-    # graph‑level service objects later). 100 % framework‑agnostic.
-    # @note Because every object wants to feel important by "owning" something, even if it's just a connection.
-    # Moroccan black magick and Ruby sorcery may be involved in keeping these connections alive.
+    # graph‑level service objects later). 100 % framework‑agnostic.
     module ConnectionOwner
       extend ActiveSupport::Concern
       include ActiveCypher::Logging
       include ActiveCypher::Model::ConnectionHandling
 
-      included do
-        # Every class gets its own adapter slot (overridden by establish_connection)
-        # Because nothing says "flexibility" like a class variable you'll forget exists.
-        # This is where the witchcraft happens: sometimes the right connection just appears.
-        cattr_accessor :connection, instance_accessor: false
-      end
-
       class_methods do
-        delegate :current_role, :current_shard,
-                 to: ActiveCypher::RuntimeRegistry
-
         # One handler for all subclasses that include this concern
-        # Because sharing is caring, except when it comes to connection pools.
-        # Summoned by Ruby wizardry: this handler is conjured once and shared by all.
-        @@connection_handler ||= ActiveCypher::ConnectionHandler.new # rubocop:disable Style/ClassVars
-        def connection_handler = @@connection_handler
-
-        # Temporarily switches the current role and shard for the duration of the block.
-        # @param role [Symbol, nil] The role to switch to
-        # @param shard [Symbol] The shard to switch to
-        # @yield The block to execute with the new context
-        # @note Because sometimes you just want to pretend you're connected to something else for a while.
-        # Warning: If you switch too often, you may summon unexpected spirits from the Ruby shadow dimension.
-        def connected_to(role: nil, shard: :default)
-          previous_role  = current_role
-          previous_shard = current_shard
-          ActiveCypher::RuntimeRegistry.current_role  = role  || previous_role
-          ActiveCypher::RuntimeRegistry.current_shard = shard || previous_shard
-          yield
-        ensure
-          ActiveCypher::RuntimeRegistry.current_role  = previous_role
-          ActiveCypher::RuntimeRegistry.current_shard = previous_shard
+        def connection_handler
+          if defined?(@connection_handler) && @connection_handler
+            @connection_handler
+          elsif superclass.respond_to?(:connection_handler)
+            superclass.connection_handler
+          else
+            @connection_handler = ActiveCypher::ConnectionHandler.new
+          end
+        end
+
+        # Returns the adapter class being used by this model
+        def adapter_class
+          connection&.class
+        end
+
+        # Always dynamically fetch the connection for the current db_key
+        def connection
+          handler = connection_handler
+
+          if respond_to?(:connects_to_mappings) && connects_to_mappings.is_a?(Hash)
+            db_key = connects_to_mappings[:writing] # Default to :writing mapping
+            if db_key && (pool = handler.pool(db_key))
+              return pool.connection
+            end
+          end
+
+          return superclass.connection if superclass.respond_to?(:connection)
+
+          raise ActiveCypher::ConnectionNotEstablished,
+                "No connection pool found for #{name}, db_key=#{db_key.inspect}"
         end
       end
+
+      # Instance method to access the adapter class
+      def adapter_class
+        self.class.adapter_class
+      end
+
+      # Instance method to access the connection dynamically
+      def connection
+        self.class.connection
+      end
     end
   end
 end

data/lib/active_cypher/model/core.rb

@@ -1,27 +1,19 @@
 # frozen_string_literal: true
 
-require 'active_model'
-
 module ActiveCypher
   module Model
-    # @!parse
-    #   # Core: The module that tries to make your graph model feel like it belongs in a relational world.
-    #   # Includes every concern under the sun, because why have one abstraction when you can have twelve?
-    #   # Most of this works thanks to a little Ruby sorcery, a dash of witchcraft, and—on rare occasions—some unexplained back magick.
+    # Core: The module that tries to make your graph model feel like it belongs in a relational world.
+    # Includes every concern under the sun, because why have one abstraction when you can have twelve?
+    # Most of this works thanks to a little Ruby sorcery, a dash of witchcraft, and—on rare occasions—some unexplained back magick.
     module Core
       extend ActiveSupport::Concern
 
       included do
-        include ActiveModel::API
-        include ActiveModel::Attributes
-        include ActiveModel::Dirty
         include ActiveCypher::Associations
         include ActiveCypher::Scoping
-        include ActiveModel::Validations
 
-        attribute :internal_id, :string
+        attribute :internal_id, :integer
 
-        cattr_accessor :connection, instance_accessor: false
         class_attribute :configurations, instance_accessor: false,
                                          default: ActiveSupport::HashWithIndifferentAccess.new
       end

data/lib/active_cypher/model/countable.rb

@@ -16,9 +16,16 @@ module ActiveCypher
         # If this returns the right number, thank the database gods—or maybe just the back magick hiding in the adapter.
         def count
           cypher, params =
-            if respond_to?(:label_name)          # ⇒ node class
-              ["MATCH (n:#{label_name}) RETURN count(n) AS c", {}]
-            else                                 # ⇒ relationship class
+            if respond_to?(:label_name) # ⇒ node class
+              if respond_to?(:labels) && labels.any?
+                # Use all custom labels for COUNT operations
+                label_string = labels.map { |l| ":#{l}" }.join
+                ["MATCH (n#{label_string}) RETURN count(n) AS c", {}]
+              else
+                # Fall back to primary label
+                ["MATCH (n:#{label_name}) RETURN count(n) AS c", {}]
+              end
+            else # ⇒ relationship class
               ["MATCH ()-[r:#{relationship_type}]-() RETURN count(r) AS c", {}] # ▲ undirected
             end
 

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.
@@ -22,23 +20,30 @@ module ActiveCypher
           raise 'Cannot destroy a new record' if new_record?
           raise 'Record already destroyed' if destroyed?
 
-          n      = :n
-          query  = Cyrel.match(Cyrel.node(self.class.label_name).as(n))
-                        .where(Cyrel.id(n).eq(internal_id))
-                        .detach_delete(n)
+          n = :n
+          labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
+          label_string = labels.map { |l| ":#{l}" }.join
 
-          cypher = query.to_cypher
-          params = { id: internal_id }
+          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.
-          self.class.connection.execute_cypher(cypher, params, 'Destroy')
-          @destroyed = true
-          freeze # To make sure you can't Frankenstein it back to life. Lightning not included.
-          true
+          result = self.class.connection.execute_cypher(cypher, {}, 'Destroy')
+
+          if result.present? && result.first[:deleted].to_i > 0
+            @destroyed = true
+            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.
@@ -131,16 +123,35 @@ module ActiveCypher
       def create_record
         props = attributes_for_persistence
         n = :n
-        label = self.class.label_name.to_s
-        node = Cyrel.node(n, labels: [label], properties: props)
-        query = Cyrel.create(node).return_(Cyrel.element_id(n).as(:internal_id))
-        cypher, params = query.to_cypher
-        params ||= {}
 
-        data = self.class.connection.execute_cypher(cypher, params, 'Create')
+        # Use all labels for database operations
+        labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name.to_s]
+
+        # 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')
+
         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
@@ -165,15 +176,30 @@ module ActiveCypher
         changes = changes_to_save
         return true if changes.empty?
 
-        n = :n
-        query = Cyrel.match(Cyrel.node(self.class.label_name).as(n))
-                     .where(Cyrel.id(n).eq(internal_id))
-                     .set(n => changes)
+        # Use all labels for database operations
+        labels = self.class.respond_to?(:labels) ? self.class.labels : [self.class.label_name]
+
+        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 = "MATCH (n#{label_string}) " \
+                 "WHERE id(n) = #{internal_id} " \
+                 "SET #{set_clauses} " \
+                 'RETURN n'
 
-        cypher, params = query.to_cypher
-        params ||= {}
+        self.class.connection.execute_cypher(cypher, {}, 'Update')
 
-        self.class.connection.execute_cypher(cypher, params, 'Update')
         changes_applied
         true
       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,31 +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
 
-          query = Cyrel
-                  .match(Cyrel.node(label_name).as(node_alias))
-                  .where(Cyrel.element_id(node_alias).eq(internal_db_id))
-                  .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
-                  .limit(1)
+          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
+
+          result = connection.execute_cypher(cypher)
+          record = result.first
+
+          if record
+            attrs = _hydrate_attributes_from_memgraph_record(record, node_alias)
+            return instantiate(attrs)
+          end
 
-          Relation.new(self, query).first or
-            raise ActiveCypher::RecordNotFound,
-                  "#{name} with internal_id=#{internal_db_id.inspect} not found"
+          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.
@@ -61,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/relation.rb

@@ -129,11 +129,19 @@ module ActiveCypher
     # Because writing Cypher by hand is for people with too much free time.
     # @return [Object] The default Cyrel query
     def default_query
-      label      = model_class.model_name.element
       node_alias = :n
 
+      # Use all labels if available, otherwise fall back to primary label
+      labels = if model_class.respond_to?(:labels)
+                 model_class.labels
+               elsif model_class.respond_to?(:label_name)
+                 [model_class.label_name]
+               else
+                 [model_class.model_name.element.to_sym]
+               end
+
       Cyrel
-        .match(Cyrel.node(label).as(node_alias))
+        .match(Cyrel.node(node_alias, labels: labels))
         .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
     end