activecypher 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2fe676154a99ad8fc54cfe88731a1c7ce4759235e5103e0d87662c4cd450c2
-  data.tar.gz: 8982b47d70418c6fcc2ec6e4e8a4bd9513df9ac94ab9c8d14b19f0b9af699c22
+  metadata.gz: dc6fb1ecc443117671c36c2b287b44d0059d706c8543ef113915fe0c67e8063d
+  data.tar.gz: 7f7a6e862f2c146dc19e89827e2b0ab2333bcc58f801b07a78e3e0c89f17fc6f
 SHA512:
-  metadata.gz: 1d227c0f135e4203eee987c763b3d6bb2e61e4b24fbc3a5737166bbe1288d042d42d5cc2c83172f2df6d68f42480f76e8260a4571eee533cb53ce68c93f73228
-  data.tar.gz: 2d47c7787d443326b89d8f734107f4492a2cc34f7930ae0c46fbd9e7fda3d1249ea0840376d3653218872ece6434151a557db7b430167a690824981abe54f523
+  metadata.gz: 6cd38267fc15f40e53c9d9d79d11fe52138cc20aa93290043e2aae7834616b6d78afb952a7c1c1ad6baf8e08531170618e43f297d70074c9db806928cd89b807
+  data.tar.gz: c2b0186231f35c838a56272ff6222f64af8a7be53891c8ed90260e297acdccef42992f28b65729ff61410172570cdcd92209c3c817d920d30341cc88906be9ff

data/lib/active_cypher/associations/collection_proxy.rb

@@ -45,7 +45,7 @@ module ActiveCypher
       # Returns the size, because counting things is the only certainty in life.
       #
       # @return [Integer] The number of records in the collection
-      def size   = load_target.size
+      def size = load_target.size
       alias length size
 
       # Fully refresh from the database.

data/lib/active_cypher/associations.rb

@@ -285,6 +285,12 @@ module ActiveCypher
           instance_variable_set(instance_var, associate)
         end
 
+        define_build_and_create_methods(name, target_class_name)
+      end
+
+      # Defines build_<name> and create_<name> for singular associations
+      # (shared by belongs_to and has_one).
+      def define_build_and_create_methods(name, target_class_name)
         # Define build method (e.g., build_author(name: "New Author"))
         define_method("build_#{name}") do |attributes = {}|
           target_class = target_class_name.constantize
@@ -431,25 +437,7 @@ module ActiveCypher
           instance_variable_set(instance_var, associate)
         end
 
-        # Define build method (e.g., build_profile(data: {...}))
-        define_method("build_#{name}") do |attributes = {}|
-          target_class = target_class_name.constantize
-          # TODO: Potentially set the inverse association reference here
-          # For now, just instantiate the target class
-          target_class.new(attributes)
-        end
-
-        # Define create method (e.g., create_profile(data: {...}))
-        define_method("create_#{name}") do |attributes = {}|
-          # Build the instance
-          instance = public_send("build_#{name}", attributes)
-          # Save the instance
-          instance.save
-          # If save is successful, associate it using the = method
-          public_send("#{name}=", instance) if instance.persisted?
-          # Return the instance
-          instance
-        end
+        define_build_and_create_methods(name, target_class_name)
       end
     end
 

data/lib/active_cypher/base.rb

@@ -82,7 +82,7 @@ module ActiveCypher
       # Wrap it all up in a fake-sane object string, so you can pretend your data is organized.
       "#<#{self.class} #{parts.join(', ')}>"
     end
-    
+
     def internal_id
       working_id = super
       return working_id if working_id.nil?

data/lib/active_cypher/bolt/connection.rb

@@ -485,7 +485,6 @@ module ActiveCypher
         session(database: db).write_transaction(db: db, timeout: timeout, metadata: metadata, &)
       end
 
-
       # ────────────────────────────────────────────────────────────────────
       # HEALTH AND VERSION DETECTION METHODS
       # ────────────────────────────────────────────────────────────────────
@@ -514,21 +513,17 @@ module ActiveCypher
       def health_check
         return { healthy: false, response_time_ms: nil, details: 'Not connected' } unless connected?
 
-        result = nil
+        nil
 
         begin
-          result = Sync do
-            case database_type
-            when :neo4j
-              perform_neo4j_health_check
-            when :memgraph
-              perform_memgraph_health_check
-            else
-              perform_generic_health_check
-            end
+          Sync do
+            query = case database_type
+                    when :neo4j then 'RETURN 1 AS result'
+                    when :memgraph then 'SHOW STORAGE INFO'
+                    else 'RETURN 1'
+                    end
+            perform_health_check_query(query)
           end
-
-          result
         rescue ConnectionError, ProtocolError => e
           { healthy: false, response_time_ms: nil, details: "Health check failed: #{e.message}" }
         end
@@ -707,96 +702,15 @@ module ActiveCypher
         }
       end
 
-      # Performs Neo4j-specific health check using RETURN 1 (fallback from db.ping).
-      #
-      # @return [Hash] health check result
-      def perform_neo4j_health_check
-        start_time = Time.now
-
-        begin
-          write_message(Messaging::Run.new('RETURN 1 AS result', {}, {}), 'HEALTH_CHECK')
-          run_response = read_message
-
-          case run_response
-          when Messaging::Success
-            # Send PULL message to complete the transaction
-            write_message(Messaging::Pull.new({ 'n' => -1 }), 'PULL')
-
-            # Read messages until we get SUCCESS or FAILURE
-            response_time = nil
-            loop do
-              msg = read_message
-              case msg
-              when Messaging::Record
-                # Skip records, we just want to know if the query succeeded
-                next
-              when Messaging::Success
-                response_time = ((Time.now - start_time) * 1000).round(2)
-                return { healthy: true, response_time_ms: response_time, details: 'RETURN 1 succeeded' }
-              when Messaging::Failure
-                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 failed with error' }
-              else
-                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 unexpected response' }
-              end
-            end
-          else
-            { healthy: false, response_time_ms: nil, details: 'RETURN 1 run failed' }
-          end
-        ensure
-          # Reset connection state after health check
-          reset!
-        end
-      end
-
-      # Performs Memgraph-specific health check using SHOW STORAGE INFO.
-      #
-      # @return [Hash] health check result
-      def perform_memgraph_health_check
-        start_time = Time.now
-
-        begin
-          write_message(Messaging::Run.new('SHOW STORAGE INFO', {}, {}), 'HEALTH_CHECK')
-          run_response = read_message
-
-          case run_response
-          when Messaging::Success
-            # Send PULL message to complete the transaction
-            write_message(Messaging::Pull.new({ 'n' => -1 }), 'PULL')
-
-            # Read messages until we get SUCCESS or FAILURE
-            response_time = nil
-            loop do
-              msg = read_message
-              case msg
-              when Messaging::Record
-                # Skip records, we just want to know if the query succeeded
-                next
-              when Messaging::Success
-                response_time = ((Time.now - start_time) * 1000).round(2)
-                return { healthy: true, response_time_ms: response_time, details: 'SHOW STORAGE INFO succeeded' }
-              when Messaging::Failure
-                return { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO failed with error' }
-              else
-                return { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO unexpected response' }
-              end
-            end
-          else
-            { healthy: false, response_time_ms: nil, details: 'SHOW STORAGE INFO run failed' }
-          end
-        ensure
-          # Reset connection state after health check
-          reset!
-        end
-      end
-
-      # Performs generic health check using simple RETURN 1 query.
+      # Performs a health check by running the given query and draining the result.
       #
+      # @param query [String] database-appropriate health check query
       # @return [Hash] health check result
-      def perform_generic_health_check
+      def perform_health_check_query(query)
         start_time = Time.now
 
         begin
-          write_message(Messaging::Run.new('RETURN 1', {}, {}), 'HEALTH_CHECK')
+          write_message(Messaging::Run.new(query, {}, {}), 'HEALTH_CHECK')
           run_response = read_message
 
           case run_response
@@ -814,15 +728,15 @@ module ActiveCypher
                 next
               when Messaging::Success
                 response_time = ((Time.now - start_time) * 1000).round(2)
-                return { healthy: true, response_time_ms: response_time, details: 'RETURN 1 succeeded' }
+                return { healthy: true, response_time_ms: response_time, details: "#{query} succeeded" }
               when Messaging::Failure
-                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 failed with error' }
+                return { healthy: false, response_time_ms: nil, details: "#{query} failed with error" }
               else
-                return { healthy: false, response_time_ms: nil, details: 'RETURN 1 unexpected response' }
+                return { healthy: false, response_time_ms: nil, details: "#{query} unexpected response" }
               end
             end
           else
-            { healthy: false, response_time_ms: nil, details: 'RETURN 1 run failed' }
+            { healthy: false, response_time_ms: nil, details: "#{query} run failed" }
           end
         ensure
           # Reset connection state after health check

data/lib/active_cypher/bolt/driver.rb

@@ -40,9 +40,9 @@ module ActiveCypher
       #
       # @yieldparam session [Bolt::Session] The session to use
       # @return [Object] The result of the block
-      def with_session(**kw, &block)
+      def with_session(**kw, &)
         Sync do
-          _acquire_session(**kw, &block)
+          _acquire_session(**kw, &)
         end
       rescue Async::TimeoutError => e
         raise ActiveCypher::ConnectionError, "Connection pool timeout: #{e.message}"
@@ -55,11 +55,11 @@ module ActiveCypher
       #
       # @yieldparam session [Bolt::Session] The session to use
       # @return [Async::Task] A task that resolves to the block's result
-      def async_with_session(**kw, &block)
+      def async_with_session(**kw, &)
         raise 'Cannot run async_with_session outside of an Async task' unless Async::Task.current?
 
         Async do
-          _acquire_session(**kw, &block)
+          _acquire_session(**kw, &)
         end
       end
 

data/lib/active_cypher/bolt/messaging.rb

@@ -67,13 +67,12 @@ module ActiveCypher
         end
       end
 
-      # The HELLO message. Because every protocol needs to start with a greeting before the disappointment.
-      class Hello < Message
-        SIGNATURE = 0x01
-
+      # Base for messages whose single field is a normalized metadata map.
+      # Subclasses only need to define their SIGNATURE.
+      class MetadataMessage < Message
         def initialize(metadata)
           meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
+          super(self.class::SIGNATURE, [meta])
         end
 
         def metadata
@@ -81,22 +80,27 @@ module ActiveCypher
         end
       end
 
-      # The GOODBYE message. For when you've had enough of this session, or life.
-      class Goodbye < Message
-        SIGNATURE = 0x02
-
+      # Base for messages that carry no fields at all.
+      # Subclasses only need to define their SIGNATURE.
+      class EmptyMessage < Message
         def initialize
-          super(SIGNATURE, [])
+          super(self.class::SIGNATURE, [])
         end
       end
 
+      # The HELLO message. Because every protocol needs to start with a greeting before the disappointment.
+      class Hello < MetadataMessage
+        SIGNATURE = 0x01
+      end
+
+      # The GOODBYE message. For when you've had enough of this session, or life.
+      class Goodbye < EmptyMessage
+        SIGNATURE = 0x02
+      end
+
       # The RESET message. Because sometimes you just want to pretend nothing ever happened.
-      class Reset < Message
+      class Reset < EmptyMessage
         SIGNATURE = 0x0F
-
-        def initialize
-          super(SIGNATURE, [])
-        end
       end
 
       # The RUN message. Because what else would you do with a database connection?
@@ -148,115 +152,52 @@ module ActiveCypher
       end
 
       # The COMMIT message. For when you want to pretend your changes are permanent.
-      class Commit < Message
+      class Commit < EmptyMessage
         SIGNATURE = 0x12
-
-        def initialize
-          super(SIGNATURE, [])
-        end
       end
 
       # The ROLLBACK message. Because sometimes you just want to undo your mistakes.
-      class Rollback < Message
+      class Rollback < EmptyMessage
         SIGNATURE = 0x13
-
-        def initialize
-          super(SIGNATURE, [])
-        end
       end
 
       # The DISCARD message. For when you want to throw away results, or your hopes.
-      class Discard < Message
+      class Discard < MetadataMessage
         SIGNATURE = 0x2F
 
         # metadata: { n: <N>, qid: <QID> }, where n = -1 means all
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata = fields.first
-        def n        = metadata[:n] || metadata['n']
-        def qid      = metadata[:qid] || metadata['qid']
+        def n   = metadata[:n] || metadata['n']
+        def qid = metadata[:qid] || metadata['qid']
       end
 
       # The PULL message. Because sometimes you just want to see what you got.
-      class Pull < Message
+      class Pull < MetadataMessage
         SIGNATURE = 0x3F
-
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
       end
 
       # The ROUTE message. For when you want to pretend you have control over routing.
-      class Route < Message
+      class Route < MetadataMessage
         SIGNATURE = 0x66
-
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
       end
 
       # The LOGON message. Because authentication is just another chance to be rejected.
-      class Logon < Message
+      class Logon < MetadataMessage
         SIGNATURE = 0x6A
-
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
       end
 
       # The LOGOFF message. For when you want to leave quietly, without making a scene.
-      class Logoff < Message
+      class Logoff < EmptyMessage
         SIGNATURE = 0x6B
-
-        def initialize
-          super(SIGNATURE, [])
-        end
       end
 
       # The TELEMETRY message. Because someone, somewhere, cares about your metrics. Probably.
-      class Telemetry < Message
+      class Telemetry < MetadataMessage
         SIGNATURE = 0x54
-
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
       end
 
       # The SUCCESS message. The rarest of all Bolt messages.
-      class Success < Message
+      class Success < MetadataMessage
         SIGNATURE = 0x70
-
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
       end
 
       # The RECORD message. For when you actually get data back, against all odds.
@@ -273,27 +214,14 @@ module ActiveCypher
       end
 
       # The IGNORED message. For when the server just can't be bothered.
-      class Ignored < Message
+      class Ignored < EmptyMessage
         SIGNATURE = 0x7E
-
-        def initialize
-          super(SIGNATURE, [])
-        end
       end
 
       # The FAILURE message. The most honest message in the protocol.
-      class Failure < Message
+      class Failure < MetadataMessage
         SIGNATURE = 0x7F
 
-        def initialize(metadata)
-          meta = Messaging.normalize_map(metadata)
-          super(SIGNATURE, [meta])
-        end
-
-        def metadata
-          fields.first
-        end
-
         def code
           metadata['code']
         end

data/lib/active_cypher/bolt/packstream.rb

@@ -89,18 +89,7 @@ module ActiveCypher
         end
 
         def pack_map(map)
-          size = map.size
-
-          if size < 16 # TinyMap
-            write_marker([TINY_MAP_MARKER_BASE | size].pack('C'))
-          elsif size < 256 # MAP_8
-            write_marker([MAP_8_MARKER, size].pack('CC'))
-          elsif size < 65_536 # MAP_16
-            write_marker([MAP_16_MARKER, size].pack('Cn'))
-          else
-            raise ProtocolError, "Map too large to pack (size: #{size})"
-            # write_marker([MAP_32_MARKER, size].pack('CN>'))
-          end
+          write_collection_marker(map.size, TINY_MAP_MARKER_BASE, MAP_8_MARKER, MAP_16_MARKER, 'Map')
 
           map.each do |key, value|
             pack(key.to_s) # Keys must be strings
@@ -109,21 +98,24 @@ module ActiveCypher
         end
 
         def pack_list(list)
-          size = list.size
-          if size < 16 # TinyList
-            write_marker([TINY_LIST_MARKER_BASE | size].pack('C'))
-          elsif size < 256 # LIST_8
-            write_marker([LIST_8_MARKER, size].pack('CC'))
-          elsif size < 65_536 # LIST_16
-            write_marker([LIST_16_MARKER, size].pack('Cn')) # n is already network byte order
-          else
-            raise ProtocolError, "List too large to pack (size: #{size})"
-            # write_marker([LIST_32_MARKER, size].pack('CN>')) # Use N> for network byte order
-          end
+          write_collection_marker(list.size, TINY_LIST_MARKER_BASE, LIST_8_MARKER, LIST_16_MARKER, 'List')
 
           list.each { |item| pack(item) }
         end
 
+        # Writes the size marker shared by maps and lists (tiny / 8-bit / 16-bit).
+        def write_collection_marker(size, tiny_base, marker8, marker16, label)
+          if size < 16 # Tiny
+            write_marker([tiny_base | size].pack('C'))
+          elsif size < 256 # 8-bit size
+            write_marker([marker8, size].pack('CC'))
+          elsif size < 65_536 # 16-bit size ('n' is network byte order)
+            write_marker([marker16, size].pack('Cn'))
+          else
+            raise ProtocolError, "#{label} too large to pack (size: #{size})"
+          end
+        end
+
         def pack_integer(int)
           if int.between?(TINY_INT_MIN, TINY_INT_MAX) # Tiny Integer
             write_marker([int].pack('c')) # Signed char for range -128 to 127

data/lib/active_cypher/connection_adapters/abstract_adapter.rb

@@ -54,7 +54,23 @@ module ActiveCypher
       # @param node_alias [Symbol] The alias used for the node in the query
       # @return [Hash] The hydrated attributes
       def hydrate_record(record, node_alias)
-        raise NotImplementedError, "#{self.class} must implement #hydrate_record"
+        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
 
       # Turns rows into symbols, because Rubyists fear strings.

data/lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb

@@ -98,9 +98,9 @@ module ActiveCypher
       #
       # @yieldparam session [Bolt::Session] The session to use
       # @return [Object] The result of the block
-      def with_session(**kw, &block)
+      def with_session(**kw, &)
         connect
-        @driver.with_session(**kw, &block)
+        @driver.with_session(**kw, &)
       end
 
       # Asynchronously yields a Session from the connection pool.
@@ -108,9 +108,9 @@ module ActiveCypher
       #
       # @yieldparam session [Bolt::Session] The session to use
       # @return [Async::Task] A task that resolves to the block's result
-      def async_with_session(**kw, &block)
+      def async_with_session(**kw, &)
         connect
-        @driver.async_with_session(**kw, &block)
+        @driver.async_with_session(**kw, &)
       end
 
       # Runs a Cypher query via Bolt session.
@@ -169,26 +169,24 @@ module ActiveCypher
 
           begin
             result = Sync do
+              # Try to execute a simple query first
+              session = Bolt::Session.new(@connection)
+              session.run('RETURN 1 AS check', {})
+              session.close
+              true
+            rescue StandardError => e
+              # Query failed, need to reset the connection
+              logger.debug { "Connection needs reset: #{e.message}" }
+
+              # Send RESET message directly
               begin
-                # Try to execute a simple query first
-                session = Bolt::Session.new(@connection)
-                session.run('RETURN 1 AS check', {})
-                session.close
-                true
-              rescue StandardError => e
-                # Query failed, need to reset the connection
-                logger.debug { "Connection needs reset: #{e.message}" }
-
-                # Send RESET message directly
-                begin
-                  @connection.write_message(Bolt::Messaging::Reset.new)
-                  response = @connection.read_message
-                  logger.debug { "Reset response: #{response.class}" }
-                  response.is_a?(Bolt::Messaging::Success)
-                rescue StandardError => reset_error
-                  logger.error { "Reset failed: #{reset_error.message}" }
-                  false
-                end
+                @connection.write_message(Bolt::Messaging::Reset.new)
+                response = @connection.read_message
+                logger.debug { "Reset response: #{response.class}" }
+                response.is_a?(Bolt::Messaging::Success)
+              rescue StandardError => reset_error
+                logger.error { "Reset failed: #{reset_error.message}" }
+                false
               end
             end
           rescue StandardError => e

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -64,7 +64,7 @@ module ActiveCypher
       end
 
       def id_type_conversion(incoming)
-        return incoming.to_i
+        incoming.to_i
       end
 
       # Memgraph uses different constraint syntax than Neo4j
@@ -204,30 +204,6 @@ module ActiveCypher
         metadata.compact
       end
 
-      # Hydrates attributes from a Memgraph record
-      # @param record [Hash] The raw record from Memgraph
-      # @param node_alias [Symbol] The alias used for the node in the query
-      # @return [Hash] The hydrated attributes
-      def hydrate_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
-
       protected
 
       def parse_schema(rows)

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -130,30 +130,6 @@ module ActiveCypher
         metadata.compact
       end
 
-      # Hydrates attributes from a Neo4j record
-      # @param record [Hash] The raw record from Neo4j
-      # @param node_alias [Symbol] The alias used for the node in the query
-      # @return [Hash] The hydrated attributes
-      def hydrate_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
-
       module Persistence
         include PersistenceMethods
 

data/lib/active_cypher/migration.rb

@@ -92,14 +92,13 @@ module ActiveCypher
     end
 
     def create_uniqueness_constraint(label, *props, if_not_exists: true, name: nil)
+      props_clause = props.map { |p| "n.#{p}" }.join(', ')
       cypher = if connection.vendor == :memgraph
                  # Memgraph syntax: CREATE CONSTRAINT ON (n:Label) ASSERT n.prop IS UNIQUE
                  # Note: Memgraph doesn't support IF NOT EXISTS or named constraints
-                 props_clause = props.map { |p| "n.#{p}" }.join(', ')
                  "CREATE CONSTRAINT ON (n:#{label}) ASSERT #{props_clause} IS UNIQUE"
                else
                  # Neo4j syntax
-                 props_clause = props.map { |p| "n.#{p}" }.join(', ')
                  c = +'CREATE CONSTRAINT'
                  c << " #{name}" if name
                  c << ' IF NOT EXISTS' if if_not_exists
@@ -113,7 +112,7 @@ module ActiveCypher
       cypher = if connection.vendor == :memgraph
                  # Memgraph TEXT INDEX syntax (requires --experimental-enabled='text-search')
                  # Memgraph only supports single property per text index, so create one per prop
-                 props.map.with_index do |p, i|
+                 props.map.with_index do |p, _i|
                    index_name = props.size > 1 ? "#{name}_#{p}" : name.to_s
                    "CREATE TEXT INDEX #{index_name} ON :#{label}(#{p})"
                  end

data/lib/active_cypher/model/core.rb

@@ -36,7 +36,7 @@ module ActiveCypher
           clear_changes_information
         end
       end
-      
+
       def ==(other)
         # Compares by class and internal graph id only.
         # Note: an unsaved modification will still compare equal to the persisted version.
@@ -44,8 +44,6 @@ module ActiveCypher
 
         internal_id == other.internal_id
       end
-
-
     end
   end
 end

data/lib/active_cypher/relation.rb

@@ -176,7 +176,7 @@ module ActiveCypher
         # ------------------------------------------------------------
         if node_payload.is_a?(Array) && node_payload.first == 78
           # Re‑use the adapter's private helper for consistency
-          # why is it private? This seems to be the only place it's called 
+          # why is it private? This seems to be the only place it's called
           node_payload = model_class.connection
                                     .send(:process_node, node_payload)
         end

data/lib/active_cypher/relationship.rb

@@ -234,10 +234,10 @@ module ActiveCypher
         rid = row[:rid] || row['rid']
         from_node_id = (row[:from_node] || row['from_node'])&.dig(1, 0)
         to_node_id   = (row[:to_node]   || row['to_node'])&.dig(1, 0)
-        
+
         # this is extra queries, but easier than navigating instantiation from the row data
-        from_node = Object.const_get(self.from_class).find(from_node_id)
-        to_node = Object.const_get(self.to_class).find(to_node_id)
+        from_node = Object.const_get(from_class).find(from_node_id)
+        to_node = Object.const_get(to_class).find(to_node_id)
 
         # Extract properties from the relationship data
         # Memgraph returns relationships wrapped as [type_code, [actual_data]]

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.15.1'
+  VERSION = '0.15.2'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/cyrel/clause/create.rb

@@ -9,11 +9,7 @@ module Cyrel
       # @param pattern [Cyrel::Pattern::Path, Cyrel::Pattern::Node, Cyrel::Pattern::Relationship]
       #   The pattern to create. Typically a Path or Node.
       def initialize(pattern)
-        # Ensure pattern is a valid type for CREATE
-        unless pattern.is_a?(Cyrel::Pattern::Path) || pattern.is_a?(Cyrel::Pattern::Node) || pattern.is_a?(Cyrel::Pattern::Relationship)
-          raise ArgumentError,
-                "CREATE pattern must be a Cyrel::Pattern::Path, Node, or Relationship, got #{pattern.class}"
-        end
+        Cyrel::Pattern.assert_pattern!(pattern, 'CREATE')
 
         # NOTE: Creating relationships between existing nodes requires coordination.
         # The pattern itself should reference existing aliases defined in a preceding MATCH/MERGE.

data/lib/cyrel/clause/match.rb

@@ -12,13 +12,7 @@ module Cyrel
       # @param path_variable [Symbol, String, nil] An optional variable to assign to the matched path.
       def initialize(pattern, optional: false, path_variable: nil)
         super() # Call super for Base initialization
-        # Ensure pattern is a valid type
-        unless pattern.is_a?(Cyrel::Pattern::Path) ||
-               pattern.is_a?(Cyrel::Pattern::Node) ||
-               pattern.is_a?(Cyrel::Pattern::Relationship)
-          raise ArgumentError,
-                "Match pattern must be a Cyrel::Pattern::Path, Node, or Relationship, got #{pattern.class}"
-        end
+        Cyrel::Pattern.assert_pattern!(pattern, 'Match')
 
         @pattern = pattern
         @optional = optional

data/lib/cyrel/clause/merge.rb

@@ -12,11 +12,7 @@ module Cyrel
       # @param pattern [Cyrel::Pattern::Path, Cyrel::Pattern::Node, Cyrel::Pattern::Relationship]
       #   The pattern to merge. Typically a Path or Node.
       def initialize(pattern)
-        # Ensure pattern is a valid type for MERGE
-        unless pattern.is_a?(Cyrel::Pattern::Path) || pattern.is_a?(Cyrel::Pattern::Node) || pattern.is_a?(Cyrel::Pattern::Relationship)
-          raise ArgumentError,
-                "MERGE pattern must be a Cyrel::Pattern::Path, Node, or Relationship, got #{pattern.class}"
-        end
+        Cyrel::Pattern.assert_pattern!(pattern, 'MERGE')
 
         @pattern = pattern
       end

data/lib/cyrel/expression/exists.rb

@@ -13,10 +13,7 @@ module Cyrel
       # @param pattern [Cyrel::Pattern::Path, Cyrel::Pattern::Node, Cyrel::Pattern::Relationship]
       #   The pattern to check for existence.
       def initialize(pattern)
-        unless pattern.is_a?(Cyrel::Pattern::Path) || pattern.is_a?(Cyrel::Pattern::Node) || pattern.is_a?(Cyrel::Pattern::Relationship)
-          raise ArgumentError,
-                "EXISTS pattern must be a Cyrel::Pattern::Path, Node, or Relationship, got #{pattern.class}"
-        end
+        Cyrel::Pattern.assert_pattern!(pattern, 'EXISTS')
 
         @pattern = pattern
       end

data/lib/cyrel/expression/pattern_comprehension.rb

@@ -13,10 +13,7 @@ module Cyrel
       # @param projection_expression [Cyrel::Expression::Base, Object]
       #   The expression evaluated for each match of the pattern.
       def initialize(pattern, projection_expression)
-        unless pattern.is_a?(Cyrel::Pattern::Path) || pattern.is_a?(Cyrel::Pattern::Node) || pattern.is_a?(Cyrel::Pattern::Relationship)
-          raise ArgumentError,
-                "Pattern Comprehension pattern must be a Path, Node, or Relationship, got #{pattern.class}"
-        end
+        Cyrel::Pattern.assert_pattern!(pattern, 'Pattern Comprehension')
 
         @pattern = pattern
         @projection_expression = Expression.coerce(projection_expression)

data/lib/cyrel/pattern/node.rb

@@ -12,7 +12,7 @@ module Cyrel
 
       attribute :alias_name, Cyrel::Types::SymbolType.new
       attribute :labels,     array: :string, default: []
-      attribute :or_labels,  array: :string, default: []  # Memgraph 3.2+: (n:Label1|Label2)
+      attribute :or_labels,  array: :string, default: [] # Memgraph 3.2+: (n:Label1|Label2)
       attribute :properties, Cyrel::Types::HashType.new, default: -> { {} }
 
       validates :alias_name, presence: true

data/lib/cyrel/pattern.rb

@@ -4,5 +4,15 @@ module Cyrel
   # Namespace for classes representing structural components of Cypher patterns
   # (nodes, relationships, paths).
   module Pattern
+    # Validates that the given object is a usable pattern (Path, Node, or Relationship).
+    # @param pattern [Object] The object to validate.
+    # @param context [String] Label used in the error message (e.g. "CREATE", "MATCH").
+    # @raise [ArgumentError] When the object is not a pattern.
+    def self.assert_pattern!(pattern, context)
+      return pattern if pattern.is_a?(Path) || pattern.is_a?(Node) || pattern.is_a?(Relationship)
+
+      raise ArgumentError,
+            "#{context} pattern must be a Cyrel::Pattern::Path, Node, or Relationship, got #{pattern.class}"
+    end
   end
 end

data/lib/cyrel/query.rb

@@ -136,13 +136,7 @@ module Cyrel
       # ------------------------------------------------------------------
       processed_conditions = conditions.flat_map do |cond|
         if cond.is_a?(Hash)
-          cond.map do |key, value|
-            Expression::Comparison.new(
-              Expression::PropertyAccess.new(@current_alias || infer_alias, key),
-              :'=',
-              value
-            )
-          end
+          hash_to_conditions(cond)
         else
           cond # already an expression (or coercible)
         end
@@ -155,7 +149,7 @@ module Cyrel
       # ------------------------------------------------------------------
       # 2. Merge with an existing WHERE (if any)
       # ------------------------------------------------------------------
-      existing_where_index = @clauses.find_index { |c| c.is_a?(Clause::Where) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::WhereNode)) }
+      existing_where_index = find_clause_index(Clause::Where, AST::WhereNode)
 
       if existing_where_index
         existing_clause = @clauses[existing_where_index]
@@ -258,7 +252,7 @@ module Cyrel
       ast_clause = AST::ClauseAdapter.new(set_node)
 
       # Check for existing SET clause to merge with
-      existing_set_index = @clauses.find_index { |c| c.is_a?(Clause::Set) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::SetNode)) }
+      existing_set_index = find_clause_index(Clause::Set, AST::SetNode)
 
       if existing_set_index
         existing_clause = @clauses[existing_set_index]
@@ -321,58 +315,19 @@ module Cyrel
     # @return [self]
     # Because sometimes you want to pass things along, and sometimes you just want to pass the buck.
     def with(*items, distinct: false, where: nil)
-      # Process items similar to existing Return clause
-      processed_items = items.flatten.map do |item|
-        case item
-        when Expression::Base
-          item
-        when Symbol
-          # Create a RawIdentifier for variable names
-          Clause::Return::RawIdentifier.new(item.to_s)
-        when String
-          # Check if string looks like property access (e.g. "person.name")
-          # If so, treat as raw identifier, otherwise parameterize
-          if item.match?(/\A\w+\.\w+\z/)
-            Clause::Return::RawIdentifier.new(item)
-          else
-            # String literals should be coerced to expressions (parameterized)
-            Expression.coerce(item)
-          end
-        else
-          Expression.coerce(item)
-        end
-      end
+      processed_items = process_projection_items(items)
 
       # Process WHERE conditions if provided
       where_conditions = case where
                          when nil then []
-                         when Hash
-                           # Convert hash to equality comparisons
-                           where.map do |key, value|
-                             Expression::Comparison.new(
-                               Expression::PropertyAccess.new(@current_alias || infer_alias, key),
-                               :'=',
-                               value
-                             )
-                           end
+                         when Hash then hash_to_conditions(where)
                          when Array then where
                          else [where] # Single condition
                          end
 
       # Use AST-based implementation
       with_node = AST::WithNode.new(processed_items, distinct: distinct, where_conditions: where_conditions)
-      ast_clause = AST::ClauseAdapter.new(with_node)
-
-      # Find and replace existing with or add new one
-      existing_with_index = @clauses.find_index { |c| c.is_a?(Clause::With) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::WithNode)) }
-
-      if existing_with_index
-        @clauses[existing_with_index] = ast_clause
-      else
-        add_clause(ast_clause)
-      end
-
-      self
+      replace_or_add_clause(AST::ClauseAdapter.new(with_node), Clause::With, AST::WithNode)
     end
 
     # Adds a RETURN clause.
@@ -384,41 +339,11 @@ module Cyrel
     # is a reserved keyword in Ruby. We're not crazy - we just want to provide
     # a clean DSL while respecting Ruby's language constraints.
     def return_(*items, distinct: false)
-      # Process items similar to existing Return clause
-      processed_items = items.flatten.map do |item|
-        case item
-        when Expression::Base
-          item
-        when Symbol
-          # Create a RawIdentifier for variable names
-          Clause::Return::RawIdentifier.new(item.to_s)
-        when String
-          # Check if string looks like property access (e.g. "person.name")
-          # If so, treat as raw identifier, otherwise parameterize
-          if item.match?(/\A\w+\.\w+\z/)
-            Clause::Return::RawIdentifier.new(item)
-          else
-            # String literals should be coerced to expressions (parameterized)
-            Expression.coerce(item)
-          end
-        else
-          Expression.coerce(item)
-        end
-      end
+      processed_items = process_projection_items(items)
 
       # Use AST-based implementation
       return_node = AST::ReturnNode.new(processed_items, distinct: distinct)
-      ast_clause = AST::ClauseAdapter.new(return_node)
-
-      # Find and replace existing return or add new one
-      existing_return_index = @clauses.find_index { |c| c.is_a?(Clause::Return) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::ReturnNode)) }
-
-      if existing_return_index
-        @clauses[existing_return_index] = ast_clause
-      else
-        add_clause(ast_clause)
-      end
-      self
+      replace_or_add_clause(AST::ClauseAdapter.new(return_node), Clause::Return, AST::ReturnNode)
     end
 
     # Adds or replaces the ORDER BY clause.
@@ -432,17 +357,7 @@ module Cyrel
 
       # Use AST-based implementation
       order_by_node = AST::OrderByNode.new(items_array)
-      ast_clause = AST::ClauseAdapter.new(order_by_node)
-
-      # Find and replace existing order by or add new one
-      existing_order_index = @clauses.find_index { |c| c.is_a?(Clause::OrderBy) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::OrderByNode)) }
-
-      if existing_order_index
-        @clauses[existing_order_index] = ast_clause
-      else
-        add_clause(ast_clause)
-      end
-      self
+      replace_or_add_clause(AST::ClauseAdapter.new(order_by_node), Clause::OrderBy, AST::OrderByNode)
     end
 
     # Adds or replaces the SKIP clause.
@@ -452,17 +367,7 @@ module Cyrel
     def skip(amount)
       # Use AST-based implementation
       skip_node = AST::SkipNode.new(amount)
-      ast_clause = AST::ClauseAdapter.new(skip_node)
-
-      # Find and replace existing skip or add new one
-      existing_skip_index = @clauses.find_index { |c| c.is_a?(Clause::Skip) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::SkipNode)) }
-
-      if existing_skip_index
-        @clauses[existing_skip_index] = ast_clause
-      else
-        add_clause(ast_clause)
-      end
-      self
+      replace_or_add_clause(AST::ClauseAdapter.new(skip_node), Clause::Skip, AST::SkipNode)
     end
 
     # Adds or replaces the LIMIT clause.
@@ -472,18 +377,7 @@ module Cyrel
     def limit(amount)
       # Use AST-based implementation
       limit_node = AST::LimitNode.new(amount)
-      ast_clause = AST::ClauseAdapter.new(limit_node)
-
-      # Find and replace existing limit or add new one
-      existing_limit_index = @clauses.find_index { |c| c.is_a?(Clause::Limit) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(AST::LimitNode)) }
-
-      if existing_limit_index
-        @clauses[existing_limit_index] = ast_clause
-      else
-        add_clause(ast_clause)
-      end
-
-      self
+      replace_or_add_clause(AST::ClauseAdapter.new(limit_node), Clause::Limit, AST::LimitNode)
     end
 
     # Adds a CALL procedure clause.
@@ -600,6 +494,58 @@ module Cyrel
       add_clause(AST::ClauseAdapter.new(load_csv_node))
     end
 
+    # Coerces projection items (symbols, strings, expressions) for WITH/RETURN clauses.
+    def process_projection_items(items)
+      items.flatten.map do |item|
+        case item
+        when Expression::Base
+          item
+        when Symbol
+          # Create a RawIdentifier for variable names
+          Clause::Return::RawIdentifier.new(item.to_s)
+        when String
+          # Check if string looks like property access (e.g. "person.name")
+          # If so, treat as raw identifier, otherwise parameterize
+          if item.match?(/\A\w+\.\w+\z/)
+            Clause::Return::RawIdentifier.new(item)
+          else
+            # String literals should be coerced to expressions (parameterized)
+            Expression.coerce(item)
+          end
+        else
+          Expression.coerce(item)
+        end
+      end
+    end
+
+    # Converts a Hash into equality comparisons against the current alias.
+    def hash_to_conditions(hash)
+      hash.map do |key, value|
+        Expression::Comparison.new(
+          Expression::PropertyAccess.new(@current_alias || infer_alias, key),
+          :'=',
+          value
+        )
+      end
+    end
+
+    # Finds the index of an existing clause matching either the legacy clause
+    # class or an AST::ClauseAdapter wrapping the given AST node class.
+    def find_clause_index(clause_class, ast_node_class)
+      @clauses.find_index { |c| c.is_a?(clause_class) || (c.is_a?(AST::ClauseAdapter) && c.ast_node.is_a?(ast_node_class)) }
+    end
+
+    # Replaces an existing matching clause in place, or appends the new one.
+    def replace_or_add_clause(ast_clause, clause_class, ast_node_class)
+      existing_index = find_clause_index(clause_class, ast_node_class)
+      if existing_index
+        @clauses[existing_index] = ast_clause
+      else
+        add_clause(ast_clause)
+      end
+      self
+    end
+
     # private
 
     # Merges parameters from another query, ensuring keys are unique.

data/lib/cyrel.rb

@@ -93,55 +93,34 @@ module Cyrel
       # When called like: node(:a) > rel(:r) > node(:b)
       # The rel(:r) is evaluated first, then > is called
       # So we need to modify the last relationship that was just added
-      if @elements.last.is_a?(Cyrel::Pattern::Relationship)
-        # Replace the last relationship with one that has the correct direction
-        last_rel = @elements.pop
-        new_rel = Cyrel::Pattern::Relationship.new(
-          alias_name: last_rel.alias_name,
-          types: last_rel.types,
-          properties: last_rel.properties,
-          length: last_rel.length,
-          direction: :outgoing
-        )
-        @elements << new_rel
-      else
-        @pending_direction = :outgoing
-      end
-      self
+      apply_direction(:outgoing)
     end
 
     def <(_other)
       # Same logic as > but for incoming direction
-      if @elements.last.is_a?(Cyrel::Pattern::Relationship)
-        last_rel = @elements.pop
-        new_rel = Cyrel::Pattern::Relationship.new(
-          alias_name: last_rel.alias_name,
-          types: last_rel.types,
-          properties: last_rel.properties,
-          length: last_rel.length,
-          direction: :incoming
-        )
-        @elements << new_rel
-      else
-        @pending_direction = :incoming
-      end
-      self
+      apply_direction(:incoming)
     end
 
     def -(_other)
       # Same logic as > but for bidirectional
+      apply_direction(:both)
+    end
+
+    private
+
+    def apply_direction(direction)
       if @elements.last.is_a?(Cyrel::Pattern::Relationship)
+        # Replace the last relationship with one that has the correct direction
         last_rel = @elements.pop
-        new_rel = Cyrel::Pattern::Relationship.new(
+        @elements << Cyrel::Pattern::Relationship.new(
           alias_name: last_rel.alias_name,
           types: last_rel.types,
           properties: last_rel.properties,
           length: last_rel.length,
-          direction: :both
+          direction: direction
         )
-        @elements << new_rel
       else
-        @pending_direction = :both
+        @pending_direction = direction
       end
       self
     end
@@ -256,9 +235,9 @@ module Cyrel
   # Example:
   #   Cyrel.exists_block { match(Cyrel.node(:a) > Cyrel.rel(:r) > Cyrel.node(:b, :Admin)) }
   #   # => EXISTS { MATCH (a)-[r]->(b:Admin) }
-  def exists_block(&block)
+  def exists_block(&)
     subquery = Query.new
-    subquery.instance_eval(&block)
+    subquery.instance_eval(&)
     Expression::ExistsBlock.new(subquery)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.15.2
 platform: ruby
 authors:
 - Abdelkader Boudih