rails_age 0.5.3 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd10883497fc245765a9e8313265e4d06c7a602a2f83cad592ecb5a951ab488d
-  data.tar.gz: ce03c6dc4535e2a54dddc9f2b9df8e4b413c6aeb690ee00138c4120fe1d72ce1
+  metadata.gz: 053d21a51d2e91cb61ea1678d2d84c05ac4a1a84a643334c4993df9f6ca9c3c0
+  data.tar.gz: 57f945d6055d9dca60414321e3f39dd09abfdb1a8f2a3a5fec0b4c5e3e9ee656
 SHA512:
-  metadata.gz: dcb00b35abd3a931c95ffce304c079eee2d1ba1b09ee3aa17f9c9150f4bc3b55276e7670cf3925e4ae484a117bef66bddc0242efc0cbc8295da03538ae628805
-  data.tar.gz: d6ac9aaa1ba0b04c9a48ed320e53a4de65a74e6cb6574f42c407b0c1124fafc650def68df4c41beaad27607b6f1fa22a7962518108c2fc39cd7c0e95f76d8c09
+  metadata.gz: 017c585f995749dad85f341b41a01d2f94b0cc03fac6240d63e4755e8ab0c7148969793fbe9c308f13c0ea94d35eee3fb231516eb775817a53bef003843d41e4
+  data.tar.gz: 83760cc109544589665b7297776538f48f4ac0c14273455957e714ff6d9614e1a4e8d8ba862e39b8735a5f1e5a1f9c8ca5e429f1823aee8b98e38bad3dded2de

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Change Log
 
-## VERSION 0.6.2 - 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.1 - 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.0 - 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,18 +35,29 @@ breaking change?: namespaces (by default) will use their own schema? (add to dat
 
 - **multiple AGE Schema**
 
-## VERSION 0.5.4 - 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
+
+**Document showing errors**
+
+**breaking changes**: update naming
+  * renamed `Entities::Vertex` module to `Entities::Node`
+  * renamed `UniqueVertex` to `UniqueNode`
+  * 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
 
 ## VERSION 0.5.3 - 2024-06-23
 

data/README.md

@@ -32,7 +32,7 @@ rails generate apache_age:scaffold_node Person first_name last_name
 rails generate apache_age:scaffold_edge HasJob employee_role start_date:date
 ```
 
-Ideally, edit the HasJob class so that `start_node` would use a type `:person` and the `end_node` uses at type `:company`
+Ideally, edit the HasJob class so that `start_node` would use a type `:person` and the `end_node` uses at type `:company` - this is not yet supported by the generator, but easy to do manually as shown below.  (The problem is that I havent been able to figure out how load all the rails types in the testing environment).
 
 ie:
 ```ruby
@@ -41,8 +41,8 @@ class HasJob
   include ApacheAge::Entities::Edge
 
   attribute :employee_role, :string
-  attribute :start_node, :person # instead of `:node`
-  attribute :end_node, :company # instead of `:node`
+  attribute :start_node, :person
+  attribute :end_node, :company
 
   validates :employee_role, presence: true
   validate :validate_unique_edge
@@ -147,23 +147,259 @@ 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
 

data/config/initializers/types.rb

@@ -1,20 +1,20 @@
 # config/initializers/types.rb
 
-require 'apache_age/types/age_type_factory'
+require 'apache_age/types/factory'
 # USAGE (with edges or nodes) - ie:
-# require_dependency 'nodes/company'
+# require_dependency 'company'
 # ActiveModel::Type.register(
-#   :company, ApacheAge::Types::AgeTypeFactory.create_type_for(Nodes::Company)
+#   :company, ApacheAge::Types::Factory.type_for(Company)
 # )
 
 Rails.application.config.to_prepare do
   # Register AGE types
   require_dependency 'apache_age/node'
   ActiveModel::Type.register(
-    :node, ApacheAge::Types::AgeTypeFactory.create_type_for(ApacheAge::Node)
+    :node, ApacheAge::Types::Factory.type_for(ApacheAge::Node)
   )
   require_dependency 'apache_age/edge'
   ActiveModel::Type.register(
-    :edge, ApacheAge::Types::AgeTypeFactory.create_type_for(ApacheAge::Edge)
+    :edge, ApacheAge::Types::Factory.type_for(ApacheAge::Edge)
   )
 end

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

@@ -1,12 +1,14 @@
 module ApacheAge
   module Entities
-    module Vertex
+    module Node
       extend ActiveSupport::Concern
 
       included do
         include ActiveModel::Model
         include ActiveModel::Dirty
         include ActiveModel::Attributes
+        include ActiveModel::Validations
+        include ActiveModel::Validations::Callbacks
 
         attribute :id, :integer