rails_age 0.1.0 → 0.3.0

data/lib/apache_age/entities/entity.rb

@@ -0,0 +1,69 @@
+module ApacheAge
+  module Entities
+    class Entity
+      class << self
+        def find_by(attributes)
+          where_clause = attributes.map { |k, v| "find.#{k} = '#{v}'" }.join(' AND ')
+          handle_find(where_clause)
+        end
+
+        def find(id)
+          where_clause = "id(find) = #{id}"
+          handle_find(where_clause)
+        end
+
+        private
+
+        def age_graph = 'age_schema'
+
+        def handle_find(where_clause)
+          # try to find a vertex
+          match_node = '(find)'
+          cypher_sql = find_sql(match_node, where_clause)
+          age_response = execute_find(cypher_sql)
+
+          if age_response.nil?
+            # if not a vertex try to find an edge
+            match_edge = '()-[find]->()'
+            cypher_sql = find_sql(match_edge, where_clause)
+            age_response = execute_find(cypher_sql)
+            return nil if age_response.nil?
+          end
+
+          instantiate_result(age_response)
+        end
+
+        def execute_find(cypher_sql)
+          age_result = ActiveRecord::Base.connection.execute(cypher_sql)
+          return nil if age_result.values.first.nil?
+
+          age_result
+        end
+
+        def instantiate_result(age_response)
+          age_type = age_response.values.first.first.split('::').last
+          json_string = age_response.values.first.first.split('::').first
+          json_data = JSON.parse(json_string)
+
+          age_label = json_data['label']
+          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)
+          <<-SQL
+            SELECT *
+            FROM cypher('#{age_graph}', $$
+                MATCH #{match_clause}
+                WHERE #{where_clause}
+                RETURN find
+            $$) as (found agtype);
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/apache_age/entities/vertex.rb

@@ -0,0 +1,53 @@
+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

data/lib/apache_age/types/age_type_generator.rb

@@ -0,0 +1,46 @@
+# lib/apache_age/types/age_type_generator.rb
+# Automatically generates ActiveModel::Type classes
+# Dynamically builds this (as a concrete example):
+# module ApacheAge
+#   module Types
+#     class CompanyType < ActiveModel::Type::Value
+#       def cast(value)
+#         case value
+#         when Nodes::Company
+#           value
+#         when Hash
+#           Nodes::Company.new(value)
+#         else
+#           nil
+#         end
+#       end
+#       def serialize(value)
+#         value.is_a?(Nodes::Company) ? value.attributes : nil
+#       end
+#     end
+#   end
+# end
+module ApacheAge
+  module Types
+    class AgeTypeGenerator
+      def self.create_type_for(klass)
+        Class.new(ActiveModel::Type::Value) do
+          define_method(:cast) do |value|
+            case value
+            when klass
+              value
+            when Hash
+              klass.new(value)
+            else
+              nil
+            end
+          end
+
+          define_method(:serialize) do |value|
+            value.is_a?(klass) ? value.attributes : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apache_age/validators/unique_edge_validator.rb

@@ -0,0 +1,53 @@
+# Usage (within an Age Model)
+# validates_with UniqueEdgeValidator, attributes: [:employee_role, :start_node, :end_node]
+# validates_with UniqueEdgeValidator, attributes: [:start_id, :employee_role, :end_id]
+#
+module ApacheAge
+  module Validators
+    class UniqueEdgeValidator < ActiveModel::Validator
+      def validate(record)
+        allowed_keys = record.age_properties.keys
+        attributes = options[:attributes] || []
+
+        edge_attribs =
+          attributes
+          .map { |attr| [attr, record.send(attr)] }.to_h
+          .symbolize_keys
+          .slice(*allowed_keys)
+
+        possible_end_keys = [:end_id, 'end_id', :end_node, 'end_node']
+        end_query =
+          if possible_end_keys.any? { |key| attributes.include?(key) }
+            end_query = query_node(record.end_node)
+            edge_attribs[:end_id] = end_query&.id
+            end_query
+          end
+
+        possible_start_keys = [:start_id, 'start_id', :start_node, 'start_node']
+        start_query =
+          if possible_start_keys.any? { |key| attributes.include?(key) }
+            start_query = query_node(record.start_node)
+            edge_attribs[:start_id] = start_query&.id
+            start_query
+          end
+        return if attributes.blank? && (end_query.blank? || start_query.blank?)
+
+        query = record.class.find_by(edge_attribs.compact)
+        return if query.blank? || (query.id == record.id)
+
+        record.errors.add(:base, 'attribute combination not unique')
+        record.errors.add(:end_node, 'attribute combination not unique')
+        record.errors.add(:start_node, 'attribute combination not unique')
+        attributes.each { record.errors.add(_1, 'attribute combination not unique') }
+      end
+
+      private
+
+      def query_node(node)
+        return nil if node.blank?
+
+        node.persisted? ? node.class.find(node.id) : node.class.find_by(node.age_properties)
+      end
+    end
+  end
+end

data/lib/apache_age/validators/unique_vertex_validator.rb

@@ -0,0 +1,28 @@
+# Usage (within an Age Model)
+# validates_with UniqueVertexValidator, attributes: [:first_name, :last_name, :gender]
+
+# lib/apache_age/validators/unique_vertex_validator.rb
+module ApacheAge
+  module Validators
+    class UniqueVertexValidator < ActiveModel::Validator
+      def validate(record)
+        allowed_keys = record.age_properties.keys
+        attributes = options[:attributes]
+        return if attributes.blank?
+
+        record_attribs =
+          attributes
+          .map { |attr| [attr, record.send(attr)] }
+          .to_h.symbolize_keys
+          .slice(*allowed_keys)
+        query = record.class.find_by(record_attribs)
+
+        # if no match is found or if it finds itself, it's valid
+        return if query.blank?  || (query.id == record.id)
+
+        record.errors.add(:base, 'attribute combination not unique')
+        attributes.each { record.errors.add(_1, 'attribute combination not unique') }
+      end
+    end
+  end
+end

data/lib/apache_age/validators/vertex_type_validator.rb

@@ -0,0 +1,14 @@
+module ApacheAge
+  module VertexTypeValidator
+    def vertex_attribute(attribute_name, type_symbol, klass)
+      attribute attribute_name, type_symbol
+
+      validate do
+        value = send(attribute_name)
+        unless value.is_a?(klass)
+          errors.add(attribute_name, "must be a #{klass.name}")
+        end
+      end
+    end
+  end
+end

data/lib/rails_age/version.rb

@@ -1,3 +1,3 @@
 module RailsAge
-  VERSION = "0.1.0"
+  VERSION = '0.3.0'
 end

data/lib/rails_age.rb

@@ -1,14 +1,17 @@
-require "rails_age/version"
-require "rails_age/engine"
+require 'rails_age/version'
+require 'rails_age/engine'
 
 module RailsAge
   # Your code goes here...
 end
 
 module ApacheAge
-  require "apache_age/class_methods"
-  require "apache_age/common_methods"
-  require "apache_age/edge"
-  require "apache_age/entity"
-  require "apache_age/vertex"
+  require 'apache_age/entities/class_methods'
+  require 'apache_age/entities/common_methods'
+  require 'apache_age/entities/edge'
+  require 'apache_age/entities/entity'
+  require 'apache_age/entities/vertex'
+  require 'apache_age/types/age_type_generator'
+  require 'apache_age/validators/unique_edge_validator'
+  require 'apache_age/validators/unique_vertex_validator'
 end

data/lib/tasks/install.rake

@@ -0,0 +1,210 @@
+# lib/tasks/install.rake
+# Usage: `rake apache_age:install`
+#
+namespace :apache_age do
+  desc "Copy migrations from rails_age to application and update schema"
+  task :install => :environment do
+    source_schema = File.expand_path('../../../db/schema.rb', __FILE__)
+    destination_schema = File.expand_path("#{Rails.root}/db/schema.rb", __FILE__)
+
+    # ensure we have a schema file
+    run_migrations
+
+    # copy our migrations to the application
+    last_migration_version = copy_migrations
+
+    # check if the schema is blank (NEW) before running migrations!
+    is_schema_blank = blank_schema?(destination_schema)
+    puts "Schema is blank: #{is_schema_blank}"
+
+    # run our new migrations
+    run_migrations
+
+    # adjust the schema file (unfortunately rails mangles the schema file)
+    if is_schema_blank
+      puts "creating new schema..."
+      create_new_schema(last_migration_version, destination_schema, source_schema)
+    else
+      puts "updating existing schema..."
+      update_existing_schema(last_migration_version, destination_schema, source_schema)
+    end
+
+    update_database_yml
+  end
+
+  def copy_migrations
+    migration_version = nil
+
+    source = File.expand_path('../../../db/migrate', __FILE__)
+    destination = File.expand_path("#{Rails.root}/db/migrate", __FILE__)
+
+    FileUtils.mkdir_p(destination) unless File.exist?(destination)
+    existing_migrations =
+      Dir.glob("#{destination}/*.rb").map { |file| File.basename(file).sub(/^\d+/, '') }
+
+    Dir.glob("#{source}/*.rb").each do |file|
+      filename = File.basename(file)
+      test_name = filename.sub(/^\d+/, '')
+
+      if existing_migrations.include?(test_name)
+        puts "Skipping #{filename}, it already exists"
+      else
+        migration_version = Time.now.utc.strftime("%Y_%m_%d_%H%M%S")
+        file_version = migration_version.delete('_')
+        new_filename = filename.sub(/^\d+/, file_version)
+        destination_file = File.join(destination, new_filename)
+        FileUtils.cp(file, destination_file)
+        puts "Copied #{filename} to #{destination} as #{new_filename}"
+      end
+    end
+    migration_version
+  end
+
+  def blank_schema?(destination_schema)
+    return false unless File.exist?(destination_schema)
+
+    content = File.read(destination_schema)
+    content.include?('define(version: 0)') &&
+      content.include?('enable_extension "plpgsql"') &&
+      content.scan(/enable_extension/).size == 1
+  end
+
+  def run_migrations
+    puts "Running migrations..."
+    Rake::Task["db:migrate"].invoke
+  end
+
+  def extract_rails_version(destination_schema)
+    if File.exist?(destination_schema)
+      content = File.read(destination_schema)
+      version_match = content.match(/ActiveRecord::Schema\[(.*?)\]/)
+      return version_match[1] if version_match
+    else
+      full_version = Rails.version
+      primary_secondary_version = full_version.split('.')[0..1].join('.')
+      primary_secondary_version
+    end
+  end
+
+  def create_new_schema(last_migration_version, destination_schema, source_schema)
+    if File.exist?(source_schema) && File.exist?(destination_schema)
+      rails_version = extract_rails_version(destination_schema)
+      source_content = File.read(source_schema)
+
+      # ensure we use the Rails version from the destination schema
+      source_content.gsub!(
+        /ActiveRecord::Schema\[\d+\.\d+\]/,
+        "ActiveRecord::Schema[#{rails_version}]"
+      )
+      # ensure we use the last migration version (not the source schema version)
+      source_content.gsub!(
+        /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
+        "define(version: #{last_migration_version}) do"
+      )
+
+      File.write(destination_schema, source_content)
+      puts "Created new schema in #{destination_schema} with necessary extensions and configurations."
+    else
+      puts "local db/schema.rb file not found."
+    end
+  end
+
+  def update_existing_schema(last_migration_version, destination_schema, source_schema)
+    if File.exist?(source_schema) && File.exist?(destination_schema)
+      rails_version = extract_rails_version(destination_schema)
+      source_content = File.read(source_schema)
+      new_content =
+        source_content.gsub(
+          /.*ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n|\nend$/,
+          ''
+        )
+
+      destination_content = File.read(destination_schema)
+
+      # Remove unwanted schema statements
+      destination_content.gsub!(%r{^.*?# These are extensions that must be enabled in order to support this database.*?\n}, '')
+
+      destination_content.gsub!(%r{^.*?create_schema "ag_catalog".*?\n}, '')
+      destination_content.gsub!(%r{^.*?create_schema "age_schema".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "age".*?\n}, '')
+      destination_content.gsub!(%r{^.*?enable_extension "plpgsql".*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regnamespace' for column 'namespace'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'regclass' for column 'relation'.*?\n}, '')
+      destination_content.gsub!(%r{^.*?#   Unknown type 'graphid' for column 'id'.*?\n}, '')
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_edge" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(
+        %r{^.*?# Could not dump table "_ag_label_vertex" because of following StandardError.*?\n}, ''
+      )
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_graph" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?# Could not dump table "ag_label" because of following StandardError.*?\n}, '')
+      destination_content.gsub!(%r{^.*?add_foreign_key "ag_label", "ag_graph".*?\n}, '')
+
+      # add new wanted schema statements (at the top of the schema)
+      destination_content.sub!(
+        %r{(ActiveRecord::Schema\[\d+\.\d+\]\.define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do\n)},
+        "\\1#{new_content}\n"
+      )
+
+      existing_version = destination_content.match(/define\(version: (\d{4}(?:_\d{2}){2}(?:_\d{6})?)\)/)[1].gsub('_', '')
+      current_version = last_migration_version ? last_migration_version.gsub('_', '') : existing_version
+
+      # ensure we use the last migration version (not the source schema version)
+      if current_version.to_i > existing_version.to_i
+        destination_content.gsub!(
+          /define\(version: \d{4}(?:_\d{2}){2}(?:_\d{6})?\) do/,
+          "define(version: #{last_migration_version}) do"
+        )
+      end
+
+      File.write(destination_schema, destination_content)
+      puts "Updated #{destination_schema} with necessary extensions and configurations."
+    else
+      puts "local db/schema.rb file not found."
+    end
+  end
+
+  def update_database_yml
+    db_config_file = File.expand_path("#{Rails.root}/config/database.yml", __FILE__)
+
+    # Read the file
+    lines = File.readlines(db_config_file)
+
+    # any uncommented "schema_search_path:" lines?
+    path_index = lines.find_index { |line| !line.include?('#') && line.include?('schema_search_path:') }
+    default_start_index = lines.index { |line| line.strip.start_with?('default:') }
+
+    # when it finds an existing schema_search_path, it updates it
+    if path_index && lines[path_index].include?('ag_catalog,age_schema')
+      puts "schema_search_path already set to ag_catalog,age_schema nothing to do."
+      return
+    elsif path_index
+      key, val = lines[path_index].split(': ')
+      # remove any unwanted characters
+      val = val.gsub(/[ "\s\"\"'\n]/, '')
+      lines[path_index] = "#{key}: ag_catalog,age_schema,#{val}\n"
+      puts "add ag_catalog,age_schema to schema_search_path"
+    elsif default_start_index
+      puts "add ag_catalog,age_schema,public to schema_search_path in the default section of database.yml"
+      sections_index = lines.map.with_index { |line, index| index if !line.start_with?(' ') }.compact.sort
+
+      # find the start of the default section
+      next_section_in_list = sections_index.index(default_start_index) + 1
+
+      # find the end of the default section (before the next section starts)
+      path_insert_index = sections_index[next_section_in_list]
+
+      lines.insert(path_insert_index, "  schema_search_path: ag_catalog,age_schema,public\n")
+    else
+      puts "didn't find a default section in database.yml, please add the following line:"
+      puts "  schema_search_path: ag_catalog,age_schema,public"
+      puts "to the apprpriate section of your database.yml"
+    end
+
+    # Write the modified lines back to the file
+    File.open(db_config_file, 'w') { |file| file.write(lines.join) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_age
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Bill Tihen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-21 00:00:00.000000000 Z
+date: 2024-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,29 +16,36 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.3.2
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.3.2
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Apache AGE plugin for Rails 7.1
+        version: '6.0'
+description: This plugin integrates Apache AGE for PostgreSQL with Rails 7.x, providing
+  tools and helpers for working with graph databases within a Rails application.
 email:
 - btihen@gmail.com
 executables: []
@@ -58,23 +65,28 @@ files:
 - app/models/rails_age/application_record.rb
 - app/views/layouts/rails_age/application.html.erb
 - config/routes.rb
-- db/migrate/20240521062349_configure_apache_age.rb
+- db/migrate/20240521062349_add_apache_age.rb
 - db/schema.rb
-- lib/apache_age/class_methods.rb
-- lib/apache_age/common_methods.rb
-- lib/apache_age/edge.rb
-- lib/apache_age/entity.rb
-- lib/apache_age/vertex.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/vertex.rb
+- lib/apache_age/types/age_type_generator.rb
+- lib/apache_age/validators/unique_edge_validator.rb
+- lib/apache_age/validators/unique_vertex_validator.rb
+- lib/apache_age/validators/vertex_type_validator.rb
 - lib/rails_age.rb
 - lib/rails_age/engine.rb
 - lib/rails_age/version.rb
+- lib/tasks/install.rake
 - lib/tasks/rails_age_tasks.rake
 homepage: https://github.com/marpori/rails_age
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/marpori/rails_age
-  source_code_uri: https://github.com/marpori/rails_age
+  source_code_uri: https://github.com/marpori/rails_age/blob/main
   changelog_uri: https://github.com/marpori/rails_age/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
@@ -84,15 +96,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
-summary: Apache AGE plugin for Rails 7.1
+summary: Apache AGE plugin for Rails 7.x
 test_files: []