rails_age 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6777870b945c8684ea2ef5d10b8e7411259e002001b074754840a9422b594cee
-  data.tar.gz: '008ab62bbe28d408d390acd5e00cecc764507e21ae3d38ca94d219e9d299435f'
+  metadata.gz: 053d21a51d2e91cb61ea1678d2d84c05ac4a1a84a643334c4993df9f6ca9c3c0
+  data.tar.gz: 57f945d6055d9dca60414321e3f39dd09abfdb1a8f2a3a5fec0b4c5e3e9ee656
 SHA512:
-  metadata.gz: 8a9c122ce1a8b5b173fc9ffd6ba45a4bf97965eb0681ec0d44e9779dcc1ef647da8e7e5110a5564a9f28c329ebe9e83ba832d920f4504bb5026650f41cc102d2
-  data.tar.gz: f9217b16e0177746a438ab5fed8a4e5c7f4bb6ff02b3e31a2a4d1db7a8bd246550e33be6494e0533c70dcbcde3a54078ed041b2c3a08718cb9b020c73353eee5
+  metadata.gz: 017c585f995749dad85f341b41a01d2f94b0cc03fac6240d63e4755e8ab0c7148969793fbe9c308f13c0ea94d35eee3fb231516eb775817a53bef003843d41e4
+  data.tar.gz: 83760cc109544589665b7297776538f48f4ac0c14273455957e714ff6d9614e1a4e8d8ba862e39b8735a5f1e5a1f9c8ca5e429f1823aee8b98e38bad3dded2de

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Change Log
 
-## VERSION 0.6.4 - 2024-xx-xx
+## VERSION 0.9.1 - xxxx-xx-xx
+
+- **Edge Generator**
+  * add start-/end-nodes types to edge generator (would make scaffold easier), ie:
+    `rails generate apache_age:edge HasPet owner_role start_node:person end_node:pet`
+    with property and specified start-/end-nodes (person and pet nodes must have already been created)
+
+- **Edge Scaffold** with node types?
+  * add `rails generate apache_age:edge_scaffold HasJob employee_role start_node:person end_node:company`
+
+## VERSION 0.9.0 - 2024-xx-xx
+- **AGE visual paths graph**
+  * add `rails generate apache_age:visualize`
+
+## VERSION 0.8.0 - 2024-xx-xx
 
 - **cypher queries** (like active record queries)
   * schema override
@@ -8,11 +22,12 @@
   * paths support
   * select attributes support
 
-## VERSION 0.6.3 - 2024-xx-xx
+## VERSION 0.7.0 - 2024-xx-xx
 
-- **Age Path**
+- **Age Path** - nodes and edges combined
+  * add `rails generate apache_age:path_scaffold HasJob employee_role start_node:person end_node:company`
 
-## VERSION 0.6.2 - 2024-xx-xx
+## VERSION 0.6.3 - 2024-xx-xx
 
 breaking change?: namespaces (by default) will use their own schema? (add to database.yml & schema.rb ?)
 
@@ -20,25 +35,26 @@ breaking change?: namespaces (by default) will use their own schema? (add to dat
 
 - **multiple AGE Schema**
 
-## VERSION 0.6.1 - 2024-xx-xx
+## VERSION 0.6.2 - 2024-xx-xx
 
-- **Fix**
-  * show validation errors in scaffold views
+- **Query Sanitize**
 
-- **Edge Generator**
-  * add start-/end-nodes types to edge generator (would make scaffold easier), ie:
-    `rails generate apache_age:edge HasPet owner_role start_node:person end_node:pet`
-    with property and specified start-/end-nodes (person and pet nodes must have already been created)
+## VERSION 0.6.1 - 2024-09-29
 
-- **Edge Scaffold** (generates edge, type, view and controller)
-  * add `rails generate apache_age:edge_scaffold HasJob employee_role start_node:person end_node:company`
+**Queries are not yet sanitize (injection filtered)!**
+
+- **where nodes** - Edge and Node
+- **where edges** - allow subquery on node attributes?
+- **limit** - limit the number of results returned
+
+## VERSION 0.6.0 - 2024-06-28
 
-## VERSION 0.6.0 - 2024-06-xx
+**Document showing errors**
 
 **breaking changes**: update naming
   * renamed `Entities::Vertex` module to `Entities::Node`
   * renamed `UniqueVertex` to `UniqueNode`
-  * rebamed `AgeTypeGenerator` to `Type::Factory`
+  * rebamed `AgeTypeGenerator.create_type_for` to `Type::Factory.type_for`
   * move `lib/generators/*` intp `lib/apache_age/generators`
 
 here is the [commit](https://github.com/marpori/rails_age_demo_app/commit/a6f0708f2bbc165eddbafe63896068a72d803b17) to see the changes te demo app to make it work for release 0.6.0

data/README.md

@@ -147,24 +147,260 @@ rails generate apache_age:scaffold_node Person first_name last_name
 rails generate apache_age:scaffold_node Animals/Pet pet_name birthdate:date
 ```
 
-### EDGE Scaffold Generation**
-
-NOTE: the generator will only allow `:node` (default type) for start_node and end_node, however, it is strongly recommended to specify the start_node and end_node types manually. _Hopefully, I can find a way to get the generators to recognize and allow the usage of custom node types. Thus eventually, I hope: `rails generate apache_age:node HasPet start_node:person end_node:pet caretaker_role` will work._
-
+now you can test your nodes at:
 ```bash
-rails generate apache_age:edge HasJob employee_role begin_date:date
+http://localhost/people
+# and
+http://localhost/animals_pets
 ```
 
-_edge scaffold is coming soon._
+Note: Turbo seems to interfere with the default rails template's ability to show errors, this can easily be fixed by disabling turbo for forms that where turbo isn't needed by adding `data: { turbo: false }` to the form, ie:
+```ruby
+<%= form_with(model: animals_pet, data: { turbo: false }) do |form| %>
+  ...
+<% end %>
+```
+
+### EDGE Scaffold Generation**
 
 ```bash
 # without a namespace
 rails generate apache_age:scaffold_edge HasPet caretaker_role
+rails generate apache_age:edge HasJob employee_role begin_date:date
 
 # with a namespace
-rails generate apache_age:scaffold_edge People/HasSpouse spousal_role
+rails generate apache_age:scaffold_edge People/HasSpouce spousal_role
 ```
 
+now you can test your edges at:
+```bash
+http://localhost/has_pets
+http://localhost/has_jobs
+# and
+http://localhost/people/has_spouses
+```
+
+you can improve the view to only show the items you expect to be associated with the start- and end-node by changing the selects in the form from the generic form (finds all nodes):
+```ruby
+  <div>
+    <%= form.label :end_node, style: "display: block" %>
+    <%= form.collection_select(:end_id, ApacheAge::Node.all, :id, :display, prompt: 'Select an End-Node') %>
+  </div>
+```
+to selecting a specific node expected (along with the desired 'name' in the list)
+```ruby
+  <div>
+    <%= form.label :end_node, style: "display: block" %>
+    <%= form.collection_select(:end_id, Company.all, :id, :company_name, prompt: 'Select a Company') %>
+  </div>
+```
+so full form change for has_job could look like:
+```ruby
+# app/views/has_jobs/_form.html.erb
+<%= form_with(model: has_job, url: form_url) do |form| %>
+  <% if has_job.errors.any? %>
+    <div style="color: red">
+      <h2><%= pluralize(has_job.errors.count, "error") %> prohibited this has_job from being saved:</h2>
+
+      <ul>
+        <% has_job.errors.each do |error| %>
+          <li><%= error.full_message %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div>
+    <%= form.label :employee_role, style: "display: block" %>
+    <%= form.text_field :employee_role %>
+  </div>
+
+  <div>
+    <%= form.label :start_node, style: "display: block" %>
+    <%= form.collection_select(:start_id, Person.all, :id, :first_name, prompt: 'Select a person') %>
+  </div>
+
+  <div>
+    <%= form.label :end_node, style: "display: block" %>
+    <%= form.collection_select(:end_id, Company.all, :id, :company_name, prompt: 'Select a Company') %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>
+```
+
+To make your code more robust (enforce that the appropriate node type is associate with the start- and end-nodes) you can adjust the edge definition by adding the node type to the `start_node` and `end_node` attributes.
+from
+```ruby
+  attribute :start_node
+  attribute :end_node
+```
+to:
+```ruby
+  attribute :start_node, :person
+  attribute :end_node, :company
+```
+For example you can make the edge/has_pet.rb more robust by making the model look like:
+```ruby
+# app/edges/has_job.rb
+class HasJob
+  include ApacheAge::Entities::Edge
+
+  attribute :employee_role, :string
+  attribute :start_node, :person
+  attribute :end_node, :company
+
+  validates :employee_role, presence: true
+  validate :validate_unique
+
+  private
+
+  def validate_unique
+    ApacheAge::Validators::UniqueEdge
+      .new(attributes: %i[employee_role start_node end_node])
+      .validate(self)
+  end
+end
+```
+
+The generator will only allow `:node` (default type) since at the time of running the generator (at least within tests, the custom types are not known), eventually, I hope to find a way to fix that and allow:
+`rails generate apache_age:node HasPet start_node:person end_node:pet caretaker_role`
+but that doesn't work yet!
+
+### AGE Rails Quick Example
+
+```bash
+rails new stone_age --database=postresql
+cd stone_age
+
+bundle add rails_age
+bundle install
+bin/rails apache_age:install
+bin/rails apache_age:override_db_migrate
+rails db:create
+rails db:migrate
+rails generate apache_age:scaffold_node Person first_name, last_name, gender
+rails generate apache_age:scaffold_node Pet name gender species
+rails generate apache_age:scaffold_edge HasChild role:string
+rails generate apache_age:scaffold_edge HasSibling role:string
+rails generate apache_age:scaffold_edge HasSpouse role:string
+
+# seed file: [db/seed.rb](SEED.md)
+rails db:seed
+
+# Console Usage (seed doesn't provide any pets)
+dino = Pet.create(name: 'Dino', gender: 'male', species: 'dinosaur')
+dino.to_h
+
+# find a person
+fred = Person.find_by(first_name: 'Fred', last_name: 'Flintstone')
+fred.to_h
+
+pebbles = Person.find_by(first_name: 'Pebbles')
+pebbles.to_h
+
+# find an edge
+father_relationship = HasChild.find_by(start_node: fred, end_node: pebbles)
+father_relationship.to_h
+> {:id=>1407374883553310,
+ :end_id=>844424930131996,
+ :start_id=>844424930131986,
+ :role=>"father",
+ :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"},
+ :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
+
+# where - find multiple nodes
+family = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).all.puts family.map(&:to_h)
+
+family
+> [{:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"},
+>  {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"},
+?  {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"},
+>  {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}]
+
+# all - unsorted
+all_family = Person.where(last_name: 'Flintstone').all
+puts all_family.map(&:to_h)
+> {:id=>844424930131969, :last_name=>"Flintstone", :first_name=>"Zeke", :gender=>"female"}
+> {:id=>844424930131970, :last_name=>"Flintstone", :first_name=>"Jed", :gender=>"male"}
+> {:id=>844424930131971, :last_name=>"Flintstone", :first_name=>"Rockbottom", :gender=>"male"}
+> {:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"}
+> {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}
+> {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"}
+> {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}
+> {:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}
+> {:id=>844424930131995, :last_name=>"Flintstone", :first_name=>"Stoney", :gender=>"male"}
+> {:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}
+
+# where - multiple edges (relations) - for now only edge attributes and start/end nodes can be queried
+parental_relations = HasChild.where(end_node: pebbles)
+puts parental_relations.map(&:to_h)
+> {:id=>1407374883553310, :end_id=>844424930131996, :start_id=>844424930131986, :role=>"father", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
+> {:id=>1407374883553309, :end_id=>844424930131996, :start_id=>844424930131987, :role=>"mother", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}}
+
+
+raw_pg_results = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).execute
+=> #<PG::Result:0x000000012255f348 status=PGRES_TUPLES_OK ntuples=4 nfields=1 cmd_tuples=4>
+raw_pg_results.values
+> [["{\"id\": 844424930131974, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Ed\"}}::vertex"],
+>  ["{\"id\": 844424930131976, \"label\": \"Person\", \"properties\": {\"gender\": \"female\", \"last_name\": \"Flintstone\", \"first_name\": \"Edna\"}}::vertex"],
+>  ["{\"id\": 844424930131986, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Fred\"}}::vertex"],
+>  ["{\"id\": 844424930131975, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Giggles\"}}::vertex"]]
+```
+
+### Age Cypher Queries
+
+```ruby
+flintstone_family =
+  Person.where(last_name: 'Flintstone')
+        .order(:first_name)
+        .limit(4).all
+        .map(&:to_h)
+
+# generates the query
+SELECT *
+FROM cypher('age_schema', $$
+    MATCH (find:Person)
+    WHERE find.last_name = 'Flintstone'
+    RETURN find
+    ORDER BY find.first_name
+    LIMIT 4
+$$) as (Person agtype);
+
+# and returns:
+[{:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"},
+ {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"},
+ {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"},
+ {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}]
+```
+
+```ruby
+query =
+  Person.
+    cypher('age_schema')
+    .match("(a:Person), (b:Person)")
+    .where("a.name = 'Node A'", "b.name = 'Node B'")
+    .return("a.name", "b.name")
+    .as("name_a agtype, name_b agtype")
+    .execute
+```
+
+or more generally:
+
+```ruby
+tihen =
+  ApacheAge::Cypher
+    .new('age_schema')
+    .create("(person:Person {name: 'Tihen'})")
+    .return('person')
+    .as('Person agtype')
+    .execute
+```
+
+see [AGE Cypher Queries](AGE_CYPHER_QUERIES.md)
+
 ### AGE Usage within Rails Console
 
 see [AGE Usage within Rails Console](AGE_CONSOLE_USAGE.md)

data/lib/apache_age/cypher.rb

@@ -0,0 +1,95 @@
+module ApacheAge
+  class Cypher
+    class << self
+      attr_accessor :model_class
+    end
+
+    def initialize(graph_name = 'age_schema')
+      @graph_name = graph_name
+      @query = ""
+      @as_type = "result agtype"
+    end
+
+    def match(pattern)
+      @query += "MATCH #{pattern} "
+      self
+    end
+
+    # WITH n.name as name, n.age as age
+    # WITH otherPerson, count(*) AS foaf WHERE foaf > 1
+    # with has a lot of cases - see docs
+    def with(*conditions)
+      @query += "WITH #{variables.join(', ')} "
+      self
+    end
+
+    def where(*conditions)
+      condition_str = conditions.join(' AND ')
+      # @query += "WHERE #{condition_str} "
+      # If there's already a WHERE clause in the query, append to it (they need to be adjacent!)
+      @query += (@query.include?("WHERE") ? " AND #{condition_str} " : "WHERE #{condition_str} ")
+      self
+    end
+
+    # ORDER BY n.age DESC, n.name ASC
+    def order_by(*conditions)
+      @query += "ORDER BY #{variables.join(', ')} "
+      self
+    end
+
+    # can use full names n.name or aliases (with) name
+    def return(*variables)
+      @query += "RETURN #{variables.join(', ')} "
+      self
+    end
+
+    def create(node)
+      @query += "CREATE #{node} "
+      self
+    end
+
+    def set(properties)
+      @query += "SET #{properties} "
+      self
+    end
+
+    def remove(property)
+      @query += "REMOVE #{property} "
+      self
+    end
+
+    def delete(entity)
+      @query += "DELETE #{entity} "
+      self
+    end
+
+    def merge(pattern)
+      @query += "MERGE #{pattern} "
+      self
+    end
+
+    def skip(count)
+      @query += "SKIP #{count} "
+      self
+    end
+
+    def limit(count)
+      @query += "LIMIT #{count} "
+      self
+    end
+
+    def as(type)
+      @as_type = type
+      self
+    end
+
+    def to_cypher
+      "SELECT * FROM cypher('#{@graph_name}', $$ #{@query.strip} $$) AS (#{@as_type});"
+    end
+
+    def execute
+      cypher_sql = to_cypher
+      ActiveRecord::Base.connection.execute(cypher_sql)
+    end
+  end
+end

data/lib/apache_age/entities/class_methods.rb

@@ -8,40 +8,24 @@ module ApacheAge
         instance
       end
 
-      def find_by(attributes)
-        return nil if attributes.reject{ |k,v| v.blank? }.empty?
-
-        edge_keys = [:start_id, :start_node, :end_id, :end_node]
-        return find_edge(attributes) if edge_keys.any? { |key| attributes.include?(key) }
-
-        where_clause = attributes.map { |k, v| "find.#{k} = '#{v}'" }.join(' AND ')
-        cypher_sql = find_sql(where_clause)
-
-        execute_find(cypher_sql)
+      def where(attributes)
+        query_builder = QueryBuilder.new(self)
+        query_builder.where(attributes)
       end
 
-      def find(id)
-        where_clause = "id(find) = #{id}"
-        cypher_sql = find_sql(where_clause)
-        execute_find(cypher_sql)
-      end
-
-      def all
-        age_results = ActiveRecord::Base.connection.execute(all_sql)
-        return [] if age_results.values.count.zero?
+      def all = QueryBuilder.new(self).all
+      def first = QueryBuilder.new(self).limit(1).first
+      def find(id) = where(id: id).first
 
-        age_results.values.map do |result|
-          json_string = result.first.split('::').first
-          hash = JSON.parse(json_string)
-          attribs = hash.except('label', 'properties').merge(hash['properties']).symbolize_keys
+      def find_by(attributes)
+        return nil if attributes.reject { |k, v| v.blank? }.empty?
 
-          new(**attribs)
-        end
+        where(attributes).limit(1).first
       end
 
       # Private stuff
 
-      def find_edge(attributes)
+      def where_edge(attributes)
         where_attribs =
           attributes
           .compact
@@ -57,9 +41,9 @@ module ApacheAge
         where_clause = [where_attribs, where_start_id, where_end_id].compact.join(' AND ')
         return nil if where_clause.empty?
 
-        cypher_sql = find_edge_sql(where_clause)
+        cypher_sql = edge_sql(where_clause)
 
-        execute_find(cypher_sql)
+        execute_where(cypher_sql)
       end
 
       def age_graph = 'age_schema'
@@ -70,17 +54,21 @@ module ApacheAge
         age_type == 'vertex' ? "(find:#{age_label})" : "(start_node)-[find:#{age_label}]->(end_node)"
       end
 
-      def execute_find(cypher_sql)
-        age_result = ActiveRecord::Base.connection.execute(cypher_sql)
-        return nil if age_result.values.count.zero?
+      def execute_sql(cypher_sql) = ActiveRecord::Base.connection.execute(cypher_sql)
 
-        age_type = age_result.values.first.first.split('::').last
-        json_data = age_result.values.first.first.split('::').first
+      def execute_find(cypher_sql) = execute_where(cypher_sql).first
 
-        hash = JSON.parse(json_data)
-        attribs = hash.except('label', 'properties').merge(hash['properties']).symbolize_keys
+      def execute_where(cypher_sql)
+        age_results = ActiveRecord::Base.connection.execute(cypher_sql)
+        return [] if age_results.values.count.zero?
 
-        new(**attribs)
+        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
 
       def all_sql
@@ -93,7 +81,7 @@ module ApacheAge
         SQL
       end
 
-      def find_sql(where_clause)
+      def node_sql(where_clause)
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
@@ -104,7 +92,7 @@ module ApacheAge
         SQL
       end
 
-      def find_edge_sql(where_clause)
+      def edge_sql(where_clause)
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
@@ -114,6 +102,48 @@ module ApacheAge
           $$) as (#{age_label} agtype);
         SQL
       end
+
+      private
+
+      def where_node_clause(attributes)
+        build_core_where_clause(attributes)
+      end
+
+      def where_edge_clause(attributes)
+        core_attributes = attributes.except(:end_id, :start_id, :end_node, :start_node)
+        core_clauses = core_attributes.empty? ? nil : build_core_where_clause(core_attributes)
+
+        end_id =
+          if attributes[:end_id]
+            end_id = attributes[:end_id]
+          elsif attributes[:end_node].is_a?(Node)
+            end_id = attributes[:end_node]&.id
+          end
+        where_end_id = end_id ? "id(end_node) = #{end_id}" : nil
+
+        start_id =
+          if attributes[:start_id]
+            start_id = attributes[:start_id]
+          elsif attributes[:start_node].is_a?(Node)
+            start_id = attributes[:start_node]&.id
+          end
+        where_start_id = start_id ? "id(start_node) = #{start_id}" : nil
+
+        where_end_attrs =
+          attributes[:end_node].map { |k, v| "end_node.#{k} = '#{v}'" } if attributes[:end_node].is_a?(Hash)
+        where_start_attrs =
+          attributes[:start_node].map { |k, v| "start_node.#{k} = '#{v}'" } if attributes[:start_node].is_a?(Hash)
+
+        [core_clauses, where_start_id, where_end_id, where_start_attrs, where_end_attrs]
+          .flatten.compact.join(' AND ')
+      end
+
+      def build_core_where_clause(attributes)
+        attributes
+          .compact
+          .map { |k, v| k == :id ? "id(find) = #{v}" : "find.#{k} = '#{v}'"}
+          .join(' AND ')
+      end
     end
   end
 end

data/lib/apache_age/entities/edge.rb

@@ -7,6 +7,8 @@ module ApacheAge
         include ActiveModel::Model
         include ActiveModel::Dirty
         include ActiveModel::Attributes
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
 
         attribute :id, :integer
         # attribute :label, :string

data/lib/apache_age/entities/node.rb

@@ -7,6 +7,8 @@ module ApacheAge
         include ActiveModel::Model
         include ActiveModel::Dirty
         include ActiveModel::Attributes
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
 
         attribute :id, :integer
 

data/lib/apache_age/entities/path.rb

@@ -0,0 +1,27 @@
+module ApacheAge
+  module Entities
+    module Path
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Model
+        include ActiveModel::Dirty
+        include ActiveModel::Attributes
+
+        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
+
+        validates :end_node, :start_node, presence: true
+        validate :validate_nodes
+
+        extend ApacheAge::Entities::ClassMethods
+        include ApacheAge::Entities::CommonMethods
+      end
+    end
+  end
+end

data/lib/apache_age/entities/query_builder.rb

@@ -0,0 +1,159 @@
+# query =
+#   Person.
+#     cypher('age_schema')
+#     .match("(a:Person), (b:Person)")
+#     .where("a.name = 'Node A'", "b.name = 'Node B'")
+#     .return("a.name", "b.name")
+#     .as("name_a agtype, name_b agtype")
+#     .execute
+# def cypher(graph_name = 'age_schema')
+#   ApacheAge::Cypher.new(graph_name)
+#   self
+# end
+
+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)
+        @model_class = model_class
+        @where_clauses = []
+        @return_names = ['find']
+        @return_clause = 'find'
+        @return_variables = []
+        @order_clause = nil
+        @limit_clause = nil
+        @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
+
+      # need to handle string inputs too: ie: "id(find) = #{id}"
+      def where(attributes)
+        return self if attributes.blank?
+
+        @where_clauses <<
+          if attributes.is_a?(String)
+            if attributes.include?('id(') || attributes.include?('find.')
+              attributes
+            else
+              "find.#{attributes}"
+            end
+          else
+            edge_keys = [:start_id, :start_node, :end_id, :end_node]
+            if edge_keys.any? { |key| attributes.include?(key) }
+              model_class.send(:where_edge_clause, attributes)
+            else
+              model_class.send(:where_node_clause, attributes)
+            end
+          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
+
+      def order(ordering)
+        @order_clause = nil
+        return self if ordering.blank?
+
+        order_by_values = Array.wrap(ordering).map { |order| parse_ordering(order) }.join(', ')
+        @order_clause = "ORDER BY #{order_by_values}"
+        self
+      end
+
+      def limit(limit_value)
+        @limit_clause = "LIMIT #{limit_value}"
+        self
+      end
+
+      def all
+        cypher_sql = build_query
+        results = model_class.send(:execute_where, cypher_sql)
+        return results if return_variables.empty?
+
+        results.map(&:to_h).map { _1.slice(*return_variables) }
+      end
+
+      def execute
+        cypher_sql = build_query
+        model_class.send(:execute_sql, cypher_sql)
+      end
+
+      def first
+        cypher_sql = build_query(limit_clause || "LIMIT 1")
+        model_class.send(:execute_find, cypher_sql)
+      end
+
+      def to_sql
+        build_query.strip
+      end
+
+      private
+
+      def parse_ordering(ordering)
+        if ordering.is_a?(Hash)
+          # Convert hash into "find.key direction" format and join with commas
+          ordering = ordering.map { |k, v| "find.#{k} #{v}" }.join(', ')
+        elsif ordering.is_a?(Symbol)
+          # If it's a symbol, simply prepend "find."
+          ordering = "find.#{ordering}"
+        elsif ordering.is_a?(String)
+          # If it's a string, assume it's already in the correct format
+          ordering = ordering
+        elsif ordering.is_a?(Array)
+          # If it's an array, process each element recursively
+          ordering = ordering.map do |order|
+            if order.is_a?(Hash)
+              order.map { |k, v| "find.#{k} #{v}" }.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(', ')
+        else
+          raise ArgumentError, 'Ordering must be a string, symbol, hash, or array'
+        end
+      end
+
+      def build_query(_extra_clause = nil)
+        where_sql = where_clauses.any? ? "WHERE #{where_clauses.join(' AND ')}" : ''
+        order_by = order_clause.present? ? order_clause : ''
+        <<-SQL.squish
+          SELECT *
+          FROM cypher('#{graph_name}', $$
+              MATCH #{match_clause}
+              #{where_sql}
+              RETURN #{return_clause}
+              #{order_clause}
+              #{limit_clause}
+          $$) AS (#{return_names.join(' agtype, ')} agtype);
+        SQL
+      end
+    end
+  end
+end

data/lib/apache_age/path.rb

@@ -0,0 +1,4 @@
+module ApacheAge
+  class Path
+  end
+end

data/lib/rails_age/version.rb

@@ -1,3 +1,3 @@
 module RailsAge
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

data/lib/rails_age.rb

@@ -6,13 +6,17 @@ module RailsAge
 end
 
 module ApacheAge
+  require 'apache_age/cypher.rb'
+  require 'apache_age/entities/query_builder'
   require 'apache_age/entities/class_methods'
   require 'apache_age/entities/common_methods'
   require 'apache_age/entities/entity'
   require 'apache_age/entities/node'
   require 'apache_age/entities/edge'
+  # require 'apache_age/entities/path'
   require 'apache_age/node'
   require 'apache_age/edge'
+  # require 'apache_age/path'
   require 'apache_age/validators/expected_node_type'
   require 'apache_age/validators/unique_node'
   require 'apache_age/validators/unique_edge'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_age
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Bill Tihen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-27 00:00:00.000000000 Z
+date: 2024-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -96,14 +110,18 @@ files:
 - config/routes.rb
 - db/migrate/20240521062349_add_apache_age.rb
 - db/schema.rb
+- lib/apache_age/cypher.rb
 - lib/apache_age/edge.rb
 - lib/apache_age/entities/class_methods.rb
 - lib/apache_age/entities/common_methods.rb
 - lib/apache_age/entities/edge.rb
 - lib/apache_age/entities/entity.rb
 - lib/apache_age/entities/node.rb
+- lib/apache_age/entities/path.rb
+- lib/apache_age/entities/query_builder.rb
 - lib/apache_age/entities/vertex.rb
 - lib/apache_age/node.rb
+- lib/apache_age/path.rb
 - lib/apache_age/types/factory.rb
 - lib/apache_age/validators/expected_node_type.rb
 - lib/apache_age/validators/node_type_validator.rb
@@ -162,14 +180,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
 summary: Apache AGE plugin for Rails 7.x