rails_age 0.6.3 → 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