activecypher 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 738573111aeb926ef359c2bd2643e07d25f83b76d63f7cebf0d31e762c06fabf
-  data.tar.gz: 8ede3884325f7e86e4ca06dea636e0193d8742fc19b0ed2e92724f3270f31f7f
+  metadata.gz: bcfe9f62e0fdcf58b7d4f46fef0b7869bac550fc730f2e93a2d057938cad8a4e
+  data.tar.gz: a835e25b6ff10e6e9e4884c2855091e617086e1635931988cc018d9eac06afd8
 SHA512:
-  metadata.gz: afc1446c1c2e7195ed3ad241e84bcdaffaf9c634084068088f15137f897ea4955d80448af5b80b225af204a23baa217486b4327160b50b7bd41899d7c6b95df1
-  data.tar.gz: f5cf3960f8127672e803d9dd9d2246e8245499e2f7208013e2bd97a4e5971fbcd5044aa107bcf1208a21cfc40337d0c89cbc3354706dce06f0bb1df8b62d84a3
+  metadata.gz: 4297ab6127aa159da2800dd2024102e8768cfac6604ce390fa35d71d95b393e3226a6d544e535ccc09c14d1632a23009c48df5067a62b6f158fc344b7e1ff21c
+  data.tar.gz: b929133db5f0be22b7fbd2e3923e54b0a6b041e748d28dc32bbd6f454ab0547ea48637a945262b480339ccee8e78551b23b64cd6aea8a276c5f3d5e766adbc8d

data/lib/active_cypher/associations/collection_proxy.rb

@@ -128,9 +128,9 @@ module ActiveCypher
           arrow = (dir == :both ? :'--' : :out)
           Cyrel
             .match(Cyrel.node(from_node.class.label_name).as(:a)
-                        .where(Cyrel.id(:a).eq(from_node.internal_id)))
+                        .where(Cyrel.node_id(:a).eq(from_node.internal_id)))
             .match(Cyrel.node(to_node.class.label_name).as(:b)
-                        .where(Cyrel.id(:b).eq(to_node.internal_id)))
+                        .where(Cyrel.node_id(:b).eq(to_node.internal_id)))
             .create(Cyrel.node(:a).rel(arrow, reflection[:relationship]).to(:b))
             .tap { |qry| owner.class.connection.execute_cypher(*qry.to_cypher, 'Create Association') }
         end

data/lib/active_cypher/associations.rb

@@ -142,7 +142,7 @@ module ActiveCypher
           # Compose query  MATCH – WHERE – RETURN
           query = Cyrel::Query.new
                               .match(path)
-                              .where(Cyrel.id(a_alias).eq(internal_id))
+                              .where(Cyrel.node_id(a_alias).eq(internal_id))
                               .return_(b_alias)
 
           base_relation = Relation.new(target_class, query)
@@ -186,7 +186,7 @@ module ActiveCypher
 
           query = Cyrel::Query.new
                               .match(path)
-                              .where(Cyrel.id(a_alias).eq(internal_id))
+                              .where(Cyrel.node_id(a_alias).eq(internal_id))
                               .return_(b_alias)
                               .limit(1)
 
@@ -225,8 +225,8 @@ module ActiveCypher
                                       .rel(cyrel_direction, rel_type)
                                       .as(del_rel_alias)
                                       .to(del_end_alias))
-                        .where(Cyrel.id(del_start_alias).eq(del_start_node.internal_id))
-                        .where(Cyrel.id(del_end_alias).eq(del_end_node.internal_id))
+                        .where(Cyrel.node_id(del_start_alias).eq(del_start_node.internal_id))
+                        .where(Cyrel.node_id(del_end_alias).eq(del_end_node.internal_id))
                         .delete(del_rel_alias)
 
             self.class.connection.execute_cypher(
@@ -266,8 +266,8 @@ module ActiveCypher
               create_query = Cyrel
                              .match(Cyrel.node(new_start_node.class.label_name).as(new_start_alias))
                              .match(Cyrel.node(new_end_node.class.label_name).as(new_end_alias))
-                             .where(Cyrel.id(new_start_alias).eq(new_start_node.internal_id))
-                             .where(Cyrel.id(new_end_alias).eq(new_end_node.internal_id))
+                             .where(Cyrel.node_id(new_start_alias).eq(new_start_node.internal_id))
+                             .where(Cyrel.node_id(new_end_alias).eq(new_end_node.internal_id))
                              .create(Cyrel.node(new_start_alias)
                                             .rel(arrow, rel_type)
                                             .to(new_end_alias))
@@ -322,7 +322,7 @@ module ActiveCypher
           target_node_alias = :target_node
 
           start_node_pattern = Cyrel.node(self.class.label_name).as(start_node_alias)
-                                    .where(Cyrel.id(start_node_alias).eq(internal_id))
+                                    .where(Cyrel.node_id(start_node_alias).eq(internal_id))
           target_node_pattern = Cyrel.node(target_class.label_name).as(target_node_alias)
 
           rel_pattern = case direction
@@ -372,10 +372,10 @@ module ActiveCypher
             # Adjust direction for Cyrel pattern if needed
             cyrel_direction = direction == :in ? :out : direction
             del_query = Cyrel.match(Cyrel.node(del_start_node.class.label_name)
-                                         .as(del_start_alias).where(Cyrel.id(del_start_alias)
+                                         .as(del_start_alias).where(Cyrel.node_id(del_start_alias)
                                                                          .eq(del_start_node.internal_id)))
                              .match(Cyrel.node(del_end_node.class.label_name)
-                                         .as(del_end_alias).where(Cyrel.id(del_end_alias)
+                                         .as(del_end_alias).where(Cyrel.node_id(del_end_alias)
                                                                        .eq(del_end_node.internal_id)))
                              .match(Cyrel.node(del_start_alias).rel(cyrel_direction,
                                                                     rel_type).as(del_rel_alias).to(del_end_alias))
@@ -411,10 +411,10 @@ module ActiveCypher
               new_start_alias = :a
               new_end_alias = :b
               create_query = Cyrel.match(Cyrel.node(new_start_node.class.label_name)
-                                              .as(new_start_alias).where(Cyrel.id(new_start_alias)
+                                              .as(new_start_alias).where(Cyrel.node_id(new_start_alias)
                                                                               .eq(new_start_node.internal_id)))
                                   .match(Cyrel.node(new_end_node.class.label_name)
-                                              .as(new_end_alias).where(Cyrel.id(new_end_alias)
+                                              .as(new_end_alias).where(Cyrel.node_id(new_end_alias)
                                                                             .eq(new_end_node.internal_id)))
                                   .create(Cyrel.node(new_start_alias).rel(:out, rel_type).to(new_end_alias))
 
@@ -488,7 +488,7 @@ module ActiveCypher
 
         # Start node pattern
         start_node_pattern = Cyrel.node(self.class.label_name).as(start_node_alias)
-                                  .where(Cyrel.id(start_node_alias).eq(internal_id))
+                                  .where(Cyrel.node_id(start_node_alias).eq(internal_id))
 
         # Intermediate node pattern (based on through_reflection)
         intermediate_node_pattern = Cyrel.node(intermediate_class.label_name).as(intermediate_node_alias)

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -39,6 +39,27 @@ module ActiveCypher
         'id(r) AS rid'
       end
 
+      # Additional helper methods for nodes
+      def self.node_id_where(alias_name, param_name = nil)
+        if param_name
+          "id(#{alias_name}) = $#{param_name}"
+        else
+          "id(#{alias_name})"
+        end
+      end
+
+      def self.node_id_equals_value(alias_name, value)
+        "id(#{alias_name}) = #{value}"
+      end
+
+      def self.return_node_id(alias_name, as_name = 'internal_id')
+        "id(#{alias_name}) AS #{as_name}"
+      end
+
+      def self.id_function
+        'id'
+      end
+
       # Return self as id_handler for compatibility with tests
       def id_handler
         self.class
@@ -66,7 +87,10 @@ module ActiveCypher
       # Memgraph defaults to **implicit auto‑commit** transactions
       # so we simply run the Cypher and return the rows.
       def execute_cypher(cypher, params = {}, ctx = 'Query')
-        rows = run(cypher.gsub(/\belementId\(/i, 'id('), params, context: ctx)
+        # Replace adapter-aware placeholder with Memgraph's id function
+        # Because Memgraph insists on being different and using id() instead of elementId()
+        cypher = cypher.gsub('__NODE_ID__', 'id')
+        rows = run(cypher, params, context: ctx)
         process_records(rows)
       end
 

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -61,8 +61,40 @@ module ActiveCypher
         'elementId(r) AS rid'
       end
 
+      # Additional helper methods for nodes
+      def self.node_id_where(alias_name, param_name = nil)
+        if param_name
+          "elementId(#{alias_name}) = $#{param_name}"
+        else
+          "elementId(#{alias_name})"
+        end
+      end
+
+      def self.node_id_equals_value(alias_name, value)
+        # Quote string values for Cypher because Neo4j is paranoid about injection attacks
+        # (As it should be, have you seen what people try to inject these days?)
+        quoted_value = value.is_a?(String) ? "'#{value}'" : value
+        "elementId(#{alias_name}) = #{quoted_value}"
+      end
+
+      def self.return_node_id(alias_name, as_name = 'internal_id')
+        "elementId(#{alias_name}) AS #{as_name}"
+      end
+
+      def self.id_function
+        'elementId'
+      end
+
+      # Return self as id_handler for compatibility
+      def id_handler
+        self.class
+      end
+
       def execute_cypher(cypher, params = {}, ctx = 'Query')
         connect
+        # Replace adapter-aware placeholder with Neo4j's elementId function
+        cypher = cypher.gsub('__NODE_ID__', 'elementId')
+        
         session = connection.session # thin wrapper around Bolt::Session
         result  = session.write_transaction do |tx|
           logger.debug { "[#{ctx}] #{cypher} #{params.inspect}" }

data/lib/active_cypher/connection_adapters/persistence_methods.rb

@@ -16,7 +16,8 @@ module ActiveCypher
                  end
         label_string = labels.map { |l| ":#{l}" }.join
 
-        cypher = "CREATE (n#{label_string} $props) RETURN id(n) AS internal_id"
+        adapter = model.connection.id_handler
+        cypher = "CREATE (n#{label_string} $props) RETURN #{adapter.return_node_id('n')}"
         data = model.connection.execute_cypher(cypher, { props: props }, 'Create')
 
         return false if data.blank? || !data.first.key?(:internal_id)
@@ -42,9 +43,14 @@ module ActiveCypher
 
         label_string = labels.map { |l| ":#{l}" }.join
         set_clauses = changes.keys.map { |property| "n.#{property} = $#{property}" }.join(', ')
-        params = changes.merge(node_id: model.internal_id)
 
-        cypher = "MATCH (n#{label_string}) WHERE id(n) = $node_id SET #{set_clauses} RETURN n"
+        adapter = model.connection.id_handler
+        # Convert internal_id to its preferred existential format
+        # Neo4j wants strings because it's complicated, Memgraph wants integers because it's not
+        node_id_param = adapter.id_function == 'elementId' ? model.internal_id.to_s : model.internal_id.to_i
+        params = changes.merge(node_id: node_id_param)
+
+        cypher = "MATCH (n#{label_string}) WHERE #{adapter.node_id_where('n', 'node_id')} SET #{set_clauses} RETURN n"
         model.connection.execute_cypher(cypher, params, 'Update')
 
         model.send(:changes_applied)
@@ -62,14 +68,19 @@ module ActiveCypher
                  end
         label_string = labels.map { |l| ":#{l}" }.join
 
+        adapter = model.connection.id_handler
+        # Convert internal_id to whatever format makes the database feel validated
+        # It's like therapy, but for graph databases
+        node_id_param = adapter.id_function == 'elementId' ? model.internal_id.to_s : model.internal_id.to_i
+
         cypher = <<~CYPHER
           MATCH (n#{label_string})
-          WHERE id(n) = $node_id
+          WHERE #{adapter.node_id_where('n', 'node_id')}
           DETACH DELETE n
           RETURN count(*) AS deleted
         CYPHER
 
-        result = model.connection.execute_cypher(cypher, { node_id: model.internal_id }, 'Destroy')
+        result = model.connection.execute_cypher(cypher, { node_id: node_id_param }, 'Destroy')
         result.present? && result.first[:deleted].to_i.positive?
       end
     end

data/lib/active_cypher/connection_url_resolver.rb

@@ -9,9 +9,11 @@ module ActiveCypher
   #
   # Supported URL prefixes:
   # - neo4j://
+  # - neo4j+s:// (alias for neo4j+ssc://)
   # - neo4j+ssl://
   # - neo4j+ssc://
   # - memgraph://
+  # - memgraph+s:// (alias for memgraph+ssc://)
   # - memgraph+ssl://
   # - memgraph+ssc://
   #
@@ -138,10 +140,14 @@ module ActiveCypher
 
       return nil unless SUPPORTED_ADAPTERS.include?(adapter)
 
-      modifiers = parts.select { |mod| %w[ssl ssc].include?(mod) }
+      # Map 's' to 'ssc' for Neo4j compatibility (self-signed certificates)
+      mapped_parts = parts.map { |mod| mod == 's' ? 'ssc' : mod }
+      modifiers = mapped_parts.select { |mod| %w[ssl ssc].include?(mod) }
 
       # If there are parts that are neither the adapter nor valid modifiers, the URL is invalid
-      remaining_parts = parts - modifiers
+      # Check against original parts but also accept 's' as valid
+      valid_modifiers = %w[ssl ssc s]
+      remaining_parts = parts.reject { |part| valid_modifiers.include?(part) }
       return nil if remaining_parts.any?
 
       [adapter, modifiers]

data/lib/active_cypher/fixtures/node_builder.rb

@@ -17,10 +17,11 @@ module ActiveCypher
         label_clause = labels.map { |label| "`#{label}`" }.join(':')
 
         # Build and fire the CREATE query.
-        # We use id(n) because elementId(n) lies to us with strings.
+        # Ask the adapter how it likes its IDs served - string or integer, sir?
+        adapter = conn.id_handler
         cypher = <<~CYPHER
           CREATE (n:#{label_clause} $props)
-          RETURN n, id(n) AS internal_id, properties(n) AS props
+          RETURN n, #{adapter.return_node_id('n')}, properties(n) AS props
         CYPHER
 
         result = conn.execute_cypher(cypher, props: props)

data/lib/active_cypher/generators/templates/cypher_databases.yml

@@ -1,11 +1,11 @@
 development:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>
 
 test:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>
 
 production:
   primary:
-    url: ENV["GRAPH_URL"]
+    url: <%= ENV["GRAPHDB_URL"] %>

data/lib/active_cypher/model/core.rb

@@ -12,7 +12,11 @@ module ActiveCypher
         include ActiveCypher::Associations
         include ActiveCypher::Scoping
 
-        attribute :internal_id, :integer
+        # internal_id: The ID that proves you exist in the graph's eyes
+        # String type because Neo4j needs UUIDs like "4:abc:xyz" to feel special
+        # while Memgraph just counts sheep like a normal database.
+        # ActiveModel will convert between them, hopefully without existential dread
+        attribute :internal_id, :string
 
         class_attribute :configurations, instance_accessor: false,
                                          default: ActiveSupport::HashWithIndifferentAccess.new

data/lib/active_cypher/model/querying.rb

@@ -33,16 +33,25 @@ module ActiveCypher
         # Find a node by internal DB ID. Returns the record or dies dramatically.
         # 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
 
           labels = respond_to?(:labels) ? self.labels : [label_name]
-          Cyrel.match(Cyrel.node(node_alias, labels: labels)).limit(1)
+          adapter = connection.id_handler
           label_string = labels.map { |l| ":#{l}" }.join
+
+          # Handle ID format based on adapter's preferred flavor of existential crisis
+          # Neo4j insists on string IDs like "4:uuid:wtf" because simple integers are for peasants
+          # Memgraph keeps it real with numeric IDs because it doesn't need to prove anything
+          formatted_id = if adapter.id_function == 'elementId'
+                           internal_db_id.to_s  # String for Neo4j
+                         else
+                           internal_db_id.to_i  # Numeric for Memgraph
+                         end
+
           cypher = <<~CYPHER
             MATCH (#{node_alias}#{label_string})
-            WHERE id(#{node_alias}) = #{internal_db_id}
-            RETURN #{node_alias}, id(#{node_alias}) AS internal_id
+            WHERE #{adapter.node_id_equals_value(node_alias, formatted_id)}
+            RETURN #{node_alias}, #{adapter.return_node_id(node_alias)}
             LIMIT 1
           CYPHER
 

data/lib/active_cypher/relation.rb

@@ -142,7 +142,7 @@ module ActiveCypher
 
       Cyrel
         .match(Cyrel.node(node_alias, labels: labels))
-        .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
+        .return_(node_alias, Cyrel.node_id(node_alias).as(:internal_id))
     end
 
     # Actually loads the records from the database, shattering the illusion of laziness.

data/lib/active_cypher/relationship.rb

@@ -50,7 +50,10 @@ module ActiveCypher
     # --------------------------------------------------------------
     # Attributes
     # --------------------------------------------------------------
-    attribute :internal_id, :integer
+    # internal_id: Your relationship's social security number, but less secure
+    # String because Neo4j relationships have commitment issues and need complex IDs
+    # Memgraph relationships just want a simple number, like the good old days with MS Access.
+    attribute :internal_id, :string
 
     # --------------------------------------------------------------
     # Connection fallback

data/lib/active_cypher/version.rb

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

data/lib/cyrel/functions.rb

@@ -18,14 +18,25 @@ module Cyrel
     # --- Common Cypher Functions ---
 
     # Use elementId() instead of deprecated id()
+    # @deprecated Use {#node_id} instead for adapter-aware ID handling
     def element_id(node_variable)
       Expression::FunctionCall.new(:elementId, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
+    # @deprecated Use {#node_id} instead for adapter-aware ID handling
     def id(node_variable)
       Expression::FunctionCall.new(:id, Clause::Return::RawIdentifier.new(node_variable.to_s))
     end
 
+    # Adapter-aware node ID function
+    # Generates a placeholder that will be replaced by the correct ID function
+    # at execution time based on the database adapter (Neo4j vs Memgraph)
+    # Because databases can't agree on how to name their ID functions,
+    # we'll just pretend they're all the same and fix it later
+    def node_id(node_variable)
+      Expression::FunctionCall.new(:__NODE_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.
     def count(expression, distinct: false)

data/lib/cyrel.rb

@@ -35,11 +35,15 @@ module Cyrel
 
   # Cyrel DSL helper: returns the element id of a node/relationship.
   # Example: Cyrel.id(:n)
-  def id(...) = Functions.element_id(...)
+  def id(...) = Functions.id(...)
 
   # Cyrel DSL helper: returns the element id of a node/relationship (alias).
   def element_id(...) = Functions.element_id(...)
 
+  # Cyrel DSL helper: adapter-aware node ID function
+  # Example: Cyrel.node_id(:n)
+  def node_id(...) = Functions.node_id(...)
+
   # Cyrel DSL helper: Cypher count() aggregation.
   # Example: Cyrel.count(:n)
   def count(...) = Functions.count(...)

metadata

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