rails_age 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6777870b945c8684ea2ef5d10b8e7411259e002001b074754840a9422b594cee
-  data.tar.gz: '008ab62bbe28d408d390acd5e00cecc764507e21ae3d38ca94d219e9d299435f'
+  metadata.gz: '01018a3efe8d4cef46fce365b6fd442882d8bf4ff51e0ad3d3bdb235db80ebb7'
+  data.tar.gz: 69a20eb39f9609c6350463d6a391b7f08887079e51e56602a6357d914571ed8f
 SHA512:
-  metadata.gz: 8a9c122ce1a8b5b173fc9ffd6ba45a4bf97965eb0681ec0d44e9779dcc1ef647da8e7e5110a5564a9f28c329ebe9e83ba832d920f4504bb5026650f41cc102d2
-  data.tar.gz: f9217b16e0177746a438ab5fed8a4e5c7f4bb6ff02b3e31a2a4d1db7a8bd246550e33be6494e0533c70dcbcde3a54078ed041b2c3a08718cb9b020c73353eee5
+  metadata.gz: cc2ea56dcb102213397ca5ffc19edc095341e51307b0500d0be7bc7595cb65f64e74c6490a678703f5faf903d0396010b63b8dd33e162ed218e038a4e95e05f5
+  data.tar.gz: 30e0472fb006bf883cb57a5c7406571d4fc4715a9d6d96e792dd5d3b4998e538eab74f809b5d384072d88e77ce2d6fb143cdb6a5c20fd044fd74673edd2bb13a

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,37 +22,51 @@
   * paths support
   * select attributes support
 
-## VERSION 0.6.3 - 2024-xx-xx
-
-- **Age Path**
-
-## VERSION 0.6.2 - 2024-xx-xx
+## VERSION 0.8.0 - 2024-xx-xx
 
 breaking change?: namespaces (by default) will use their own schema? (add to database.yml & schema.rb ?)
 
 - **AGE Schema override**
 
-- **multiple AGE Schema**
+- **Multiple AGE Schema**
 
-## VERSION 0.6.1 - 2024-xx-xx
+## VERSION 0.7.0 - 2024-xx-xx
 
-- **Fix**
-  * show validation errors in scaffold views
+- **Age Path** - nodes and edges combined
+  * add `rails generate apache_age:path_scaffold HasJob employee_role start_node:person end_node:company`
 
-- **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** (generates edge, type, view and controller)
-  * add `rails generate apache_age:edge_scaffold HasJob employee_role start_node:person end_node:company`
+## VERSION 0.6.3 - 2024-xx-xx
+
+- **Query Sanitize**:
+  * reject attributes not defined in model
+  * sanitize strings using: id(find) = ?, 23 & find.first_name = ?, 'John'
+
+## VERSION 0.6.2 - 2024-09-30
+
+- **Query Sanitize**
+  * hashes sanitized
+
+- **TODO**:
+  * reject attributes not defined in model
+  * sanitize strings using: id(find) = ?, 23 & find.first_name = ?, 'John'
+
+## VERSION 0.6.1 - 2024-09-29
+
+**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 (soon - not yet tested nor santized):
+
+```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,58 +8,44 @@ 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)
+      # used? or dead code?
+      def where_edge(attributes)
         where_attribs =
           attributes
-          .compact
-          .except(:end_id, :start_id, :end_node, :start_node)
-          .map { |k, v| "find.#{k} = '#{v}'" }.join(' AND ')
+            .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 ? "id(end_node) = #{end_id}" : nil
-        where_start_id = start_id ? "id(start_node) = #{start_id}" : nil
+        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 = 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 +56,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)
+
+      def execute_find(cypher_sql) = execute_where(cypher_sql).first
 
-        age_type = age_result.values.first.first.split('::').last
-        json_data = age_result.values.first.first.split('::').first
+      def execute_where(cypher_sql)
+        age_results = ActiveRecord::Base.connection.execute(cypher_sql)
+        return [] if age_results.values.count.zero?
 
-        hash = JSON.parse(json_data)
-        attribs = hash.except('label', 'properties').merge(hash['properties']).symbolize_keys
+        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)
+          new(**attribs)
+        end
       end
 
       def all_sql
@@ -93,7 +83,7 @@ module ApacheAge
         SQL
       end
 
-      def find_sql(where_clause)
+      def node_sql(where_clause)
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
@@ -104,7 +94,7 @@ module ApacheAge
         SQL
       end
 
-      def find_edge_sql(where_clause)
+      def edge_sql(where_clause)
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
@@ -114,6 +104,56 @@ 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]
+            attributes[:end_id]
+          elsif attributes[:end_node].is_a?(Node)
+            attributes[:end_node]&.id
+          end
+        where_end_id = end_id ? ActiveRecord::Base.sanitize_sql(["id(end_node) = ?", end_id]) : nil
+
+        start_id =
+          if attributes[:start_id]
+            attributes[:start_id]
+          elsif attributes[:start_node].is_a?(Node)
+            attributes[:start_node]&.id
+          end
+        where_start_id = start_id ? ActiveRecord::Base.sanitize_sql(["id(start_node) = ?", start_id]) : nil
+
+        where_end_attrs =
+          if attributes[:end_node].is_a?(Hash)
+            attributes[:end_node].map { |k, v| ActiveRecord::Base.sanitize_sql(["end_node.#{k} = ?", v]) }
+          end
+        where_start_attrs =
+          if attributes[:start_node].is_a?(Hash)
+            attributes[:start_node].map { |k, v| ActiveRecord::Base.sanitize_sql(["start_node.#{k} = ?", v]) }
+          end
+
+        [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 do |k, v|
+            query_string = k == :id ? "id(find) = #{v}" : "find.#{k} = '#{v}'"
+            ActiveRecord::Base.sanitize_sql([query_string, v])
+          end
+          .join(' AND ')
+      end
     end
   end
 end

data/lib/apache_age/entities/common_methods.rb

@@ -57,13 +57,14 @@ module ApacheAge
       def destroy
         match_clause = (age_type == 'vertex' ? "(done:#{age_label})" : "()-[done:#{age_label}]->()")
         delete_clause = (age_type == 'vertex' ? 'DETACH DELETE done' : 'DELETE done')
+        sanitized_id = ActiveRecord::Base.sanitize_sql(["id(done) = ?", id])
         cypher_sql =
           <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
               MATCH #{match_clause}
-              WHERE id(done) = #{id}
-   	          #{delete_clause}
+              WHERE #{sanitized_id}
+              #{delete_clause}
               return done
           $$) as (deleted agtype);
           SQL
@@ -99,7 +100,8 @@ module ApacheAge
       def properties_to_s
         string_values =
           age_properties.each_with_object([]) do |(key, val), array|
-            array << "#{key}: '#{val}'"
+            sanitized_val = ActiveRecord::Base.sanitize_sql(["?", val])
+            array << "#{key}: #{sanitized_val}"
           end
         "{#{string_values.join(', ')}}"
       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
@@ -68,12 +70,25 @@ module ApacheAge
       def create_sql
         self.start_node = start_node.save unless start_node.persisted?
         self.end_node = end_node.save unless end_node.persisted?
+
+        start_node_age_label = ActiveRecord::Base.sanitize_sql(start_node.age_label)
+        end_node_age_label = ActiveRecord::Base.sanitize_sql(end_node.age_label)
+        sanitized_start_id = ActiveRecord::Base.sanitize_sql(["?", start_node.id])
+        sanitized_end_id = ActiveRecord::Base.sanitize_sql(["?", end_node.id])
+        # cant use sanitize_sql_like because it escapes the % and _ characters
+        # label_name = ActiveRecord::Base.sanitize_sql_like(age_label)
+
+        reject_keys = %i[id start_id end_id start_node end_node]
+        sanitized_properties =
+          self.to_h.reject { |k, _v| reject_keys.include?(k) }.reject { |_k, v| v.nil? }
+            .map { |k, v| "#{k}: #{ActiveRecord::Base.sanitize_sql(["?", v])}" }
+            .join(', ')
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
-              MATCH (from_node:#{start_node.age_label}), (to_node:#{end_node.age_label})
-              WHERE id(from_node) = #{start_node.id} and id(to_node) = #{end_node.id}
-              CREATE (from_node)-[edge#{self}]->(to_node)
+              MATCH (from_node:#{start_node_age_label}), (to_node:#{end_node_age_label})
+              WHERE id(from_node) = #{sanitized_start_id} AND id(to_node) = #{sanitized_end_id}
+              CREATE (from_node)-[edge:#{age_label} {#{sanitized_properties}}]->(to_node)
               RETURN edge
           $$) as (edge agtype);
         SQL
@@ -82,14 +97,24 @@ module ApacheAge
       # So far just properties of string type with '' around them
       def update_sql
         alias_name = age_alias || age_label.downcase
-        set_caluse =
-          age_properties.map { |k, v| v ? "#{alias_name}.#{k} = '#{v}'" : "#{alias_name}.#{k} = NULL" }.join(', ')
+        set_clause =
+          age_properties.map do |k, v|
+            if v
+              sanitized_value = ActiveRecord::Base.sanitize_sql(["?", v])
+              "#{alias_name}.#{k} = #{sanitized_value}"
+            else
+              "#{alias_name}.#{k} = NULL"
+            end
+          end.join(', ')
+
+        sanitized_id = ActiveRecord::Base.sanitize_sql(["?", id])
+
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
               MATCH ()-[#{alias_name}:#{age_label}]->()
-              WHERE id(#{alias_name}) = #{id}
-              SET #{set_caluse}
+              WHERE id(#{alias_name}) = #{sanitized_id}
+              SET #{set_clause}
               RETURN #{alias_name}
           $$) as (#{age_label} agtype);
         SQL

data/lib/apache_age/entities/entity.rb

@@ -3,14 +3,20 @@ module ApacheAge
     class Entity
       class << self
         def find_by(attributes)
-          where_clause = attributes.map { |k, v| "find.#{k} = '#{v}'" }.join(' AND ')
+          where_clause =
+            attributes
+              .map do |k, v|
+                if k == :id
+                  ActiveRecord::Base.sanitize_sql(["id(find) = ?", v])
+                else
+                  ActiveRecord::Base.sanitize_sql(["find.#{k} = ?", v])
+                end
+              end
+              .join(' AND ')
           handle_find(where_clause)
         end
 
-        def find(id)
-          where_clause = "id(find) = #{id}"
-          handle_find(where_clause)
-        end
+        def find(id) = find_by(id: id)
 
         private
 
@@ -46,19 +52,24 @@ module ApacheAge
           json_data = JSON.parse(json_string)
 
           age_label = json_data['label']
-          attribs = json_data.except('label', 'properties')
-                            .merge(json_data['properties'])
-                            .symbolize_keys
+          attribs =
+            json_data
+              .except('label', 'properties')
+              .merge(json_data['properties'])
+              .symbolize_keys
 
           "#{json_data['label'].gsub('__', '::')}".constantize.new(**attribs)
         end
 
         def find_sql(match_clause, where_clause)
+          sanitized_match_clause = ActiveRecord::Base.sanitize_sql(match_clause)
+          sanitized_where_clause = where_clause # Already sanitized in `find_by` or `find`
+
           <<-SQL
             SELECT *
             FROM cypher('#{age_graph}', $$
-                MATCH #{match_clause}
-                WHERE #{where_clause}
+                MATCH #{sanitized_match_clause}
+                WHERE #{sanitized_where_clause}
                 RETURN find
             $$) as (found agtype);
           SQL

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
 
@@ -23,11 +25,21 @@ 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
-        <<-SQL
+        sanitized_properties =
+          self
+            .to_h.reject { |k, v| k == :id }.reject { |k, v| v.nil? }
+            .map { |k, v| "#{k}: #{ActiveRecord::Base.sanitize_sql(["?", v])}" }
+            .join(', ')
+
+        <<~SQL.squish
           SELECT *
           FROM cypher('#{age_graph}', $$
-              CREATE (#{alias_name}#{self})
+              CREATE (#{alias_name}:#{age_label} {#{sanitized_properties}})
           RETURN #{alias_name}
           $$) as (#{age_label} agtype);
         SQL
@@ -35,19 +47,29 @@ module ApacheAge
 
       # So far just properties of string type with '' around them
       def update_sql
-        alias_name = age_alias || age_label.downcase
-        set_caluse =
-          age_properties.map { |k, v| v ? "#{alias_name}.#{k} = '#{v}'" : "#{alias_name}.#{k} = NULL" }.join(', ')
+        alias_name = ActiveRecord::Base.sanitize_sql_like(age_alias || age_label.downcase)
+        sanitized_set_clause = age_properties.map do |k, v|
+          if v
+            sanitized_value = ActiveRecord::Base.sanitize_sql(["?", v])
+            "#{alias_name}.#{k} = #{sanitized_value}"
+          else
+            "#{alias_name}.#{k} = NULL"
+          end
+        end.join(', ')
+
+        sanitized_id = ActiveRecord::Base.sanitize_sql(["?", id])
+
         <<-SQL
           SELECT *
           FROM cypher('#{age_graph}', $$
               MATCH (#{alias_name}:#{age_label})
-              WHERE id(#{alias_name}) = #{id}
-              SET #{set_caluse}
+              WHERE id(#{alias_name}) = #{sanitized_id}
+              SET #{sanitized_set_clause}
               RETURN #{alias_name}
           $$) as (#{age_label} agtype);
         SQL
       end
+
     end
   end
 end

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,180 @@
+# 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
+
+      # 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(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
+
+      # TODO: ensure ordering keys are present in the model
+      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(', ')
+        elsif ordering.is_a?(Symbol)
+          ordering = "find.#{ordering}"
+        elsif ordering.is_a?(String)
+          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(', ')
+        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
+      # 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
+    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.2'
 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.2
 platform: ruby
 authors:
 - Bill Tihen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-27 00:00:00.000000000 Z
+date: 2024-09-30 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,17 @@ 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/vertex.rb
+- lib/apache_age/entities/path.rb
+- lib/apache_age/entities/query_builder.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 +179,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

data/lib/apache_age/entities/vertex.rb

@@ -1,53 +0,0 @@
-# module ApacheAge
-#   module Entities
-#     module Vertex
-#       extend ActiveSupport::Concern
-
-#       included do
-#         include ActiveModel::Model
-#         include ActiveModel::Dirty
-#         include ActiveModel::Attributes
-
-#         attribute :id, :integer
-
-#         extend ApacheAge::Entities::ClassMethods
-#         include ApacheAge::Entities::CommonMethods
-#       end
-
-#       def age_type = 'vertex'
-
-#       # AgeSchema::Nodes::Company.create(company_name: 'Bedrock Quarry')
-#       # SELECT *
-#       # FROM cypher('age_schema', $$
-#       #     CREATE (company:Company {company_name: 'Bedrock Quarry'})
-#       # RETURN company
-#       # $$) as (Company agtype);
-#       def create_sql
-#         alias_name = age_alias || age_label.downcase
-#         <<-SQL
-#           SELECT *
-#           FROM cypher('#{age_graph}', $$
-#               CREATE (#{alias_name}#{self})
-#           RETURN #{alias_name}
-#           $$) as (#{age_label} agtype);
-#         SQL
-#       end
-
-#       # So far just properties of string type with '' around them
-#       def update_sql
-#         alias_name = age_alias || age_label.downcase
-#         set_caluse =
-#           age_properties.map { |k, v| v ? "#{alias_name}.#{k} = '#{v}'" : "#{alias_name}.#{k} = NULL" }.join(', ')
-#         <<-SQL
-#           SELECT *
-#           FROM cypher('#{age_graph}', $$
-#               MATCH (#{alias_name}:#{age_label})
-#               WHERE id(#{alias_name}) = #{id}
-#               SET #{set_caluse}
-#               RETURN #{alias_name}
-#           $$) as (#{age_label} agtype);
-#         SQL
-#       end
-#     end
-#   end
-# end