rails_age 0.6.3 → 0.7.0

data/lib/apache_age/entities/query_builder.rb

@@ -1,6 +1,6 @@
 # query =
-#   Person.
-#     cypher('age_schema')
+#   Person
+#     .cypher('age_schema')
 #     .match("(a:Person), (b:Person)")
 #     .where("a.name = 'Node A'", "b.name = 'Node B'")
 #     .return("a.name", "b.name")
@@ -15,64 +15,48 @@ module ApacheAge
   module Entities
     class QueryBuilder
       attr_accessor :where_clauses, :order_clause, :limit_clause, :model_class, :match_clause,
-                    :graph_name, :return_clause, :return_names, :return_variables
-
-      def initialize(model_class, graph_name: nil)
+                    :graph_name, :return_clause, :return_names, :return_variables,
+                    :path_edge_name, :path_length, :path_properties
+
+      def initialize(
+        model_class, return_clause: nil, match_clause: nil, graph_name: nil
+        # model_class, path_edge: nil, path_length: nil, path_properties: nil, return_clause: nil, match_clause: nil, graph_name: nil
+      )
+        # @path_edge = path_length
+        # @path_length = path_length
+        # @path_properties = path_properties
         @model_class = model_class
         @where_clauses = []
-        @return_names = ['find']
-        @return_clause = 'find'
+        @return_clause = return_clause ? return_clause : 'find'
+        @return_names = [@return_clause]
         @return_variables = []
         @order_clause = nil
         @limit_clause = nil
-        @match_clause = model_class.match_clause
+        @match_clause = match_clause ? match_clause : model_class.match_clause
         @graph_name = graph_name || model_class.age_graph
       end
 
-      # def cypher(graph_name = 'age_schema')
-      #   return self if graph_name.blank?
-
-      #   @graph_name = graph_name
-      #   self
-      # end
-
       def match(match_string)
         @match_clause = match_string
         self
       end
 
-      # # TODO: need to handle string inputs too: instead of: \
-      # # "id(find) = #{id}" & "find.name = #{name}"
-      # # we can have: "id(find) = ?", id & "find.name = ?", name
-      # # ActiveRecord::Base.sanitize_sql([query_string, v])
       def where(*args)
         return self if args.blank?
 
         @where_clauses <<
-          # not able to sanitize the query string in this case
-          # ["first_name = 'Barney'"]
+          # not able to sanitize the query string in this case: `["first_name = 'Barney'"]`
           if args.length == 1 && args.first.is_a?(String)
-            string_query = args.first
-            if string_query.include?('id = ?')
-              "id(find) = ?"
-            elsif string_query.include?('id(') || string_query.include?('find.')
-              string_query
-            else
-              "find.#{string_query}"
-            end
+            raw_query_string = args.first
+            transform_cypher_sql(raw_query_string)
 
           # Handling & sanitizing parameterized string queries
           elsif args.length > 1 && args.first.is_a?(String)
             raw_query_string = args.first
-            query_string =
-              if raw_query_string.include?('id = ?')
-                "id(find) = ?"
-              elsif raw_query_string.include?('id(') || raw_query_string.include?('find.')
-                raw_query_string
-              else
-                "find.#{raw_query_string}"
-              end
+            # Replace `id = ?` with `id(find) = ?` and `first_name = ?` with `find.first_name = ?`
+            query_string = transform_cypher_sql(raw_query_string)
             values = args[1..-1]
+            # sanitize sql input values
             ActiveRecord::Base.sanitize_sql_array([query_string, *values])
 
           # Hashes are sanitized in the model class
@@ -93,71 +77,11 @@ module ApacheAge
         self
       end
 
-      # # where is sanitized in the model class with hash values
-      # def where(attributes)
-      #   return self if attributes.blank?
-
-      #   @where_clauses <<
-      #     if attributes.is_a?(String)
-      #       puts "HANDLE PURE STRING QUERIES"
-      #       if attributes.include?('id(') || attributes.include?('find.')
-      #         attributes
-      #       else
-      #         "find.#{attributes}"
-      #       end
-      #     else
-      #       puts "HANDLE HASHES"
-      #       pp attributes
-      #       edge_keys = [:start_id, :start_node, :end_id, :end_node]
-      #       if edge_keys.any? { |key| attributes.include?(key) }
-      #         puts "HANDLE EDGE CLAUSES"
-      #         model_class.send(:where_edge_clause, attributes)
-      #       else
-      #         puts "HANDLE NODE CLAUSES"
-      #         model_class.send(:where_node_clause, attributes)
-      #       end
-      #     end
-
-      #   self
-      # end
-
-      # # Pre-sanitize where statements
-      # # def where(*args)
-      # #   return self if args.blank?
-
-      # #   # Handling parameterized query strings with values
-      # #   if args.length == 1 && args.first.is_a?(Hash)
-      # #     # If a hash of attributes is provided, use the existing logic
-      # #     attributes = args.first
-      # #     edge_keys = [:start_id, :start_node, :end_id, :end_node]
-      # #     if edge_keys.any? { |key| attributes.include?(key) }
-      # #       @where_clauses << model_class.send(:where_edge_clause, attributes)
-      # #     else
-      # #       @where_clauses << model_class.send(:where_node_clause, attributes)
-      # #     end
-      # #   elsif args.length > 1 && args.first.is_a?(String)
-      # #     # If a query string with placeholders and values is provided
-      # #     query_string = args.first
-      # #     values = args[1..-1]
-      # #     sanitized_query = ActiveRecord::Base.send(:sanitize_sql_array, [query_string, *values])
-      # #     @where_clauses << sanitized_query
-      # #   elsif args.length == 1 && args.first.is_a?(String)
-      # #     # If a single string is provided, use it directly (assuming it is already sanitized or trusted)
-      # #     @where_clauses << args.first
-      # #   else
-      # #     raise ArgumentError, "Invalid arguments for `where` method"
-      # #   end
-
-      # #   self
-      # # end
-
       # New return method
       def return(*variables)
         return self if variables.blank?
 
         @return_variables = variables
-        # @return_names = variables.empty? ? ['find'] : variables
-        # @return_clause = variables.empty? ? 'find' : "find.#{variables.join(', find.')}"
         self
       end
 
@@ -199,31 +123,36 @@ module ApacheAge
 
       private
 
-      # TODO: ensure ordering keys are present in the model
+      # Handle ordering criteria for paths
       def parse_ordering(ordering)
         if ordering.is_a?(Hash)
-          ordering =
-            ordering
-              .map { |k, v| "find.#{k} #{ActiveRecord::Base.sanitize_sql_like(v.to_s)}" }
-              .join(', ')
+          ordering.map do |key, value|
+            if key == :length
+              # Special case for path length
+              "length(path) #{value.to_s.upcase}"
+            elsif key == :start_node || key == :end_node
+              # Node property ordering
+              if value.is_a?(Hash)
+                property = value.keys.first
+                direction = value.values.first.to_s.upcase
+                "#{key}.#{property} #{direction}"
+              else
+                "#{key} #{value.to_s.upcase}"
+              end
+            else
+              # Default case
+              "find.#{key} #{ActiveRecord::Base.sanitize_sql_like(value.to_s)}"
+            end
+          end.join(', ')
         elsif ordering.is_a?(Symbol)
-          ordering = "find.#{ordering}"
+          # Default for symbol
+          "find.#{ordering}"
         elsif ordering.is_a?(String)
+          # Pass strings through as-is
           ordering
         elsif ordering.is_a?(Array)
-          ordering = ordering.map do |order|
-            if order.is_a?(Hash)
-              order
-                .map { |k, v| "find.#{k} #{ActiveRecord::Base.sanitize_sql_like(v.to_s)}" }
-                .join(', ')
-            elsif order.is_a?(Symbol)
-              "find.#{order}"
-            elsif order.is_a?(String)
-              order
-            else
-              raise ArgumentError, 'Array elements must be a string, symbol, or hash'
-            end
-          end.join(', ')
+          # Process arrays recursively
+          ordering.map { |order| parse_ordering(order) }.join(', ')
         else
           raise ArgumentError, 'Ordering must be a string, symbol, hash, or array'
         end
@@ -243,22 +172,48 @@ module ApacheAge
           $$) AS (#{return_names.join(' agtype, ')} agtype);
         SQL
       end
-      # def build_query(_extra_clause = nil)
-      #   sanitized_where_sql = where_clauses.any? ? "WHERE #{where_clauses.map { |clause| ActiveRecord::Base.sanitize_sql_like(clause) }.join(' AND ')}" : ''
-      #   sanitized_order_by = order_clause.present? ? ActiveRecord::Base.sanitize_sql_like(order_clause) : ''
-      #   sanitized_limit_clause = limit_clause.present? ? ActiveRecord::Base.sanitize_sql_like(limit_clause) : ''
 
-      #   <<-SQL.squish
-      #     SELECT *
-      #     FROM cypher('#{graph_name}', $$
-      #         MATCH #{ActiveRecord::Base.sanitize_sql_like(match_clause)}
-      #         #{sanitized_where_sql}
-      #         RETURN #{ActiveRecord::Base.sanitize_sql_like(return_clause)}
-      #         #{sanitized_order_by}
-      #         #{sanitized_limit_clause}
-      #     $$) AS (#{return_names.map { |name| "#{ActiveRecord::Base.sanitize_sql_like(name)} agtype" }.join(', ')});
-      #   SQL
-      # end
+      def transform_cypher_sql(raw_sql_string)
+        # Define the logical operators and order multi-word operators first to avoid partial splits
+        operators = ['=', '>', '<', '<>', '>=', '<=', '=~', 'ENDS WITH', 'CONTAINS', 'STARTS WITH', 'IN', 'IS NULL', 'IS NOT NULL']
+        separators = ["AND NOT", "OR NOT", "AND", "OR", "NOT"]
+
+        # Combine the operators and separators into a regex pattern
+        pattern = /(#{(operators + separators).map { |s| Regexp.escape(s) }.join('|')})/
+
+        # Split the raw_sql_string string based on the pattern for operators and separators
+        parts = raw_sql_string.split(pattern)
+
+        # Process each part to identify and transform the attributes
+        transformed_parts = parts.map do |part|
+          # Skip transformation if part is one of the logical operators or separators
+          next part if operators.include?(part.strip) || separators.include?(part.strip)
+
+          # if string contains a dot or is an integer (plus or minus), skip transformation
+          if part.include?(".") || !!(part.strip =~ /\A-?\d+\z/)
+            part # Keep parts with prefixes as they are
+          elsif part =~ /\s*(\w+)\s*$/
+            attribute = $1
+            if attribute == 'end_id'
+              "id(end_node)"
+            elsif attribute == 'start_id'
+              "id(start_node)"
+            elsif attribute == 'id'
+              "id(find)"
+            # attributes must start with a letter
+            elsif attribute =~ /^[a-z]\w*$/
+              "find.#{attribute}"
+            else
+              attribute
+            end
+          else
+            part
+          end
+        end
+
+        # Reassemble the string with the transformed parts
+        transformed_parts.join(" ").gsub(/\s+/, ' ').strip
+      end
     end
   end
 end

data/lib/apache_age/node.rb

@@ -12,24 +12,67 @@ module ApacheAge
       info.blank? ? "#{label} (#{id})" : "#{info} (#{label})"
     end
 
-    def self.all
-      all_nodes_sql = <<~SQL
-      SELECT *
-      FROM cypher('age_schema', $$
-          MATCH (node)
-          RETURN node
-      $$) as (node agtype);
-      SQL
-      age_results = ActiveRecord::Base.connection.execute(all_nodes_sql)
-      return [] if age_results.values.count.zero?
-
-      age_results.values.map do |result|
-        json_string = result.first.split('::').first
-        hash = JSON.parse(json_string)
-        attribs = hash.slice('id', 'label').symbolize_keys
-        attribs[:properties] = hash['properties'].symbolize_keys
-
-        new(**attribs)
+    class << self
+      def age_type = 'vertex'
+
+      def ensure_query_builder!
+        @query_builder ||= ApacheAge::Entities::QueryBuilder.new(@node_class || self)
+      end
+
+      def cypher(node_class: nil, graph_name: nil)
+        @node_class = node_class || self
+        @query_builder = ApacheAge::Entities::QueryBuilder.new(@node_class, graph_name:)
+        self
+      end
+
+      def match(match_string)
+        ensure_query_builder!
+        @query_builder.match(match_string)
+        self
+      end
+
+      def where(*args)
+        ensure_query_builder!
+        @query_builder.where(*args)
+        self
+      end
+
+      def order(ordering)
+        ensure_query_builder!
+        @query_builder.order(ordering)
+        self
+      end
+
+      def limit(limit_value)
+        ensure_query_builder!
+        @query_builder.limit(limit_value)
+        self
+      end
+
+      def return(*variables)
+        ensure_query_builder!
+        @query_builder.return(*variables)
+        self
+      end
+
+      def execute
+        ensure_query_builder!
+        @query_builder.execute
+      end
+
+      def first
+        ensure_query_builder!
+        @query_builder.first
+      end
+
+      def all
+        ensure_query_builder!
+        @query_builder.all
+      end
+
+      def to_sql
+        ensure_query_builder!
+        @query_builder.to_sql
       end
     end
   end

data/lib/apache_age/path.rb

@@ -1,4 +1,262 @@
+# Query Paths
+# DSL - When all edges are of the same type
+# - Path.cypher(path_edge: HasChild, path_length: "1..5")
+#     .where(start_node: {first_name: 'Zeke'})
+#     .where('end_node.last_name CONTAINS ?', 'Flintstone')
+#     .limit(3)
+# with full control of the matching paths
+# JUST FATHER LINEAGE (where can't handle edge path properties - not one element and get error:
+# `ERROR:  array index must resolve to an integer value`
+# so instead match as an edge property instead as shown below
+# - Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'})
+#     .where(start_node: {first_name: 'Zeke'})
+#     .where('end_node.last_name =~ ?', 'Flintstone')
+#     .limit(3)
+# - Path
+#     .match('(start_node)-[HasChild*1..5 {guardian_role: 'father'}]->(end_node)')
+#     .where(start_node: {first_name: 'Zeke'})
+#     .where('end_node.last_name =~ ?', 'Flintstone')
+#     .limit(3)
+#
+# # DSL RESULTS:
+# [
+#   [
+#     Person.find(844424930131969), # Zeke Flintstone
+#     Edge.find(1407374883553281),  # HasChild(mother)
+#     Person.find(844424930131971)  # Rockbottom Flintstone
+#   ],
+#   [
+#     Person.find(844424930131969), # Zeke Flintstone
+#     Edge.find(1407374883553281),  # HasChild(mother)
+#     Person.find(844424930131971), # Rockbottom Flintstone
+#     Edge.find(1407374883553284),  # HasChild(falther)
+#     Person.find(844424930131975)  # Giggles Flintstone
+#   ],
+#   [
+#     Person.find(844424930131969), # Zeke Flintstone
+#     Edge.find(1407374883553281),  # HasChild(mother)
+#     Person.find(844424930131971), # Rockbottom Flintstone
+#     Edge.find(1407374883553283),  # HasChild(father)
+#     Person.find(844424930131974)  # Ed Flintstone
+#   ]
+# ]
+# SQL:
+# - SELECT *
+#   FROM cypher('age_schema', $$
+#   MATCH path = (start_node)-[HasChild*1..5]->(end_node)
+#   WHERE start_node.first_name = 'Zeke' AND end_node.last_name CONTAINS 'Flintstone'
+#   RETURN path
+#   LIMIT 3
+#   $$) AS (path agtype);
+#
+# SQL:
+# SELECT *
+#   FROM cypher('age_schema', $$
+#   MATCH path = (start_node)-[HasChild*1..5 {guardian_role: 'father'}]->(end_node)
+#   WHERE start_node.first_name = "Jed" AND end_node.last_name =~ 'Flintstone'
+#   RETURN path
+#   LIMIT 3
+#   $$) AS (path agtype);
+#
+# SQL RESULTS:
+# [
+#   {"id": 844424930131969, "label": "Person", "properties": {"gender": "female", "last_name": "Flintstone", "first_name": "Zeke"}}::vertex,
+#   {"id": 1407374883553281, "label": "HasChild", "end_id": 844424930131971, "start_id": 844424930131969, "properties": {"guardian_role": "mother"}}::edge,
+#   {"id": 844424930131971, "label": "Person", "properties": {"gender": "male", "last_name": "Flintstone", "first_name": "Rockbottom"}}::vertex
+# ]::path
+# [
+#   {"id": 844424930131969, "label": "Person", "properties": {"gender": "female", "last_name": "Flintstone", "first_name": "Zeke"}}::vertex,
+#   {"id": 1407374883553281, "label": "HasChild", "end_id": 844424930131971, "start_id": 844424930131969, "properties": {"guardian_role": "mother"}}::edge,
+#   {"id": 844424930131971, "label": "Person", "properties": {"gender": "male", "last_name": "Flintstone", "first_name": "Rockbottom"}}::vertex,
+#   {"id": 1407374883553284, "label": "HasChild", "end_id": 844424930131975, "start_id": 844424930131971, "properties": {"guardian_role": "father"}}::edge,
+#   {"id": 844424930131975, "label": "Person", "properties": {"gender": "male", "last_name": "Flintstone", "first_name": "Giggles"}}::vertex
+# ]::path
+# [
+#   {"id": 844424930131969, "label": "Person", "properties": {"gender": "female", "last_name": "Flintstone", "first_name": "Zeke"}}::vertex,
+#   {"id": 1407374883553281, "label": "HasChild", "end_id": 844424930131971, "start_id": 844424930131969, "properties": {"guardian_role": "mother"}}::edge,
+#   {"id": 844424930131971, "label": "Person", "properties": {"gender": "male", "last_name": "Flintstone", "first_name": "Rockbottom"}}::vertex, {"id": 1407374883553283, "label": "HasChild", "end_id": 844424930131974, "start_id": 844424930131971, "properties": {"guardian_role": "father"}}::edge,
+#   {"id": 844424930131974, "label": "Person", "properties": {"gender": "male", "last_name": "Flintstone", "first_name": "Ed"}}::vertex
+# ]::path
+# (3 rows)
+
 module ApacheAge
   class Path
+    include ApacheAge::Entities::Path
+
+    attr_reader :query_builder, :path_edge, :path_length, :path_properties, :start_node_filter, :end_node_filter
+
+    class << self
+      def age_type = 'path'
+
+      # Convert a path result or collection of path results to hashes
+      # This handles both a single path (array of nodes/edges) and multiple paths
+      def path_to_h(path_result)
+        if path_result.first.is_a?(Array)
+          # It's a collection of paths
+          path_result.map { |path| path.map(&:to_h) }
+        else
+          # It's a single path
+          path_result.map(&:to_h)
+        end
+      end
+
+      # Convert a path result to rich hashes with additional context information
+      # This handles both a single path (array of nodes/edges) and multiple paths
+      def path_to_rich_h(path_result)
+        if path_result.first.is_a?(Array)
+          # It's a collection of paths
+          path_result.map { |path| path.map(&:to_rich_h) }
+        else
+          # It's a single path
+          path_result.map(&:to_rich_h)
+        end
+      end
+
+      def ensure_query_builder!
+        @query_builder ||= ApacheAge::Entities::QueryBuilder.new(self)
+      end
+
+      def cypher(path_edge: nil, path_length: nil, path_properties: {}, start_node_filter: nil, end_node_filter: nil, graph_name: nil)
+        unless path_edge.nil? || path_edge.ancestors.include?(ApacheAge::Entities::Edge)
+          raise ArgumentError, 'Path edge must be a valid edge class'
+        end
+
+        @path_edge = path_edge ? path_edge.name.gsub('::', '__') : nil
+        @path_length = path_length ? "*#{path_length}" : "*"
+        @path_properties = path_properties.blank? ? nil : " {#{path_properties.map { |k, v| "#{k}: '#{v}'" }.join(', ')}}"
+
+        # Format node filters for the match clause if provided
+        start_filter = format_node_filter(start_node_filter)
+        end_filter = format_node_filter(end_node_filter)
+
+        @has_edge_ordering = false
+        @match_clause = "path = (start_node#{start_filter})-[#{@path_edge}#{@path_length}#{@path_properties}]->(end_node#{end_filter})"
+        @query_builder =
+          ApacheAge::Entities::QueryBuilder.new(
+            self,
+            graph_name:,
+            return_clause: 'path',
+            match_clause: @match_clause
+          )
+        self
+      end
+
+      def match_clause
+        # Use the edge variable if we're ordering by edge properties
+        if @has_edge_ordering
+          "path = (start_node)-[edge:#{@path_edge}#{@path_length}#{@path_properties}]->(end_node)"
+        else
+          "path = (start_node)-[#{@path_edge}#{@path_length}#{@path_properties}]->(end_node)"
+        end
+      end
+
+      def match(match_string)
+        ensure_query_builder!
+        @query_builder.match(match_string)
+        self
+      end
+
+      # Delegate additional methods like `where`, `limit`, etc., to `QueryBuilder`
+      def where(*args)
+        ensure_query_builder!
+        @query_builder.where(*args)
+        self
+      end
+
+      # order is important to put last (but before limit)
+      # Path.cypher(...).where(...).order("start_node.first_name ASC").limit(5)
+      def order(ordering)
+        ensure_query_builder!
+
+        # Check if we're ordering by edge properties
+        if ordering.is_a?(Hash) && ordering.key?(:edge)
+          # Update match clause to include edge variable
+          @match_clause = "path = (start_node)-[edge:#{@path_edge}#{@path_length}#{@path_properties}]->(end_node)"
+          @query_builder.match_clause = @match_clause
+        end
+
+        @query_builder.order(ordering)
+        self
+      end
+
+      def limit(limit_value)
+        ensure_query_builder!
+        @query_builder.limit(limit_value)
+        self
+      end
+
+      def return(*variables)
+        ensure_query_builder!
+        @query_builder.return(*variables)
+        self
+      end
+
+      # Executes the query and returns results
+      def execute
+        ensure_query_builder!
+        @query_builder.execute
+      end
+
+      def first
+        ensure_query_builder!
+        @query_builder.first
+      end
+
+      def all
+        ensure_query_builder!
+        @query_builder.all
+      end
+
+      # Build the final SQL query
+      def to_sql
+        ensure_query_builder!
+        @query_builder.to_sql
+      end
+
+      private
+
+      # Format node filter hash into Cypher node property syntax {key: 'value', ...}
+      # Returns a properly formatted string for insertion into a MATCH clause
+      def format_node_filter(filter)
+        return '' if filter.nil? || !filter.is_a?(Hash) || filter.empty?
+
+        properties = filter.map do |key, value|
+          formatted_value = value.is_a?(String) ? "'#{value}'" : value
+          "#{key}: #{formatted_value}"
+        end.join(', ')
+
+        " {#{properties}}"
+      end
+
+      # PathResult is a custom Array subclass that adds to_rich_h convenience method
+      class PathResult < Array
+        def to_rich_h
+          map(&:to_rich_h)
+        end
+      end
+
+      # private
+
+      def execute_where(cypher_sql)
+        age_results = ActiveRecord::Base.connection.execute(cypher_sql)
+        return [] if age_results.values.count.zero?
+
+        age_results.values.map do |row|
+          path_data = row.first.split('::path').first
+          # [1..-2] - removes leading and trailing brackets
+          elements = path_data[1..-2].split(/(?<=\}::vertex,)|(?<=\}::edge,)/)
+          # elements.map do |element|
+          path_elements = elements.map do |element|
+            path_hash = JSON.parse(element.sub("::vertex,", "").sub("::vertex", "").sub("::edge,", "").sub("::edge", "").strip)
+            path_klass = path_hash['label'].gsub('__', '::').constantize
+            path_attribs = path_hash.except('label', 'properties').merge(path_hash['properties']).symbolize_keys
+            path_klass.new(**path_attribs)
+          end
+          
+          # Wrap the result in our custom PathResult class
+          PathResult.new(path_elements)
+        end
+      end
+    end
   end
 end

data/lib/rails_age/version.rb

@@ -1,3 +1,3 @@
 module RailsAge
-  VERSION = '0.6.3'
+  VERSION = '0.7.0'
 end

data/lib/rails_age.rb

@@ -13,10 +13,10 @@ module ApacheAge
   require 'apache_age/entities/entity'
   require 'apache_age/entities/node'
   require 'apache_age/entities/edge'
-  # require 'apache_age/entities/path'
+  require 'apache_age/entities/path'
   require 'apache_age/node'
   require 'apache_age/edge'
-  # require 'apache_age/path'
+  require 'apache_age/path'
   require 'apache_age/validators/expected_node_type'
   require 'apache_age/validators/unique_node'
   require 'apache_age/validators/unique_edge'