activecypher 0.7.3 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcfe9f62e0fdcf58b7d4f46fef0b7869bac550fc730f2e93a2d057938cad8a4e
-  data.tar.gz: a835e25b6ff10e6e9e4884c2855091e617086e1635931988cc018d9eac06afd8
+  metadata.gz: e620571f10d214866edea1ed9542b49fc0527c97e3a41d26fad6992d5c9dc900
+  data.tar.gz: 1c79530d7aebae332ee2acaf12c25657866be8edbf3ccaaf50241308098edeba
 SHA512:
-  metadata.gz: 4297ab6127aa159da2800dd2024102e8768cfac6604ce390fa35d71d95b393e3226a6d544e535ccc09c14d1632a23009c48df5067a62b6f158fc344b7e1ff21c
-  data.tar.gz: b929133db5f0be22b7fbd2e3923e54b0a6b041e748d28dc32bbd6f454ab0547ea48637a945262b480339ccee8e78551b23b64cd6aea8a276c5f3d5e766adbc8d
+  metadata.gz: 355a7867dbce5af603a5473b061e874afbd3af77ff8f2ad1d29419e308208ff3391dfb3dedd6542dd9467d0abed5bf4f63e0940bf8d4d958352c77545558747a
+  data.tar.gz: 6bd1446f02f78ca88d0da56da74001ffa28c1d0691619df5ba28dff319ab0e78002a41c626cf15da58749105fcd42b2bb2c4fe6b9769fc7e6cb09e57a55484f3

data/lib/active_cypher/connection_adapters/abstract_bolt_adapter.rb

@@ -59,6 +59,7 @@ module ActiveCypher
 
       # Connection health check. If this returns false, you're probably in trouble.
       def active? = @connection&.connected?
+      alias connected? active?
 
       # Clean disconnection. Resets the internal state.
       def disconnect

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -136,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

@@ -94,7 +94,7 @@ module ActiveCypher
         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,10 +14,18 @@ module ActiveCypher
                  else
                    [model.class.label_name.to_s]
                  end
-        label_string = labels.map { |l| ":#{l}" }.join
 
         adapter = model.connection.id_handler
-        cypher = "CREATE (n#{label_string} $props) RETURN #{adapter.return_node_id('n')}"
+
+        # 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
+
         data = model.connection.execute_cypher(cypher, { props: props }, 'Create')
 
         return false if data.blank? || !data.first.key?(:internal_id)
@@ -41,16 +49,23 @@ module ActiveCypher
                    [model.class.label_name.to_s]
                  end
 
-        label_string = labels.map { |l| ":#{l}" }.join
-        set_clauses = changes.keys.map { |property| "n.#{property} = $#{property}" }.join(', ')
-
         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"
+        # 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(', ')
+
+        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)
@@ -66,19 +81,21 @@ module ActiveCypher
                  else
                    [model.class.label_name]
                  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 #{adapter.node_id_where('n', 'node_id')}
-          DETACH DELETE n
-          RETURN count(*) AS deleted
-        CYPHER
+        # OPTIMIZED: Use string template for known-safe DELETE pattern
+        # Labels come from model class (safe)
+        label_string = labels.map { |l| ":#{l}" }.join
+
+        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: node_id_param }, 'Destroy')
         result.present? && result.first[:deleted].to_i.positive?

data/lib/active_cypher/relation.rb

@@ -141,7 +141,7 @@ module ActiveCypher
                end
 
       Cyrel
-        .match(Cyrel.node(node_alias, labels: labels))
+        .match(Cyrel.node(node_alias, *labels))
         .return_(node_alias, Cyrel.node_id(node_alias).as(:internal_id))
     end
 

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.7.3'
+  VERSION = '0.8.1'
 
   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