activecypher 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d9c41285d4f1a84779d72a479b329e6c397d4630473d369691456e35f4337fc
-  data.tar.gz: 1673192a6552da378dfd625114f8bc8eee8e973eb17583d802de8fcbcd609c70
+  metadata.gz: 001236241c04680c15946488d5f7e915100342dad161abe512f5e1d1f47bb84f
+  data.tar.gz: e6cbcd8f09b83bdfbb90830aded7a39ad7afc91c7aef03704d7dba8a55bcc12d
 SHA512:
-  metadata.gz: 6feecb3dbad832f8f8253f64b3ccb030d2fe99194824d57bf5087db7caee2e335a4e7a6b21646e7ba098250812f3b05d4a5c812b7d8b0cc5b8e93e23f1c56ebb
-  data.tar.gz: f389ab164a37e002523c55e050abc1bee7c20df6e5c6e11e311f2a5f6200a33d27ac4512f676f36eebd155ce2f71f21c87a08f9431f0fe641d1051f09aee21be
+  metadata.gz: 2e4a8e7f74da14f8013152a7a4adebfbc0cab73be88919a3ae14994f2fbeaab1599832659fd31b6b4f7a6c5f14de14439aad29e913b17981bc62b2f46fdf824d
+  data.tar.gz: b856e47065693eaab0152246a2aa7ee475706ef9c0b54c61d8e3746438971c670cb0157087d6f4456ee3e5757619e114d796880d5213d72c62048228007bc9ba

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/bolt/connection.rb

@@ -17,6 +17,26 @@ module ActiveCypher
       attr_reader :host, :port, :timeout_seconds, :socket,
                   :protocol_version, :server_agent, :connection_id, :adapter
 
+      # Override inspect to redact sensitive information
+      def inspect
+        filtered_auth = ActiveCypher::Redaction.filter_hash(@auth_token)
+
+        attributes = {
+          host: @host.inspect,
+          port: @port.inspect,
+          auth_token: filtered_auth.inspect,
+          timeout_seconds: @timeout_seconds.inspect,
+          secure: @secure.inspect,
+          verify_cert: @verify_cert.inspect,
+          connected: @connected.inspect,
+          protocol_version: @protocol_version.inspect,
+          server_agent: @server_agent.inspect,
+          connection_id: @connection_id.inspect
+        }
+
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} #{attributes.map { |k, v| "@#{k}=#{v}" }.join(', ')}>"
+      end
+
       SUPPORTED_VERSIONS = [5.8, 5.2].freeze
 
       # Initializes a new Bolt connection.

data/lib/active_cypher/connection_adapters/abstract_adapter.rb

@@ -82,6 +82,15 @@ module ActiveCypher
       # @return [Array<Hash>] The processed rows
       def process_records(rows) = rows.map { |r| deep_symbolize(r) }
 
+      # Override inspect to hide sensitive information
+      # @return [String] Safe representation of the adapter
+      def inspect
+        filtered_config = ActiveCypher::Redaction.filter_hash(config)
+
+        # Return a safe representation
+        "#<#{self.class}:0x#{object_id.to_s(16)} @config=#{filtered_config.inspect}>"
+      end
+
       private
 
       # Recursively turns everything into symbols, because that's what all the cool kids do.

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "active_cypher/schema/catalog"
 
 module ActiveCypher
   module ConnectionAdapters
@@ -6,6 +7,15 @@ module ActiveCypher
       # 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 +68,36 @@ 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,43 @@
 # 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/cypher_databases.yml

@@ -1,16 +1,11 @@
 development:
   primary:
-    adapter: neo4j # Because you like your graphs with a touch of existential dread
-    url: neo4j://neo4j:neo4j@localhost:7687 # VIP port, VIP credentials (change them, seriously)
-    multi_db: false # One DB to rule them all
+    url: ENV["GRAPH_URL"]
 
 test:
   primary:
-    url: neo4j://neo4j:neo4j@localhost:9876 # Different port, same chaos
-    multi_db: false
+    url: ENV["GRAPH_URL"]
 
 production:
   primary:
-    adapter: memgraph # Yes, still memgraph... for now...
-    url: memgraph+ssc://<%= ENV["MG_USER"] %>:<%= ENV["MG_PASS"] %>@<%= ENV["MG_HOST"] %>:7687
-    multi_db: <%= ENV.fetch("MG_MULTI_DB", "false") %> # Because complexity is a luxury
+    url: ENV["GRAPH_URL"]

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/redaction.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  # Shared constants and utilities for redacting sensitive information in inspection output
+  module Redaction
+    # The mask to use for sensitive information
+    MASK = '[HUNTER2]'
+
+    # Common sensitive parameter keys
+    SENSITIVE_KEYS = %i[password credentials auth_token principal url].freeze
+
+    # Create a parameter filter with the default mask and keys
+    # @param additional_keys [Array<Symbol>] Additional keys to redact
+    # @return [ActiveSupport::ParameterFilter] The configured filter
+    def self.create_filter(additional_keys = [])
+      keys = SENSITIVE_KEYS + additional_keys
+      ActiveSupport::ParameterFilter.new(keys, mask: MASK)
+    end
+
+    # Filter a hash to redact sensitive information
+    # @param hash [Hash] The hash to filter
+    # @param additional_keys [Array<Symbol>] Additional keys to redact
+    # @return [Hash] The filtered hash
+    def self.filter_hash(hash, additional_keys = [])
+      create_filter(additional_keys).filter(hash)
+    end
+  end
+end

data/lib/active_cypher/schema/catalog.rb

@@ -0,0 +1,14 @@
+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,96 @@
+require 'fileutils'
+require 'optparse'
+
+module ActiveCypher
+  module Schema
+    # Dumps the graph schema to a Cypher script
+    class Dumper
+      DEFAULT_PATH = 'graphdb'.freeze
+
+      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')].sort.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,75 @@
+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,5 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
+
+  def self.gem_version
+    Gem::Version.new VERSION
+  end
+
+  class << self
+    alias version gem_version
+  end
 end

data/lib/activecypher.rb

@@ -4,6 +4,7 @@ require 'active_support'
 require 'zeitwerk'
 require_relative 'cyrel'
 require_relative 'active_cypher/version'
+require_relative 'active_cypher/redaction'
 
 # ActiveCypher is a Ruby gem that provides an ActiveRecord-like interface for
 # interacting with Neo4j databases using Cypher queries.

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 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
@@ -154,9 +158,13 @@ files:
 - lib/active_cypher/model/persistence.rb
 - lib/active_cypher/model/querying.rb
 - lib/active_cypher/railtie.rb
+- lib/active_cypher/redaction.rb
 - 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
@@ -204,6 +212,7 @@ files:
 - lib/cyrel/return_only.rb
 - lib/cyrel/types/hash_type.rb
 - lib/cyrel/types/symbol_type.rb
+- lib/tasks/graphdb_migrate.rake
 - sig/activecypher.rbs
 homepage: https://github.com/seuros/activecypher
 licenses: