activecypher 0.6.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6586ae8148cfb3d3f1e6ce182fc556a36790d84d0559e95455a57e1534afe4b2
-  data.tar.gz: 634ef2b25e6ba61bb38baf955c30e48fca9c9c6c71e885c5e5a5174d2105a947
+  metadata.gz: e5ccd00478564eeb903b76a423867e21973268d6c23af232de7329abe94263d5
+  data.tar.gz: a6e74f587ad7c543123840d5f44440efca909a44efa0a59be5b8ce15d8d39f0f
 SHA512:
-  metadata.gz: 9ea71245757351c9e2d503078721ee431a1525faa84ea83634ff9d0ed9b2ad486d7001941ef1de608ec86cf0141676bd9a1bbe6ebe1ed215094203a1efe98f01
-  data.tar.gz: c445c1430312284afd41a91dd8b25478066ce5f93284f249cdedd5256ed62eb02fa09161eda7ff3298d0f33c6a233e858bc75b1f780153ea218096c3ec911036
+  metadata.gz: 1b90a82d07ffc1504ddf9d07fcd88a80d3371d32ed09eb8f799c4d228958e090522a44cac2abd6bdf661983fda43ce95b898fe440f8e76c0427621f55ad342a0
+  data.tar.gz: bd848d6485fdc502673f88ad3ea3dd776d486a1e11cf501592994efba1347cb799b28af0b6f06e5a29daf3a60c79c39072181fb03d36f0938df5ed52699bd881

data/lib/active_cypher/associations.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-require 'active_support/core_ext/string/inflections' # for camelize, singularize etc.
-
 module ActiveCypher
   # Module to handle association definitions (has_many, belongs_to, etc.)
   # for ActiveCypher models.

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -1,11 +1,22 @@
 # frozen_string_literal: true
 
+require 'active_cypher/schema/catalog'
+
 module ActiveCypher
   module ConnectionAdapters
     class MemgraphAdapter < AbstractBoltAdapter
       # Register this adapter with the registry
       Registry.register('memgraph', self)
 
+      def vendor = :memgraph
+
+      def schema_catalog
+        rows = run('SHOW SCHEMA')
+        parse_schema(rows)
+      rescue StandardError
+        introspect_fallback
+      end
+
       # Use id() for Memgraph instead of elementId()
       ID_FUNCTION = 'id'
 
@@ -58,6 +69,39 @@ module ActiveCypher
 
       protected
 
+      def parse_schema(rows)
+        nodes = []
+        edges = []
+        idx = []
+        cons = []
+
+        rows.each do |row|
+          case row['type']
+          when 'NODE'
+            nodes << Schema::NodeTypeDef.new(row['label'], row['properties'], row['primaryKey'])
+          when 'EDGE'
+            edges << Schema::EdgeTypeDef.new(row['label'], row['from'], row['to'], row['properties'])
+          when 'INDEX'
+            idx << Schema::IndexDef.new(row['name'], :node, row['label'], row['properties'], row['unique'], nil)
+          when 'CONSTRAINT'
+            cons << Schema::ConstraintDef.new(row['name'], row['label'], row['properties'], :unique)
+          end
+        end
+
+        Schema::Catalog.new(indexes: idx, constraints: cons, node_types: nodes, edge_types: edges)
+      end
+
+      def introspect_fallback
+        labels = run('MATCH (n) RETURN DISTINCT labels(n) AS lbl').flat_map { |r| r['lbl'] }
+
+        nodes = labels.map do |lbl|
+          props = run("MATCH (n:`#{lbl}`) WITH n LIMIT 100 UNWIND keys(n) AS k RETURN DISTINCT k").map { |r| r['k'] }
+          Schema::NodeTypeDef.new(lbl, props, nil)
+        end
+
+        Schema::Catalog.new(indexes: [], constraints: [], node_types: nodes, edge_types: [])
+      end
+
       def protocol_handler_class = ProtocolHandler
 
       def validate_connection

data/lib/active_cypher/connection_adapters/neo4j_adapter.rb

@@ -1,10 +1,44 @@
 # frozen_string_literal: true
 
+require 'active_cypher/schema/catalog'
+
 module ActiveCypher
   module ConnectionAdapters
     class Neo4jAdapter < AbstractBoltAdapter
       Registry.register('neo4j', self)
 
+      def vendor = :neo4j
+
+      def schema_catalog
+        idx_rows = run('SHOW INDEXES')
+        con_rows = run('SHOW CONSTRAINTS')
+
+        idx_defs = idx_rows.map do |r|
+          Schema::IndexDef.new(
+            r['name'],
+            r['entityType'].downcase.to_sym,
+            r['labelsOrTypes'].first,
+            r['properties'],
+            r['uniqueness'] == 'UNIQUE',
+            r['type'] == 'VECTOR' ? r['options'] : nil
+          )
+        end
+
+        con_defs = con_rows.map do |r|
+          Schema::ConstraintDef.new(
+            r['name'],
+            r['labelsOrTypes'].first,
+            r['properties'],
+            r['type'].split('_').first.downcase.to_sym
+          )
+        end
+
+        Schema::Catalog.new(indexes: idx_defs, constraints: con_defs,
+                            node_types: [], edge_types: [])
+      rescue StandardError
+        Schema::Catalog.new(indexes: [], constraints: [], node_types: [], edge_types: [])
+      end
+
       # Use elementId() for Neo4j
       ID_FUNCTION = 'elementId'
 

data/lib/active_cypher/generators/migration_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails/generators/named_base'
+
+module ActiveCypher
+  module Generators
+    class MigrationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('templates', __dir__)
+
+      def create_migration_file
+        timestamp = Time.now.utc.strftime('%Y%m%d%H%M%S')
+        dir = File.join('graphdb', 'migrate')
+        FileUtils.mkdir_p(dir)
+        template 'migration.rb.erb', File.join(dir, "#{timestamp}_#{file_name}.rb")
+      end
+    end
+  end
+end

data/lib/active_cypher/generators/templates/migration.rb.erb

@@ -0,0 +1,5 @@
+class <%= name.camelize %> < ActiveCypher::Migration
+  up do
+    # add operations or incantation here
+  end
+end

data/lib/active_cypher/generators/templates/relationship.rb.erb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class <%= class_name %> < ApplicationGraphRelationship
-  from_class :<%= options[:from] %>
-  to_class   :<%= options[:to] %>
-  type       :<%= relationship_type %>
+  from_class '<%= options[:from] %>'
+  to_class   '<%= options[:to] %>'
+  type       '<%= relationship_type %>'
 <% if attributes.any? -%>
 <% attributes.each do |attr| -%>
   attribute :<%= attr.name %>, :<%= attr.type || "string" %>

data/lib/active_cypher/instrumentation.rb

@@ -132,7 +132,7 @@ module ActiveCypher
     # @param key [String, Symbol] The key to check
     # @return [Boolean] True if the key contains sensitive information
     def sensitive_key?(key)
-      return true if key.to_s.match?(/\b(password|token|secret|credential|key)\b/i)
+      return true if key.to_s.match?(/(^|[\-_])(?:password|token|secret|credential|key)($|[\-_])/i)
 
       # Check against Rails filter parameters if available
       if defined?(Rails) && Rails.application

data/lib/active_cypher/migration.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  # Base class for GraphDB migrations.
+  # Provides a small DSL for defining index and constraint operations.
+  class Migration
+    class << self
+      attr_reader :up_block
+
+      # Define the migration steps.
+      def up(&block)
+        @up_block = block if block_given?
+      end
+    end
+
+    attr_reader :connection, :operations
+
+    def initialize(connection = ActiveCypher::Base.connection)
+      @connection = connection
+      @operations = []
+    end
+
+    # Execute the migration.
+    def run
+      instance_eval(&self.class.up_block) if self.class.up_block
+      execute_operations
+    end
+
+    # DSL ---------------------------------------------------------------
+
+    def create_node_index(label, *props, unique: false, if_not_exists: true, name: nil)
+      props_clause = props.map { |p| "n.#{p}" }.join(', ')
+      cypher = +'CREATE '
+      cypher << 'UNIQUE ' if unique
+      cypher << 'INDEX'
+      cypher << " #{name}" if name
+      cypher << ' IF NOT EXISTS' if if_not_exists
+      cypher << " FOR (n:#{label}) ON (#{props_clause})"
+      operations << cypher
+    end
+
+    def create_rel_index(rel_type, *props, if_not_exists: true, name: nil)
+      props_clause = props.map { |p| "r.#{p}" }.join(', ')
+      cypher = +'CREATE INDEX'
+      cypher << " #{name}" if name
+      cypher << ' IF NOT EXISTS' if if_not_exists
+      cypher << " FOR ()-[r:#{rel_type}]-() ON (#{props_clause})"
+      operations << cypher
+    end
+
+    def create_uniqueness_constraint(label, *props, if_not_exists: true, name: nil)
+      props_clause = props.map { |p| "n.#{p}" }.join(', ')
+      cypher = +'CREATE CONSTRAINT'
+      cypher << " #{name}" if name
+      cypher << ' IF NOT EXISTS' if if_not_exists
+      cypher << " FOR (n:#{label}) REQUIRE (#{props_clause}) IS UNIQUE"
+      operations << cypher
+    end
+
+    def execute(cypher_string)
+      operations << cypher_string.strip
+    end
+
+    private
+
+    def execute_operations
+      tx = connection.begin_transaction if connection.respond_to?(:begin_transaction)
+      operations.each do |cypher|
+        if tx
+          tx.run(cypher)
+        else
+          connection.execute_cypher(cypher)
+        end
+      end
+      connection.commit_transaction(tx) if tx
+    rescue StandardError
+      connection.rollback_transaction(tx) if tx
+      raise
+    end
+  end
+end

data/lib/active_cypher/migrator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  # Runs pending graph database migrations.
+  class Migrator
+    MIGRATE_DIR = File.join('graphdb', 'migrate')
+
+    def initialize(connection = ActiveCypher::Base.connection)
+      @connection = connection
+    end
+
+    def migrate!
+      ensure_schema_migration_constraint
+      applied = existing_versions
+
+      migration_files.each do |file|
+        version = File.basename(file)[0, 14]
+        next if applied.include?(version)
+
+        require file
+        class_name = File.basename(file, '.rb').split('_', 2).last.camelize
+        klass = Object.const_get(class_name)
+        klass.new(@connection).run
+
+        @connection.execute_cypher(<<~CYPHER)
+          CREATE (:SchemaMigration { version: '#{version}', executed_at: datetime() })
+        CYPHER
+      end
+    end
+
+    def status
+      ensure_schema_migration_constraint
+      applied = existing_versions
+      migration_files.map do |file|
+        version = File.basename(file)[0, 14]
+        {
+          status: (applied.include?(version) ? 'up' : 'down'),
+          version: version,
+          name: File.basename(file)
+        }
+      end
+    end
+
+    private
+
+    def adapter_dir
+      name = @connection.class.name.demodulize.sub('Adapter', '').downcase
+      File.join('graphdb', name)
+    end
+
+    def migration_dirs
+      dirs = [MIGRATE_DIR, adapter_dir]
+      extra = @connection.config[:migrations_paths]
+      dirs.concat(Array(extra)) if extra
+      dirs
+    end
+
+    def migration_files
+      migration_dirs.flat_map do |dir|
+        Dir[File.expand_path(File.join(dir, '*.rb'), Dir.pwd)]
+      end.sort
+    end
+
+    def existing_versions
+      @connection.execute_cypher('MATCH (m:SchemaMigration) RETURN m.version AS version')
+                 .map { |r| r[:version].to_s }
+    rescue StandardError
+      []
+    end
+
+    def ensure_schema_migration_constraint
+      @connection.execute_cypher(<<~CYPHER)
+        CREATE CONSTRAINT graph_schema_migration IF NOT EXISTS
+        FOR (m:SchemaMigration)
+        REQUIRE m.version IS UNIQUE
+      CYPHER
+    end
+  end
+end

data/lib/active_cypher/railtie.rb

@@ -64,6 +64,12 @@ module ActiveCypher
       require 'active_cypher/generators/install_generator'
       require 'active_cypher/generators/node_generator'
       require 'active_cypher/generators/relationship_generator'
+      require 'active_cypher/generators/migration_generator'
+    end
+
+    rake_tasks do
+      load File.expand_path('../tasks/graphdb_migrate.rake', __dir__)
+      load File.expand_path('../tasks/graphdb_schema.rake', __dir__)
     end
   end
 end

data/lib/active_cypher/schema/catalog.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module Schema
+    IndexDef      = Data.define(:name, :element, :label, :props, :unique, :vector_opts)
+    ConstraintDef = Data.define(:name, :label, :props, :kind)
+    NodeTypeDef   = Data.define(:label, :props, :primary_key)
+    EdgeTypeDef   = Data.define(:type, :from, :to, :props)
+
+    Catalog = Data.define(:indexes, :constraints, :node_types, :edge_types) do
+      def empty?
+        indexes.empty? && constraints.empty? && node_types.empty? && edge_types.empty?
+      end
+    end
+  end
+end

data/lib/active_cypher/schema/dumper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'optparse'
+
+module ActiveCypher
+  module Schema
+    # Dumps the graph schema to a Cypher script
+    class Dumper
+      DEFAULT_PATH = 'graphdb'
+
+      def initialize(connection = ActiveCypher::Base.connection, base_dir: Dir.pwd)
+        @connection = connection
+        @base_dir   = base_dir
+      end
+
+      def dump_to_string
+        cat = @connection.schema_catalog
+        cat = catalog_from_migrations if cat.respond_to?(:empty?) && cat.empty?
+        Writer::Cypher.new(cat, @connection.vendor).to_s
+      end
+
+      def dump_to_file(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, dump_to_string)
+        path
+      end
+
+      def self.run_from_cli(argv = ARGV)
+        opts = { stdout: false, connection: :primary }
+        OptionParser.new do |o|
+          o.on('--stdout') { opts[:stdout] = true }
+          o.on('--connection=NAME') { |v| opts[:connection] = v.to_sym }
+        end.parse!(argv)
+
+        pool = ActiveCypher::Base.connection_handler.pool(opts[:connection])
+        raise "Unknown connection: #{opts[:connection]}" unless pool
+
+        dumper = new(pool.connection)
+        file = output_file(opts[:connection])
+        if opts[:stdout]
+          puts dumper.dump_to_string
+        else
+          dumper.dump_to_file(file)
+          puts "Written #{file}"
+        end
+      end
+
+      def self.output_file(conn)
+        case conn.to_sym
+        when :primary
+          File.join(DEFAULT_PATH, 'schema.cypher')
+        when :analytics
+          File.join(DEFAULT_PATH, 'schema.analytics.cypher')
+        else
+          File.join(DEFAULT_PATH, "schema.#{conn}.cypher")
+        end
+      end
+
+      private
+
+      def catalog_from_migrations
+        idx = []
+        cons = []
+        Dir[File.join(@base_dir, 'graphdb', 'migrate', '*.rb')].each do |file|
+          require file
+          class_name = File.basename(file, '.rb').split('_', 2).last.camelize
+          klass = Object.const_get(class_name)
+          mig = klass.new(@connection)
+          mig.instance_eval(&klass.up_block) if klass.respond_to?(:up_block) && klass.up_block
+          mig.operations.each do |cy|
+            if cy =~ /CREATE\s+(UNIQUE\s+)?INDEX/i
+              unique = !Regexp.last_match(1).nil?
+              name = cy[/CREATE\s+(?:UNIQUE\s+)?INDEX\s+(\w+)/i, 1] || 'idx'
+              label = cy[/\(n:`?([^:`)]+)`?\)/, 1] || 'Unknown'
+              props = cy[/ON \(([^)]+)\)/i, 1].to_s.split(',').map { |p| p.strip.sub(/^n\./, '').sub(/^r\./, '') }
+              elem = cy.include?('-[r:') ? :relationship : :node
+              idx << IndexDef.new(name, elem, label, props, unique, nil)
+            elsif cy =~ /CREATE\s+CONSTRAINT/i
+              name = cy[/CREATE\s+CONSTRAINT\s+(\w+)/i, 1] || 'constraint'
+              label = cy[/\(n:`?([^:`)]+)`?\)/, 1] || 'Unknown'
+              if cy =~ /UNIQUE/i
+                props = cy[/\(([^)]+)\)/, 1].to_s.split(',').map { |p| p.strip.sub(/^n\./, '') }
+                kind = :unique
+              else
+                prop = cy[/n\.(\w+)\s+IS NOT NULL/i, 1]
+                props = [prop].compact
+                kind = :exists
+              end
+              cons << ConstraintDef.new(name, label, props, kind)
+            end
+          end
+        end
+        Catalog.new(indexes: idx, constraints: cons, node_types: [], edge_types: [])
+      end
+    end
+  end
+end

data/lib/active_cypher/schema/writer/cypher.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module Schema
+    module Writer
+      class Cypher
+        def initialize(catalog, vendor)
+          @catalog = catalog
+          @vendor  = vendor
+        end
+
+        def to_s
+          sections = []
+          sections << constraint_lines(@catalog.constraints)
+          sections << index_lines(@catalog.indexes.select { |i| i.element == :node }, :node)
+          sections << index_lines(@catalog.indexes.select { |i| i.element == :relationship }, :relationship)
+          if @vendor == :memgraph
+            sections << node_type_lines(@catalog.node_types)
+            sections << edge_type_lines(@catalog.edge_types)
+          end
+          sections.reject(&:empty?).join("\n")
+        end
+
+        private
+
+        def constraint_lines(list)
+          list.sort_by(&:name).map do |c|
+            props = c.props.map { |p| "n.#{p}" }.join(', ')
+            case c.kind
+            when :unique
+              "CREATE CONSTRAINT #{c.name} FOR (n:`#{c.label}`) REQUIRE (#{props}) IS UNIQUE"
+            when :exists
+              "CREATE CONSTRAINT #{c.name} FOR (n:`#{c.label}`) REQUIRE n.#{c.props.first} IS NOT NULL"
+            else
+              "-- UNKNOWN CONSTRAINT #{c.name}"
+            end
+          end.join("\n")
+        end
+
+        def index_lines(list, element)
+          list.sort_by(&:name).map do |i|
+            if @vendor == :memgraph && i.vector_opts
+              "-- NOT-SUPPORTED ON MEMGRAPH 3.2: Vector index #{i.name}"
+            else
+              var = element == :node ? 'n' : 'r'
+              target = element == :node ? "(#{var}:`#{i.label}`)" : "()-[#{var}:`#{i.label}`]-()"
+              props = i.props.map { |p| "#{var}.#{p}" }.join(', ')
+              line = +'CREATE '
+              line << 'UNIQUE ' if i.unique
+              line << "INDEX #{i.name} FOR #{target} ON (#{props})"
+              if i.vector_opts && @vendor == :neo4j
+                opts = i.vector_opts.map { |k, v| "#{k}: #{v}" }.join(', ')
+                line << " OPTIONS { #{opts} }"
+              end
+              line
+            end
+          end.join("\n")
+        end
+
+        def node_type_lines(list)
+          list.sort_by(&:label).map do |nt|
+            props = nt.props.join(', ')
+            pk = nt.primary_key ? " PRIMARY KEY #{nt.primary_key}" : ''
+            "CREATE NODE TYPE #{nt.label}#{pk} PROPERTIES #{props}"
+          end.join("\n")
+        end
+
+        def edge_type_lines(list)
+          list.sort_by(&:type).map do |et|
+            props = et.props.join(', ')
+            "CREATE EDGE TYPE #{et.type} FROM #{et.from} TO #{et.to} PROPERTIES #{props}"
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.6.3'
+  VERSION = '0.7.1'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/cyrel/node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string/inflections'
-
 module Cyrel
   # The base class for building Cypher queries.
   class Node

data/lib/tasks/graphdb_migrate.rake

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+namespace :graphdb do
+  desc 'Run graph database migrations'
+  task migrate: :environment do
+    ActiveCypher::Migrator.new.migrate!
+    puts 'GraphDB migrations complete'
+  end
+
+  desc 'Show graph database migration status'
+  task status: :environment do
+    ActiveCypher::Migrator.new.status.each do |m|
+      puts format('%-4s %s %s', m[:status], m[:version], m[:name])
+    end
+  end
+end

data/lib/tasks/graphdb_schema.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :graphdb do
+  namespace :schema do
+    desc 'Dump current graph schema to graphdb/schema*.cypher'
+    task dump: :environment do
+      ActiveCypher::Schema::Dumper.run_from_cli
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -132,15 +132,19 @@ files:
 - lib/active_cypher/fixtures/registry.rb
 - lib/active_cypher/fixtures/rel_builder.rb
 - lib/active_cypher/generators/install_generator.rb
+- lib/active_cypher/generators/migration_generator.rb
 - lib/active_cypher/generators/node_generator.rb
 - lib/active_cypher/generators/relationship_generator.rb
 - lib/active_cypher/generators/templates/application_graph_node.rb
 - lib/active_cypher/generators/templates/application_graph_relationship.rb
 - lib/active_cypher/generators/templates/cypher_databases.yml
+- lib/active_cypher/generators/templates/migration.rb.erb
 - lib/active_cypher/generators/templates/node.rb.erb
 - lib/active_cypher/generators/templates/relationship.rb.erb
 - lib/active_cypher/instrumentation.rb
 - lib/active_cypher/logging.rb
+- lib/active_cypher/migration.rb
+- lib/active_cypher/migrator.rb
 - lib/active_cypher/model/abstract.rb
 - lib/active_cypher/model/attributes.rb
 - lib/active_cypher/model/callbacks.rb
@@ -158,6 +162,9 @@ files:
 - lib/active_cypher/relation.rb
 - lib/active_cypher/relationship.rb
 - lib/active_cypher/runtime_registry.rb
+- lib/active_cypher/schema/catalog.rb
+- lib/active_cypher/schema/dumper.rb
+- lib/active_cypher/schema/writer/cypher.rb
 - lib/active_cypher/scoping.rb
 - lib/active_cypher/utils/logger.rb
 - lib/active_cypher/version.rb
@@ -205,6 +212,8 @@ files:
 - lib/cyrel/return_only.rb
 - lib/cyrel/types/hash_type.rb
 - lib/cyrel/types/symbol_type.rb
+- lib/tasks/graphdb_migrate.rake
+- lib/tasks/graphdb_schema.rake
 - sig/activecypher.rbs
 homepage: https://github.com/seuros/activecypher
 licenses: