activerecord-graph-extractor 0.1.0

data/lib/activerecord_graph_extractor/relationship_analyzer.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module ActiveRecordGraphExtractor
+  class RelationshipAnalyzer
+    attr_reader :config, :visited_models, :circular_paths
+
+    def initialize(config = ActiveRecordGraphExtractor.configuration)
+      @config = config
+      @visited_models = Set.new
+      @circular_paths = []
+    end
+
+    def analyze_model(model_class)
+      # Validate that this is an ActiveRecord model
+      unless model_class.respond_to?(:reflect_on_all_associations)
+        raise ExtractionError, "#{model_class} is not an ActiveRecord model"
+      end
+
+      relationships = {}
+
+      model_class.reflect_on_all_associations.each do |association|
+        begin
+          next if association.klass.nil?
+
+          relationship_name = association.name.to_s
+          next unless config.relationship_included?(relationship_name)
+
+          model_name = association.klass.name
+          next unless config.model_included?(model_name)
+
+          relationships[relationship_name] = {
+            'type' => association.macro.to_s,
+            'model_class' => association.klass,
+            'model_name' => model_name,
+            'foreign_key' => association.foreign_key,
+            'polymorphic' => association.options[:polymorphic] || false,
+            'optional' => association.options[:optional] || false
+          }
+        rescue NameError => e
+          if config.skip_missing_models
+            next
+          else
+            raise e
+          end
+        end
+      end
+
+      filter_relationships(relationships)
+    end
+
+    def analyze_models(model_classes)
+      # Validate input
+      unless model_classes.is_a?(Array)
+        raise ExtractionError, "Expected an array of model classes"
+      end
+
+      # Handle empty array
+      return {} if model_classes.empty?
+
+      # Validate each model class
+      model_classes.each do |model_class|
+        unless model_class.respond_to?(:reflect_on_all_associations)
+          raise ExtractionError, "#{model_class} is not an ActiveRecord model"
+        end
+      end
+
+      relationships = {}
+
+      model_classes.each do |model_class|
+        model_name = model_class.name
+        relationships[model_name] = analyze_model(model_class)
+      end
+
+      relationships
+    end
+
+    def get_relationship_info(record, relationship_name)
+      relationships = analyze_model(record.class)
+      relationship = relationships[relationship_name.to_s]
+      
+      return nil unless relationship
+
+      # Convert to symbols for consistency with expected API
+      {
+        model_class: relationship['model_class'],
+        model_name: relationship['model_name'],
+        type: relationship['type'].to_sym
+      }
+    end
+
+    def build_dependency_graph(models)
+      dependency_graph = {}
+
+      models.each do |model_class|
+        dependencies = []
+        relationships = analyze_model(model_class)
+
+        relationships.each do |name, info|
+          if info['type'] == 'belongs_to' && !info['optional']
+            dependencies << info['model_class'] unless dependencies.include?(info['model_class'])
+          end
+        end
+
+        dependency_graph[model_class] = dependencies
+      end
+
+      dependency_graph
+    end
+
+    def circular_reference?(model_name, visited)
+      visited.include?(model_name)
+    end
+
+    private
+
+    def filter_relationships(relationships)
+      relationships.select do |name, info|
+        config.model_included?(info['model_name']) &&
+          config.relationship_included?(name)
+      end
+    end
+
+    def should_include_association?(association)
+      return false unless config.relationship_included?(association.name.to_s)
+      
+      # Skip associations that don't have a klass (can happen with polymorphic or broken associations)
+      return false unless association.klass
+      
+      return false unless config.model_included?(association.klass.name)
+      
+      # Skip polymorphic associations that can't be resolved
+      return false if association.polymorphic? && association.foreign_type.nil?
+      
+      true
+    rescue NameError
+      # Skip associations that reference non-existent models
+      false
+    end
+
+    def build_relationship_info(association)
+      {
+        type: association.macro,
+        class_name: association.klass&.name,
+        foreign_key: association.foreign_key,
+        primary_key: association.association_primary_key,
+        polymorphic: association.polymorphic?,
+        through: association.through_reflection&.name,
+        source: association.source_reflection&.name,
+        dependent: association.options[:dependent],
+        inverse_of: association.inverse_of&.name
+      }
+    end
+
+    def traverse_for_dependencies(model_class, dependency_graph, path)
+      model_name = model_class.name
+      
+      # Detect circular references
+      if path.include?(model_name)
+        handle_circular_reference(model_name, path)
+        return
+      end
+      
+      return if dependency_graph.key?(model_name)
+      
+      dependencies = []
+      current_path = path + [model_name]
+      
+      model_class.reflect_on_all_associations.each do |association|
+        next unless should_include_association?(association)
+        next if association.macro == :has_many || association.macro == :has_one
+        
+        # Only belongs_to creates dependencies
+        if association.macro == :belongs_to
+          # Skip if klass is nil (can happen with polymorphic associations)
+          next unless association.klass
+          
+          associated_class = association.klass
+          dependencies << associated_class.name
+          
+          # Recursively analyze dependencies
+          traverse_for_dependencies(associated_class, dependency_graph, current_path)
+        end
+      end
+      
+      dependency_graph[model_name] = dependencies.uniq
+    end
+
+    def handle_circular_reference(model_name, path)
+      cycle_start = path.index(model_name)
+      cycle = path[cycle_start..-1] + [model_name]
+      
+      @circular_paths << cycle
+      
+      case config.circular_reference_strategy
+      when :error
+        raise CircularReferenceError.new(
+          "Circular reference detected: #{cycle.join(' -> ')}",
+          model: model_name
+        )
+      when :skip
+        # Simply skip this path
+        return
+      when :break_at_depth
+        return if path.length >= config.max_circular_depth
+      end
+    end
+
+    def get_custom_rules(from_model, to_model)
+      config.custom_traversal_rules.dig(from_model, to_model) || {}
+    end
+  end
+end 

data/lib/activerecord_graph_extractor/s3_client.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-s3'
+
+module ActiveRecordGraphExtractor
+  class S3Client
+    attr_reader :bucket_name, :region, :s3_client
+
+    def initialize(bucket_name:, region: 'us-east-1', **options)
+      @bucket_name = bucket_name
+      @region = region
+      
+      # Initialize AWS S3 client with optional credentials
+      s3_options = { region: region }
+      s3_options.merge!(options) if options.any?
+      
+      @s3_client = Aws::S3::Client.new(s3_options)
+      
+      validate_bucket_access!
+    end
+
+    # Upload a file to S3
+    def upload_file(local_file_path, s3_key = nil, **options)
+      raise FileError, "File not found: #{local_file_path}" unless File.exist?(local_file_path)
+      
+      s3_key ||= generate_s3_key(local_file_path)
+      
+      begin
+        File.open(local_file_path, 'rb') do |file|
+          s3_client.put_object(
+            bucket: bucket_name,
+            key: s3_key,
+            body: file,
+            content_type: 'application/json',
+            **options
+          )
+        end
+        
+        {
+          bucket: bucket_name,
+          key: s3_key,
+          url: s3_url(s3_key),
+          size: File.size(local_file_path)
+        }
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to upload file to S3: #{e.message}"
+      end
+    end
+
+    # Download a file from S3
+    def download_file(s3_key, local_file_path = nil)
+      local_file_path ||= File.basename(s3_key)
+      
+      begin
+        s3_client.get_object(
+          bucket: bucket_name,
+          key: s3_key,
+          response_target: local_file_path
+        )
+        
+        {
+          bucket: bucket_name,
+          key: s3_key,
+          local_path: local_file_path,
+          size: File.size(local_file_path)
+        }
+      rescue Aws::S3::Errors::NoSuchKey
+        raise S3Error, "File not found in S3: s3://#{bucket_name}/#{s3_key}"
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to download file from S3: #{e.message}"
+      end
+    end
+
+    # Check if a file exists in S3
+    def file_exists?(s3_key)
+      s3_client.head_object(bucket: bucket_name, key: s3_key)
+      true
+    rescue Aws::S3::Errors::NotFound
+      false
+    rescue Aws::S3::Errors::ServiceError => e
+      raise S3Error, "Failed to check file existence: #{e.message}"
+    end
+
+    # List files in S3 with optional prefix
+    def list_files(prefix: nil, max_keys: 1000)
+      options = {
+        bucket: bucket_name,
+        max_keys: max_keys
+      }
+      options[:prefix] = prefix if prefix
+
+      begin
+        response = s3_client.list_objects_v2(options)
+        
+        response.contents.map do |object|
+          {
+            key: object.key,
+            size: object.size,
+            last_modified: object.last_modified,
+            url: s3_url(object.key)
+          }
+        end
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to list files: #{e.message}"
+      end
+    end
+
+    # Delete a file from S3
+    def delete_file(s3_key)
+      begin
+        s3_client.delete_object(bucket: bucket_name, key: s3_key)
+        true
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to delete file: #{e.message}"
+      end
+    end
+
+    # Generate a presigned URL for downloading
+    def presigned_url(s3_key, expires_in: 3600)
+      begin
+        presigner = Aws::S3::Presigner.new(client: s3_client)
+        presigner.presigned_url(:get_object, bucket: bucket_name, key: s3_key, expires_in: expires_in)
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to generate presigned URL: #{e.message}"
+      end
+    end
+
+    # Get file metadata
+    def file_metadata(s3_key)
+      begin
+        response = s3_client.head_object(bucket: bucket_name, key: s3_key)
+        
+        {
+          key: s3_key,
+          size: response.content_length,
+          last_modified: response.last_modified,
+          content_type: response.content_type,
+          etag: response.etag,
+          metadata: response.metadata
+        }
+      rescue Aws::S3::Errors::NotFound
+        raise S3Error, "File not found: s3://#{bucket_name}/#{s3_key}"
+      rescue Aws::S3::Errors::ServiceError => e
+        raise S3Error, "Failed to get file metadata: #{e.message}"
+      end
+    end
+
+    private
+
+    def validate_bucket_access!
+      s3_client.head_bucket(bucket: bucket_name)
+    rescue Aws::S3::Errors::NotFound
+      raise S3Error, "Bucket not found: #{bucket_name}"
+    rescue Aws::S3::Errors::Forbidden
+      raise S3Error, "Access denied to bucket: #{bucket_name}"
+    rescue Aws::S3::Errors::ServiceError => e
+      raise S3Error, "Failed to access bucket: #{e.message}"
+    end
+
+    def generate_s3_key(local_file_path)
+      filename = File.basename(local_file_path)
+      timestamp = Time.now.strftime('%Y/%m/%d')
+      "activerecord-graph-extractor/#{timestamp}/#{filename}"
+    end
+
+    def s3_url(s3_key)
+      "s3://#{bucket_name}/#{s3_key}"
+    end
+  end
+end 

data/lib/activerecord_graph_extractor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordGraphExtractor
+  VERSION = "0.1.0"
+end 

data/lib/activerecord_graph_extractor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_support"
+require "yajl"
+
+require_relative "activerecord_graph_extractor/version"
+require_relative "activerecord_graph_extractor/errors"
+require_relative "activerecord_graph_extractor/configuration"
+require_relative "activerecord_graph_extractor/relationship_analyzer"
+require_relative "activerecord_graph_extractor/dependency_resolver"
+require_relative "activerecord_graph_extractor/json_serializer"
+require_relative "activerecord_graph_extractor/primary_key_mapper"
+require_relative "activerecord_graph_extractor/progress_tracker"
+require_relative "activerecord_graph_extractor/s3_client"
+require_relative "activerecord_graph_extractor/dry_run_analyzer"
+require_relative "activerecord_graph_extractor/extractor"
+require_relative "activerecord_graph_extractor/importer"
+
+module ActiveRecordGraphExtractor
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end 

data/scripts/verify_installation.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Installation Verification Script for ActiveRecord Graph Extractor CLI
+# Run this script to verify your installation is working correctly
+
+puts "🔍 ActiveRecord Graph Extractor CLI Installation Verification"
+puts "=" * 60
+
+# Check if the arge command is available
+def check_command_availability
+  print "Checking if 'arge' command is available... "
+  
+  result = `which arge 2>/dev/null`.strip
+  if result.empty?
+    puts "❌ NOT FOUND"
+    puts
+    puts "The 'arge' command is not available in your PATH."
+    puts "This could mean:"
+    puts "  1. The gem is not installed globally"
+    puts "  2. You need to use 'bundle exec arge' instead"
+    puts "  3. You need to run 'rbenv rehash' (if using rbenv)"
+    puts
+    return false
+  else
+    puts "✅ FOUND at #{result}"
+    return true
+  end
+end
+
+# Check gem installation
+def check_gem_installation
+  print "Checking gem installation... "
+  
+  begin
+    require 'activerecord_graph_extractor'
+    version = ActiveRecordGraphExtractor::VERSION
+    puts "✅ INSTALLED (version #{version})"
+    return true
+  rescue LoadError
+    puts "❌ NOT FOUND"
+    puts
+    puts "The activerecord-graph-extractor gem is not installed or not in your load path."
+    puts "Try: gem install activerecord-graph-extractor"
+    puts
+    return false
+  end
+end
+
+# Test CLI functionality
+def test_cli_functionality
+  print "Testing CLI functionality... "
+  
+  # Try to run the version command
+  output = `arge version 2>&1`
+  exit_code = $?.exitstatus
+  
+  if exit_code == 0 && output.include?("ActiveRecord Graph Extractor")
+    puts "✅ WORKING"
+    puts "   Output: #{output.strip}"
+    return true
+  else
+    puts "❌ FAILED"
+    puts "   Exit code: #{exit_code}"
+    puts "   Output: #{output}"
+    return false
+  end
+end
+
+# Test CLI help
+def test_cli_help
+  print "Testing CLI help... "
+  
+  output = `arge help 2>&1`
+  exit_code = $?.exitstatus
+  
+      expected_commands = ['extract', 'import', 'extract_to_s3', 's3_list', 's3_download', 'analyze', 'dry_run']
+  
+  if exit_code == 0 && expected_commands.all? { |cmd| output.include?(cmd) }
+    puts "✅ ALL COMMANDS AVAILABLE"
+    puts "   Available commands: #{expected_commands.join(', ')}"
+    return true
+  else
+    puts "❌ MISSING COMMANDS"
+    puts "   Expected: #{expected_commands.join(', ')}"
+    puts "   Output: #{output}"
+    return false
+  end
+end
+
+# Check Ruby version
+def check_ruby_version
+  print "Checking Ruby version... "
+  
+  ruby_version = RUBY_VERSION
+  required_version = Gem::Version.new('2.7.0')
+  current_version = Gem::Version.new(ruby_version)
+  
+  if current_version >= required_version
+    puts "✅ COMPATIBLE (#{ruby_version})"
+    return true
+  else
+    puts "❌ TOO OLD (#{ruby_version}, requires >= 2.7.0)"
+    puts
+    puts "Please upgrade your Ruby version to 2.7.0 or higher."
+    puts "Consider using rbenv or RVM to manage Ruby versions."
+    puts
+    return false
+  end
+end
+
+# Check if running in Rails environment
+def check_rails_environment
+  print "Checking Rails environment... "
+  
+  if defined?(Rails)
+    puts "✅ RAILS DETECTED (#{Rails.version})"
+    puts "   You can use: bundle exec arge [command]"
+    return true
+  else
+    puts "ℹ️  NO RAILS DETECTED"
+    puts "   This is fine for standalone usage"
+    return true
+  end
+end
+
+# Main verification process
+def main
+  puts
+  
+  all_checks_passed = true
+  
+  # Run all checks
+  all_checks_passed &= check_ruby_version
+  all_checks_passed &= check_gem_installation
+  all_checks_passed &= check_rails_environment
+  all_checks_passed &= check_command_availability
+  
+  # Only test CLI if command is available
+  if check_command_availability
+    all_checks_passed &= test_cli_functionality
+    all_checks_passed &= test_cli_help
+  else
+    # Try with bundle exec if direct command failed
+    puts
+    puts "Trying with 'bundle exec'..."
+    
+    bundle_output = `bundle exec arge version 2>&1`
+    bundle_exit_code = $?.exitstatus
+    
+    if bundle_exit_code == 0
+      puts "✅ 'bundle exec arge' works!"
+      puts "   Use: bundle exec arge [command]"
+      puts "   This is normal when the gem is installed via Gemfile"
+    else
+      puts "❌ 'bundle exec arge' also failed"
+      puts "   Output: #{bundle_output}"
+      all_checks_passed = false
+    end
+  end
+  
+  puts
+  puts "=" * 60
+  
+  if all_checks_passed
+    puts "🎉 INSTALLATION VERIFICATION SUCCESSFUL!"
+    puts
+    puts "Your ActiveRecord Graph Extractor CLI is properly installed and working."
+    puts
+    puts "Quick start:"
+    puts "  arge version                    # Check version"
+    puts "  arge help                       # See all commands"
+    puts "  arge extract Order 123          # Extract a record (requires Rails)"
+    puts "  arge extract_to_s3 Order 123    # Extract to S3 (requires AWS config)"
+    puts
+  else
+    puts "❌ INSTALLATION VERIFICATION FAILED!"
+    puts
+    puts "Some checks failed. Please review the errors above and:"
+    puts "  1. Make sure the gem is properly installed"
+    puts "  2. Check your Ruby version (>= 2.7.0 required)"
+    puts "  3. Try 'rbenv rehash' if using rbenv"
+    puts "  4. Use 'bundle exec arge' if installed via Gemfile"
+    puts
+    puts "For more help, see the installation guide in the README."
+  end
+  
+  puts
+end
+
+# Run the verification
+main if __FILE__ == $0