activecypher 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 738573111aeb926ef359c2bd2643e07d25f83b76d63f7cebf0d31e762c06fabf
-  data.tar.gz: 8ede3884325f7e86e4ca06dea636e0193d8742fc19b0ed2e92724f3270f31f7f
+  metadata.gz: b73e136ad3f9de8db24567d350140d9679d04d35139d861af4b5821037cc6bdd
+  data.tar.gz: 6e795339764ca8e603cc80db6909a983fdcb3877fa2dfcaec3fcf20149d153b1
 SHA512:
-  metadata.gz: afc1446c1c2e7195ed3ad241e84bcdaffaf9c634084068088f15137f897ea4955d80448af5b80b225af204a23baa217486b4327160b50b7bd41899d7c6b95df1
-  data.tar.gz: f5cf3960f8127672e803d9dd9d2246e8245499e2f7208013e2bd97a4e5971fbcd5044aa107bcf1208a21cfc40337d0c89cbc3354706dce06f0bb1df8b62d84a3
+  metadata.gz: 803b1091f2227ebe564fad414025e21790710e7e4c60d9b05113c33a1a7d020495c7ce45a876ac9650261f54b60fbca5da7c2d1c0fcdfb8b169918798080feda
+  data.tar.gz: e02f17df064f5ef440503bfedfa050572c5326144403e79e32188528f615afbb11c62fe75e6417b26094c4168ede2414b821681c293c5731de5da6ad2ba8c1ea

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
 
@@ -112,7 +136,16 @@ module ActiveCypher
         labels = run('MATCH (n) RETURN DISTINCT labels(n) AS lbl').flat_map { |r| r['lbl'] }
 
         nodes = labels.map do |lbl|
-          props = run("MATCH (n:`#{lbl}`) WITH n LIMIT 100 UNWIND keys(n) AS k RETURN DISTINCT k").map { |r| r['k'] }
+          # Use Cyrel for secure query building with user-provided label
+          query = Cyrel::Query.new
+                              .match(Cyrel.node(:n, lbl))
+                              .with(:n)
+                              .limit(100)
+                              .unwind(Cyrel.function(:keys, :n), :k)
+                              .return_('DISTINCT k')
+
+          cypher, params = query.to_cypher
+          props = run(cypher, params).map { |r| r['k'] }
           Schema::NodeTypeDef.new(lbl, props, nil)
         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

@@ -14,9 +14,18 @@ module ActiveCypher
                  else
                    [model.class.label_name.to_s]
                  end
+
+        adapter = model.connection.id_handler
+
+        # OPTIMIZED: Use string template instead of Cyrel for known-safe CREATE pattern
+        # Labels come from model class (safe), props are parameterized (safe)
         label_string = labels.map { |l| ":#{l}" }.join
+        cypher = if adapter.id_function == 'elementId'
+                   "CREATE (n#{label_string} $props) RETURN elementId(n) AS internal_id"
+                 else
+                   "CREATE (n#{label_string} $props) RETURN id(n) AS internal_id"
+                 end
 
-        cypher = "CREATE (n#{label_string} $props) RETURN id(n) AS internal_id"
         data = model.connection.execute_cypher(cypher, { props: props }, 'Create')
 
         return false if data.blank? || !data.first.key?(:internal_id)
@@ -40,11 +49,23 @@ module ActiveCypher
                    [model.class.label_name.to_s]
                  end
 
+        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
+
+        # OPTIMIZED: Use string template for known-safe UPDATE pattern
+        # Labels come from model class (safe), property names from model attributes (safe)
         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"
+        cypher = if adapter.id_function == 'elementId'
+                   "MATCH (n#{label_string}) WHERE elementId(n) = $node_id SET #{set_clauses} RETURN n"
+                 else
+                   "MATCH (n#{label_string}) WHERE id(n) = $node_id SET #{set_clauses} RETURN n"
+                 end
+
+        params = changes.merge(node_id: node_id_param)
         model.connection.execute_cypher(cypher, params, 'Update')
 
         model.send(:changes_applied)
@@ -60,16 +81,23 @@ module ActiveCypher
                  else
                    [model.class.label_name]
                  end
+
+        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
+
+        # OPTIMIZED: Use string template for known-safe DELETE pattern
+        # Labels come from model class (safe)
         label_string = labels.map { |l| ":#{l}" }.join
 
-        cypher = <<~CYPHER
-          MATCH (n#{label_string})
-          WHERE id(n) = $node_id
-          DETACH DELETE n
-          RETURN count(*) AS deleted
-        CYPHER
+        cypher = if adapter.id_function == 'elementId'
+                   "MATCH (n#{label_string}) WHERE elementId(n) = $node_id DETACH DELETE n RETURN count(*) AS deleted"
+                 else
+                   "MATCH (n#{label_string}) WHERE id(n) = $node_id DETACH DELETE n RETURN count(*) AS deleted"
+                 end
 
-        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

@@ -141,8 +141,8 @@ module ActiveCypher
                end
 
       Cyrel
-        .match(Cyrel.node(node_alias, labels: labels))
-        .return_(node_alias, Cyrel.element_id(node_alias).as(:internal_id))
+        .match(Cyrel.node(node_alias, *labels))
+        .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.8.0'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/activecypher.rb

@@ -104,8 +104,10 @@ loader.ignore("#{__dir__}/activecypher.rb")
 loader.ignore("#{__dir__}/cyrel.rb")
 loader.inflector.inflect(
   'activecypher' => 'ActiveCypher',
-  'dsl_context' => 'DSLContext'
+  'dsl_context' => 'DSLContext',
+  'ast' => 'AST'
 )
+
 loader.push_dir("#{__dir__}/cyrel", namespace: Cyrel)
 loader.setup
 

data/lib/cyrel/ast/call_node.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Cyrel
+  module AST
+    # AST node for CALL clauses (procedures)
+    # For when you need to call upon the powers that be
+    class CallNode < Node
+      attr_reader :procedure_name, :arguments, :yield_items
+
+      def initialize(procedure_name, arguments: [], yield_items: nil)
+        @procedure_name = procedure_name
+        @arguments = arguments
+        @yield_items = yield_items
+      end
+
+      protected
+
+      def state
+        [@procedure_name, @arguments, @yield_items]
+      end
+    end
+
+    # AST node for CALL subqueries
+    # For when you need a query within a query (queryception)
+    class CallSubqueryNode < Node
+      attr_reader :subquery
+
+      def initialize(subquery)
+        @subquery = subquery
+      end
+
+      protected
+
+      def state
+        [@subquery]
+      end
+    end
+  end
+end

data/lib/cyrel/ast/clause_adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cyrel
+  module AST
+    # Adapter that allows AST nodes to work with the existing clause-based system
+    # Now with simple caching for performance
+    class ClauseAdapter < Clause::Base
+      attr_reader :ast_node
+
+      def initialize(ast_node)
+        @ast_node = ast_node
+        @ast_node_hash = ast_node.hash
+        super()
+      end
+
+      def render(query)
+        # Use a simple cache key based on AST node structure
+        cache_key = [@ast_node_hash, @ast_node.class.name].join(':')
+
+        SimpleCache.instance.fetch(cache_key) do
+          # Create a compiler that delegates parameter registration to the query
+          compiler = QueryIntegratedCompiler.new(query)
+          compiler.compile(ast_node)
+          compiler.output.string
+        end
+      end
+
+      # Ruby 3.0+ pattern matching support
+      def deconstruct
+        [ast_node]
+      end
+
+      def deconstruct_keys(_keys)
+        { ast_node: ast_node, type: ast_node.class }
+      end
+    end
+  end
+end

data/lib/cyrel/ast/clause_node.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cyrel
+  module AST
+    # Base class for clause nodes (MATCH, WHERE, RETURN, etc.)
+    # The building blocks of your query, like LEGO but with more existential dread
+    class ClauseNode < Node
+    end
+  end
+end