rails_age 0.6.4 → 0.7.0

data/lib/apache_age/edge.rb

@@ -1,5 +1,68 @@
 module ApacheAge
   class Edge
     include ApacheAge::Entities::Edge
+
+    class << self
+      def age_type = 'edge'
+
+      def ensure_query_builder!
+        @query_builder ||= ApacheAge::Entities::QueryBuilder.new(self)
+      end
+
+      def cypher(edge_class, graph_name: nil)
+        @query_builder = ApacheAge::Entities::QueryBuilder.new(edge_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
 end

data/lib/apache_age/entities/class_methods.rb

@@ -18,42 +18,28 @@ module ApacheAge
       def find(id) = where(id: id).first
 
       def find_by(attributes)
-        return nil if attributes.reject { |k, v| v.blank? }.empty?
+        return nil if attributes.reject { |_k, v| v.blank? }.empty?
 
         where(attributes).limit(1).first
       end
 
       # Private stuff
 
-      # used? or dead code?
-      def where_edge(attributes)
-        where_attribs =
-          attributes
-            .compact
-            .except(:end_id, :start_id, :end_node, :start_node)
-            .map { |k, v| ActiveRecord::Base.sanitize_sql(["find.#{k} = ?", v]) }
-            .join(' AND ')
-        where_attribs = where_attribs.empty? ? nil : where_attribs
-
-        end_id = attributes[:end_id] || attributes[:end_node]&.id
-        start_id = attributes[:start_id] || attributes[:start_node]&.id
-        where_end_id = end_id ? ActiveRecord::Base.sanitize_sql(["id(end_node) = ?", end_id]) : nil
-        where_start_id = start_id ? ActiveRecord::Base.sanitize_sql(["id(start_node) = ?", start_id]) : nil
-
-        where_clause = [where_attribs, where_start_id, where_end_id].compact.join(' AND ')
-        return nil if where_clause.empty?
-
-        cypher_sql = edge_sql(where_clause)
-
-        execute_where(cypher_sql)
-      end
-
       def age_graph = 'age_schema'
       def age_label = name.gsub('::', '__')
       def age_type = name.constantize.new.age_type
 
       def match_clause
-        age_type == 'vertex' ? "(find:#{age_label})" : "(start_node)-[find:#{age_label}]->(end_node)"
+        case age_type
+        when 'vertex'
+          # this allows us to Query for all nodes or a specific class of nodes
+          self == ApacheAge::Node ? '(find)' : "(find:#{age_label})"
+        when 'edge'
+          # this allows us to Query for all edges or a specific class of edges
+          self == ApacheAge::Edge ? '(start_node)-[find]->(end_node)' : "(start_node)-[find:#{age_label}]->(end_node)"
+        when 'path'
+          "(start_node)-[edge:#{@path_edge.gsub('::', '__')}*#{@path_length} #{path_properties}]->(end_node)"
+        end
       end
 
       def execute_sql(cypher_sql) = ActiveRecord::Base.connection.execute(cypher_sql)
@@ -67,47 +53,31 @@ module ApacheAge
         age_results.values.map do |value|
           json_data = value.first.split('::').first
           hash = JSON.parse(json_data)
+          # once we have the record we use the label to find the class
+          klass = hash['label'].gsub('__', '::').constantize
           attribs = hash.except('label', 'properties').merge(hash['properties']).symbolize_keys
 
-          new(**attribs)
+          # knowing the class and attributes we can create a new instance (wether all results are of the same class or not)
+          # This allows us to return results for, ApacheAge::Node, ApacheAge::Edge, or any specific type of node or edge
+          klass.new(**attribs)
         end
       end
 
-      def all_sql
-        <<-SQL
-        SELECT *
-        FROM cypher('#{age_graph}', $$
-            MATCH #{match_clause}
-            RETURN find
-        $$) as (#{age_label} agtype);
-        SQL
-      end
-
-      def node_sql(where_clause)
-        <<-SQL
-          SELECT *
-          FROM cypher('#{age_graph}', $$
-              MATCH #{match_clause}
-              WHERE #{where_clause}
-              RETURN find
-          $$) as (#{age_label} agtype);
-        SQL
-      end
-
-      def edge_sql(where_clause)
-        <<-SQL
-          SELECT *
-          FROM cypher('#{age_graph}', $$
-              MATCH #{match_clause}
-              WHERE #{where_clause}
-              RETURN find
-          $$) as (#{age_label} agtype);
-        SQL
-      end
-
       private
 
       def where_node_clause(attributes)
+        # # Make sure we're not treating a simple node attribute query as a start_node hash
+        # # This fixes the issue with where(first_name: 'Barney') getting treated as a path query
+        # if attributes.key?(:start_node) && attributes[:start_node].is_a?(Hash)
+        #   # Handle the special case where start_node contains properties
+        #   start_node_attrs = attributes[:start_node].map do |k, v|
+        #     query_string = k == :id ? "id(find) = ?" : "find.#{k} = ?"
+        #     ActiveRecord::Base.sanitize_sql([query_string, v])
+        #   end.join(' AND ')
+        #   return start_node_attrs
+        # end
+
+        # Normal case - regular node attributes
         build_core_where_clause(attributes)
       end
 
@@ -144,16 +114,55 @@ module ApacheAge
           .flatten.compact.join(' AND ')
       end
 
+      # def where_path_clause(attributes)
+      # end
 
       def build_core_where_clause(attributes)
         attributes
           .compact
           .map do |k, v|
-            query_string = k == :id ? "id(find) = #{v}" : "find.#{k} = '#{v}'"
-            ActiveRecord::Base.sanitize_sql([query_string, v])
+            if k == :id
+              "id(find) = #{v}"
+            else
+              # Format the value appropriately based on its type
+              formatted_value = format_for_cypher(k, v)
+              "find.#{k} = #{formatted_value}"
+            end
           end
           .join(' AND ')
       end
+
+      # Formats a value appropriately for use in a Cypher query based on its type
+      def format_for_cypher(attribute_name, value)
+        return 'null' if value.nil?
+
+        # Find the attribute type if possible
+        attribute_type = attribute_types[attribute_name.to_s] if respond_to?(:attribute_types)
+
+        # Format based on Ruby class if no attribute type info is available
+        case
+        when attribute_type.is_a?(ActiveModel::Type::Boolean) || value == true || value == false
+          value.to_s # No quotes for booleans
+        when attribute_type.is_a?(ActiveModel::Type::Integer) || value.is_a?(Integer)
+          value.to_s # No quotes for integers
+        when attribute_type.is_a?(ActiveModel::Type::Float) || attribute_type.is_a?(ActiveModel::Type::Decimal) || value.is_a?(Float) || value.is_a?(BigDecimal)
+          value.to_s # No quotes for floats/decimals
+        when (attribute_type.is_a?(ActiveModel::Type::Date) && (attribute_type.class != ActiveModel::Type::DateTime)) || value.class == Date
+          "'#{value.strftime('%Y-%m-%d')}'" # Format dates as 'YYYY-MM-DD'
+        when (attribute_type.is_a?(ActiveModel::Type::DateTime) && (attribute_type.class != ActiveModel::Type::Date)) || value.is_a?(Time) || value.is_a?(DateTime)
+          utc_time = value.respond_to?(:utc) ? value.utc : value
+          "'#{utc_time.strftime('%Y-%m-%d %H:%M:%S.%6N')}'" # Format datetime (not natively supported in AGE, so formatting is a workaround)
+        # when value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(Json)
+        #   # For JSON data, serialize to JSON string and ensure it's properly quoted
+        #   "'#{value.to_json.gsub("\'", "\\'")}'"
+        # when value.is_a?(ActiveModel::Type::Array) ||value.is_a?(ActiveModel::Type::Hash) || value.is_a?(ActiveModel::Type::Json)
+        #   # For JSON data, serialize to JSON string and ensure it's properly quoted
+        #   "'#{value.to_json.gsub("\'", "\\'")}'"
+        else
+          # Default to string treatment with proper escaping
+          "'#{value.to_s.gsub("\'", "\\'")}'"
+        end
+      end
     end
   end
 end

data/lib/apache_age/entities/common_methods.rb

@@ -24,6 +24,32 @@ module ApacheAge
         base_h.symbolize_keys
       end
 
+      # Enhanced hash representation with display information
+      # This provides more context without modifying the core attributes
+      def to_rich_h
+        # Start with the basic id and add the info string
+        result = { _meta: "#{age_label} (#{age_type})", id: id }
+
+        # Group all other attributes under properties
+        properties_hash = {}
+        attributes.to_hash.except('id').each do |key, value|
+          # Skip node objects (we'll handle them specially below)
+          next if %w[start_node end_node].include?(key)
+
+          properties_hash[key.to_sym] = value
+        end
+
+        result[:properties] = properties_hash
+
+        # Handle nested objects for edges
+        if age_type == 'edge'
+          result[:start_node] = start_node.to_rich_h if start_node&.respond_to?(:to_rich_h)
+          result[:end_node] = end_node.to_rich_h if end_node&.respond_to?(:to_rich_h)
+        end
+
+        result
+      end
+
       def update_attributes(attribs)
         attribs.except(id:).each do |key, value|
           send("#{key}=", value) if respond_to?("#{key}=")

data/lib/apache_age/entities/edge.rb

@@ -47,26 +47,6 @@ module ApacheAge
         errors.add(:end_node, 'invalid') if end_node && !end_node.valid?
       end
 
-      # Discover attribute class
-      # name_type = model.class.attribute_types['name']
-      # age_type = model.class.attribute_types['age']
-      # company_type = model.class.attribute_types['company']
-      # # Determine the class from the attribute type (for custom types)
-      # name_class = name_type.class # This will generally be ActiveModel::Type::String
-      # age_class = age_type.class   # This will generally be ActiveModel::Type::Integer
-      # # For custom types, you may need to look deeper
-      # company_class = company_type.cast_type.class
-
-      # AgeSchema::Edges::HasJob.create(
-      #   start_node: fred, end_node: quarry, employee_role: 'Crane Operator'
-      # )
-      # SELECT *
-      # FROM cypher('age_schema', $$
-      #     MATCH (start_vertex:Person), (end_vertex:Company)
-      #     WHERE id(start_vertex) = 1125899906842634 and id(end_vertex) = 844424930131976
-      #     CREATE (start_vertex)-[edge:HasJob {employee_role: 'Crane Operator'}]->(end_vertex)
-      #     RETURN edge
-      # $$) as (edge agtype);
       def create_sql
         self.start_node = start_node.save unless start_node.persisted?
         self.end_node = end_node.save unless end_node.persisted?

data/lib/apache_age/entities/entity.rb

@@ -2,6 +2,10 @@ module ApacheAge
   module Entities
     class Entity
       class << self
+        def ensure_query_builder!
+          @query_builder ||= ApacheAge::Entities::QueryBuilder.new(self)
+        end
+
         def find_by(attributes)
           where_clause =
             attributes
@@ -18,6 +22,56 @@ module ApacheAge
 
         def find(id) = find_by(id: id)
 
+        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
+
         private
 
         def age_graph = 'age_schema'

data/lib/apache_age/entities/node.rb

@@ -25,10 +25,6 @@ module ApacheAge
       # RETURN company
       # $$) as (Company agtype);
       def create_sql
-        # can't use sanitiye without a solution for '_' in the alias name & label
-        # alias_name = ActiveRecord::Base.sanitize_sql_like(age_alias || age_label.downcase)
-        # label_name = ActiveRecord::Base.sanitize_sql_like(age_label)
-
         alias_name = age_alias || age_label.downcase
         sanitized_properties =
           self
@@ -69,7 +65,6 @@ module ApacheAge
           $$) as (#{age_label} agtype);
         SQL
       end
-
     end
   end
 end

data/lib/apache_age/entities/path.rb

@@ -4,23 +4,85 @@ module ApacheAge
       extend ActiveSupport::Concern
 
       included do
-        include ActiveModel::Model
-        include ActiveModel::Dirty
-        include ActiveModel::Attributes
+        extend ApacheAge::Entities::ClassMethods
+        include ApacheAge::Entities::CommonMethods
+      end
+
+      def age_type = 'path'
 
-        attribute :id, :integer
-        # attribute :label, :string
-        attribute :end_id, :integer
-        attribute :start_id, :integer
-        # override with a specific node type in the defining class
-        attribute :end_node
-        attribute :start_node
+      def ensure_query_builder!
+        @query_builder ||= ApacheAge::Entities::QueryBuilder.new(self.class)
+      end
 
-        validates :end_node, :start_node, presence: true
-        validate :validate_nodes
+      def match_clause
+        "path = (start_node)-[#{path_edge}#{path_length}#{path_properties}]->(end_node)"
+      end
 
-        extend ApacheAge::Entities::ClassMethods
-        include ApacheAge::Entities::CommonMethods
+      def match(match_string)
+        @match_clause = 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
+
+      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
+
+      # transforms 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
+
+      def to_sql
+        ensure_query_builder!
+        @query_builder.to_sql
+      end
+
+      private
+
+      def execute_where(cypher_sql)
+        age_results = ActiveRecord::Base.connection.execute(cypher_sql)
+        binding.irb
+        return [] if age_results.values.count.zero?
+
+        age_results.values.map do |value|
+          json_data = value.first.split('::').first
+          hash = JSON.parse(json_data)
+          attribs = hash.except('label', 'properties').merge(hash['properties']).symbolize_keys
+
+          new(**attribs)
+        end
       end
     end
   end

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,28 +15,27 @@ 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
 
-      # TODO: allow for multiple graphs
-      # 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
@@ -124,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
@@ -185,7 +189,8 @@ module ApacheAge
           # Skip transformation if part is one of the logical operators or separators
           next part if operators.include?(part.strip) || separators.include?(part.strip)
 
-          if part.include?(".")
+          # 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