better_structure_sql 0.1.0

data/lib/better_structure_sql/migration_patch.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  # Patches ActiveRecord::Migration to handle multi-file schema directories
+  #
+  # Rails' maintain_test_schema! calls purge_current_test_schema which tries to
+  # read the schema file directly using File.read(), which fails when the schema
+  # is a directory (multi-file mode).
+  #
+  # This patch intercepts that behavior and uses our SchemaLoader instead.
+  module MigrationPatch
+    # Override schema_cache to handle directory-based schemas
+    module SchemaCachePatch
+      # Returns the schema cache, handling directory-based schemas
+      # @return [ActiveRecord::ConnectionAdapters::SchemaCache] Schema cache
+      def schema_cache
+        return super unless multi_file_schema?
+
+        # For multi-file schemas, we need to handle the cache differently
+        # Check if cache exists as a file with the expected naming convention
+        cache_path = derived_cache_path
+
+        connection.schema_cache = ActiveRecord::ConnectionAdapters::SchemaCache.load_from(cache_path) if File.exist?(cache_path)
+
+        super
+      rescue Errno::EISDIR
+        # If we get EISDIR, it means Rails is trying to read a directory
+        # This is expected for multi-file schemas, just return the current cache
+        connection.schema_cache
+      end
+
+      private
+
+      def multi_file_schema?
+        return false unless defined?(Rails) && Rails.application
+
+        schema_path = if Rails.application.config.active_record.schema_format == :sql
+                        ENV.fetch('SCHEMA', 'db/structure.sql')
+                      else
+                        'db/schema.rb'
+                      end
+
+        full_path = Rails.root.join(schema_path)
+        File.directory?(full_path)
+      end
+
+      def derived_cache_path
+        # Check if using BetterStructureSql config
+        base_path = if defined?(BetterStructureSql) && BetterStructureSql.configured?
+                      BetterStructureSql.configuration.output_path
+                    elsif Rails.application.config.active_record.schema_format == :sql
+                      ENV.fetch('SCHEMA', 'db/structure.sql')
+                    else
+                      'db/schema.rb'
+                    end
+
+        # For directory mode, use the directory path + _schema_cache.yml
+        if Rails.root.join(base_path).directory?
+          Rails.root.join(base_path, '_schema_cache.yml')
+        else
+          # For file mode, use the default Rails cache path
+          Rails.root.join('db/schema_cache.yml')
+        end
+      end
+    end
+
+    # Patch for maintain_test_schema! to handle directory schemas
+    module MaintainTestSchemaPatch
+      # Maintains test schema, handling directory-based schemas
+      # @return [void]
+      def maintain_test_schema!
+        return super unless should_use_better_structure_sql?
+
+        # Check if we need to load or purge the schema
+        if pending_migrations?
+          # Purge the schema first
+          purge_current_test_schema_with_directory_support
+          # Load the schema using our loader
+          load_schema_with_directory_support
+        end
+      rescue Errno::EISDIR
+        # If we still get EISDIR, provide a helpful error message
+        raise ActiveRecord::MigrationError,
+              "Multi-file schema directory detected at #{schema_file_path}. " \
+              'Set config.replace_default_load = true in config/initializers/better_structure_sql.rb ' \
+              'to enable automatic multi-file schema loading, or run: rails db:schema:load_better'
+      end
+
+      private
+
+      def should_use_better_structure_sql?
+        return false unless defined?(BetterStructureSql) && defined?(Rails)
+        return false unless Rails.application.config.active_record.schema_format == :sql
+
+        # Check if schema path is a directory
+        File.directory?(schema_file_path)
+      end
+
+      def schema_file_path
+        if defined?(BetterStructureSql) && BetterStructureSql.configured?
+          Rails.root.join(BetterStructureSql.configuration.output_path)
+        else
+          Rails.root.join(ENV.fetch('SCHEMA', 'db/structure.sql'))
+        end
+      end
+
+      def pending_migrations?
+        # Use ActiveRecord::Base.connection_pool.migration_context for compatibility
+        # Different Rails versions have migration_context in different places
+        if ActiveRecord::Base.connection_pool.respond_to?(:migration_context)
+          ActiveRecord::Base.connection_pool.migration_context.needs_migration?
+        elsif ActiveRecord::Base.connection.respond_to?(:migration_context)
+          ActiveRecord::Base.connection.migration_context.needs_migration?
+        elsif defined?(ActiveRecord::MigrationContext)
+          # Fallback: construct migration context manually
+          paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+          schema_migration = ActiveRecord::Base.connection.schema_migration
+          internal_metadata = ActiveRecord::Base.connection.internal_metadata
+          ActiveRecord::MigrationContext.new(paths, schema_migration, internal_metadata).needs_migration?
+        else
+          # Very old Rails, assume migrations are pending to be safe
+          true
+        end
+      end
+
+      def purge_current_test_schema_with_directory_support
+        # Purge the test database
+        ActiveRecord::Tasks::DatabaseTasks.purge_current('test')
+      rescue ActiveRecord::NoDatabaseError
+        # Database doesn't exist, that's fine
+      end
+
+      def load_schema_with_directory_support
+        if defined?(BetterStructureSql) && BetterStructureSql.configured?
+          # Use our loader which handles both files and directories
+          loader = BetterStructureSql::SchemaLoader.new(BetterStructureSql.configuration)
+          loader.load
+        else
+          # Fallback to Rails default
+          ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql)
+        end
+      end
+    end
+
+    # Patch for DatabaseTasks to handle directory schemas in development
+    module DatabaseTasksPatch
+      # Override check_schema_file to handle directories
+      # @param filename [String] Path to schema file or directory
+      # @return [void]
+      def check_schema_file(filename)
+        # For directory mode, check if directory exists
+        if File.directory?(filename)
+          return if Dir.glob(File.join(filename, '**', '*.sql')).any?
+
+          message = +"#{filename} exists but contains no SQL files. Run `bin/rails db:migrate` to create schema files."
+          Kernel.abort message
+        end
+
+        # For file mode, use default Rails behavior
+        super
+      end
+
+      # Override schema_sha1 to handle directories
+      # @param file [String] Path to schema file or directory
+      # @return [String] SHA1 checksum
+      def schema_sha1(file)
+        if File.directory?(file)
+          # For directory mode, generate checksum from all SQL files combined
+          # Sort files to ensure deterministic ordering
+          sql_files = Dir.glob(File.join(file, '**', '*.sql')).sort
+          combined_content = sql_files.map { |f| File.read(f) }.join("\n")
+          OpenSSL::Digest::SHA1.hexdigest(combined_content)
+        else
+          # For file mode, use default Rails behavior
+          super
+        end
+      end
+    end
+
+    # Apply patches when loaded
+    def self.apply!
+      return unless defined?(ActiveRecord::Migration)
+
+      # Patch maintain_test_schema! if it exists
+      ActiveRecord::Migration.singleton_class.prepend(MaintainTestSchemaPatch) if ActiveRecord::Migration.respond_to?(:maintain_test_schema!)
+
+      # Patch schema_cache handling
+      ActiveRecord::MigrationContext.prepend(SchemaCachePatch) if defined?(ActiveRecord::MigrationContext)
+
+      # Patch DatabaseTasks for development/production use
+      return unless defined?(ActiveRecord::Tasks::DatabaseTasks)
+
+      ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksPatch)
+    end
+  end
+end

data/lib/better_structure_sql/pg_version.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  # Deprecated: Use DatabaseVersion instead.
+  # This module is kept for backward compatibility.
+  module PgVersion
+    # rubocop:disable Rails/Delegate
+    # delegate doesn't work for delegating to module constants
+    class << self
+      # Delegates to DatabaseVersion.detect
+      #
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @return [String] Database version
+      def detect(connection = ActiveRecord::Base.connection)
+        DatabaseVersion.detect(connection)
+      end
+
+      # Delegates to DatabaseVersion.parse_version
+      #
+      # @param version_string [String] Version string
+      # @return [String] Parsed version
+      def parse_version(version_string)
+        DatabaseVersion.parse_version(version_string)
+      end
+
+      # Delegates to DatabaseVersion.major_version
+      #
+      # @param version_string [String] Version string
+      # @return [Integer] Major version number
+      def major_version(version_string)
+        DatabaseVersion.major_version(version_string)
+      end
+
+      # Delegates to DatabaseVersion.minor_version
+      #
+      # @param version_string [String] Version string
+      # @return [Integer] Minor version number
+      def minor_version(version_string)
+        DatabaseVersion.minor_version(version_string)
+      end
+    end
+    # rubocop:enable Rails/Delegate
+  end
+end

data/lib/better_structure_sql/railtie.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module BetterStructureSql
+  # Rails integration for BetterStructureSql
+  #
+  # Registers rake tasks, initializers, and optionally replaces
+  # default Rails schema dump/load tasks with BetterStructureSql versions.
+  class Railtie < Rails::Railtie
+    railtie_name :better_structure_sql
+
+    rake_tasks do
+      load 'tasks/better_structure_sql.rake'
+    end
+
+    initializer 'better_structure_sql.load_config' do
+      config_file = Rails.root.join('config/initializers/better_structure_sql.rb')
+      load config_file if config_file.exist?
+    end
+
+    initializer 'better_structure_sql.replace_default_dump', after: 'active_record.set_configs' do
+      ActiveSupport.on_load(:active_record) do
+        config = BetterStructureSql.configuration
+
+        # Only replace tasks if using SQL format (structure.sql or directory)
+        # If using schema.rb format, silently skip replacement - we can still store versions
+        is_ruby_format = config.output_path.to_s.end_with?('.rb')
+
+        # Always apply migration patch for directory schema support in tests
+        # This fixes maintain_test_schema! when using multi-file directory mode
+        BetterStructureSql::MigrationPatch.apply!
+
+        if config.replace_default_dump && !is_ruby_format
+          # Automatically set Rails to use SQL schema format
+          Rails.application.config.active_record.schema_format = :sql
+
+          ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksExtension)
+          ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksDumpInfoExtension)
+          # Also prepend path override for dump
+          ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksPathExtension)
+        end
+
+        if config.replace_default_load && !is_ruby_format
+          ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksLoadExtension)
+          # Also prepend path override for load
+          ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(DatabaseTasksPathExtension)
+        end
+      end
+    end
+
+    # Extension to override schema_dump_path for BetterStructureSql
+    module DatabaseTasksPathExtension
+      # Returns schema dump path based on configuration
+      #
+      # @param db_config [ActiveRecord::DatabaseConfigurations::DatabaseConfig] Database configuration
+      # @param format [Symbol] Schema format (:sql or :ruby)
+      # @return [Pathname] Path to schema file
+      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+        if format.to_sym == :sql && !BetterStructureSql.configuration.output_path.to_s.end_with?('.rb')
+          # Return our configured path for SQL format
+          Rails.root.join(BetterStructureSql.configuration.output_path)
+        else
+          # Use default Rails path for Ruby format
+          super
+        end
+      end
+    end
+
+    # Extension to override DatabaseTasks#dump_schema for SQL format
+    module DatabaseTasksExtension
+      # Dumps schema using BetterStructureSql for SQL format
+      #
+      # @param db_config [ActiveRecord::DatabaseConfigurations::DatabaseConfig] Database configuration
+      # @param format [Symbol] Schema format
+      # @return [void]
+      def dump_schema(db_config, format = db_config.schema_format)
+        # Only override SQL format dumps
+        if format.to_sym == :sql
+          return unless db_config.schema_dump
+
+          filename = schema_dump_path(db_config, format)
+          return unless filename
+
+          FileUtils.mkdir_p(File.dirname(filename))
+
+          # Call our dumper which already includes schema_migrations
+          # Don't auto-store version here - use explicit db:schema:store task
+          BetterStructureSql::Dumper.new.dump(store_version: false)
+        else
+          # For Ruby format, call the original method
+          super
+        end
+      end
+    end
+
+    # No longer needed - we override dump_schema instead
+    module DatabaseTasksDumpInfoExtension
+      # This module is kept for backward compatibility but is no longer used
+    end
+
+    # Extension to override DatabaseTasks#load_schema for multi-file support
+    module DatabaseTasksLoadExtension
+      # Override load_schema to handle both file and directory schemas
+      def load_schema(db_config, format = ActiveRecord.schema_format, *_args)
+        if format.to_sym == :sql
+          # Get the configured schema path (could be file or directory)
+          config = BetterStructureSql.configuration
+          schema_path = Rails.root.join(config.output_path)
+
+          # Check if schema exists (file or directory)
+          abort "#{schema_path} doesn't exist yet. Run `bin/rails db:migrate` to create it, then try again." unless File.exist?(schema_path)
+
+          # Use our loader which handles both file and directory
+          loader = BetterStructureSql::SchemaLoader.new(config)
+          loader.load
+        else
+          # For Ruby format, call the original method
+          super
+        end
+      end
+    end
+  end
+end

data/lib/better_structure_sql/schema_loader.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  # Handles loading schema from single file or multi-file directory
+  class SchemaLoader
+    class LoadError < StandardError; end
+
+    attr_reader :config
+
+    def initialize(config = BetterStructureSql.configuration)
+      @config = config
+    end
+
+    # Main entry point - auto-detects mode
+    # @param path [String, nil] Path to schema file or directory (defaults to config.output_path)
+    def load(path = nil)
+      path ||= config.output_path
+      full_path = Rails.root.join(path)
+
+      if File.directory?(full_path)
+        load_directory(full_path)
+      elsif File.file?(full_path)
+        load_file(full_path)
+      else
+        raise LoadError, "Schema path not found: #{full_path}"
+      end
+    end
+
+    private
+
+    def load_directory(dir_path)
+      connection = ActiveRecord::Base.connection
+
+      # Load header first
+      header_path = File.join(dir_path, '_header.sql')
+      connection.execute(File.read(header_path)) if File.exist?(header_path)
+
+      # Load numbered directories in order (01_extensions through 10_migrations)
+      # Load all files in each directory and execute statements
+      # Use [01]* pattern to match directories starting with 0 or 1 (covers 01-10)
+      Dir.glob(File.join(dir_path, '[01]*_*')).sort.each do |dir|
+        next unless File.directory?(dir)
+
+        dir_name = File.basename(dir)
+
+        # Process files in this directory
+        Dir.glob(File.join(dir, '*.sql')).sort.each do |file_path|
+          sql_content = File.read(file_path)
+          next if sql_content.strip.empty?
+
+          # Execute SQL (connection.execute can handle multiple statements for SQLite)
+          execute_sql_statements(connection, sql_content)
+        end
+
+        Rails.logger.debug { "Loaded #{dir_name}" }
+      end
+
+      # Read manifest for file count (optional, for logging only)
+      manifest_path = File.join(dir_path, '_manifest.json')
+      return unless File.exist?(manifest_path)
+
+      manifest = JSON.parse(File.read(manifest_path))
+      Rails.logger.debug { "Schema loaded from #{manifest['total_files']} files" }
+    end
+
+    def load_file(file_path)
+      # Handle schema.rb vs structure.sql
+      if file_path.to_s.end_with?('.rb')
+        # Use Rails' ActiveRecord::Tasks::DatabaseTasks for .rb files
+        # This is what Rails uses internally for db:schema:load
+        ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, file_path)
+      else
+        # Execute SQL directly for .sql files
+        connection = ActiveRecord::Base.connection
+        sql = File.read(file_path)
+        execute_sql_statements(connection, sql)
+      end
+
+      Rails.logger.debug { "Schema loaded from #{file_path}" }
+    end
+
+    # Execute SQL statements, handling adapter-specific multi-statement behavior
+    def execute_sql_statements(connection, sql)
+      adapter_name = connection.adapter_name.downcase
+
+      case adapter_name
+      when 'sqlite'
+        # SQLite's ActiveRecord execute() uses prepare() which can't handle multiple statements
+        # We need to use the raw database connection's execute_batch method
+        connection.raw_connection.execute_batch(sql)
+      when 'postgresql', 'postgis'
+        # PostgreSQL can handle multiple statements in one execute call
+        connection.execute(sql)
+      when 'mysql', 'mysql2', 'trilogy'
+        # MySQL needs statements executed individually
+        execute_mysql_statements(connection, sql)
+      else
+        # Fallback: Try executing as-is first
+        begin
+          connection.execute(sql)
+        rescue StandardError
+          # If that fails, split by semicolon and execute individually
+          sql.split(/;\\s*$/).each do |statement|
+            next if statement.strip.empty?
+
+            connection.execute("#{statement};")
+          end
+        end
+      end
+    end
+
+    def execute_mysql_statements(connection, sql)
+      # Split SQL into individual statements for MySQL
+      # MySQL can't execute multiple statements in one call via ActiveRecord normally.
+      # For procedures/triggers with BEGIN/END blocks, we need special handling.
+
+      # Split into statements, respecting BEGIN/END blocks
+      statements = []
+      current_statement = +'' # Unfreeze string with unary plus
+      in_block = false # Track if we're inside a BEGIN/END block
+
+      sql.each_line do |line|
+        # Skip standalone comment lines
+        next if line.strip.start_with?('--') && current_statement.strip.empty?
+
+        current_statement << line
+
+        # Track BEGIN/END blocks (procedures and triggers)
+        # MySQL procedures: CREATE PROCEDURE name(...) BEGIN ... END;
+        # MySQL triggers: CREATE TRIGGER ... FOR EACH ROW BEGIN ... END;
+        stripped_line = line.strip.upcase
+
+        # Detect start of block: "BEGIN" on its own line or "FOR EACH ROW BEGIN"
+        in_block = true if stripped_line == 'BEGIN' || stripped_line.end_with?(' BEGIN')
+
+        # Detect end of block: "END" or "END;"
+        in_block = false if ['END;', 'END'].include?(stripped_line)
+
+        # Statement is complete when:
+        # 1. Line ends with semicolon, AND
+        # 2. We just closed a block (ended with END or END;), OR we're not in a block
+        if line.strip.end_with?(';') && !in_block
+          statements << current_statement.strip
+          current_statement = +'' # Unfreeze new string
+        end
+      end
+
+      # Add any remaining statement
+      statements << current_statement.strip unless current_statement.strip.empty?
+
+      # Execute each statement using raw connection
+      statements.each_with_index do |statement, index|
+        next if statement.empty?
+        next if statement.start_with?('--') # Skip standalone comments
+
+        begin
+          # Use ActiveRecord connection execute which works for procedures/triggers
+          connection.execute(statement)
+        rescue StandardError => e
+          # Log helpful error with statement number
+          Rails.logger.error "Failed to execute MySQL statement #{index + 1}/#{statements.length}: #{e.message}"
+          Rails.logger.error "Statement: #{statement[0..200]}"
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/better_structure_sql/schema_version.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module BetterStructureSql
+  # ActiveRecord model for stored schema versions
+  #
+  # Stores schema snapshots with metadata for versioning, comparison,
+  # and restoration. Supports both single-file and multi-file formats
+  # with optional ZIP archive storage.
+  class SchemaVersion < ActiveRecord::Base
+    self.table_name = 'better_structure_sql_schema_versions'
+
+    # Callbacks
+    before_save :set_metadata
+
+    # Validations
+    validates :content, presence: true
+    validates :pg_version, presence: true
+    validates :format_type, presence: true, inclusion: { in: %w[sql rb] }
+    validates :output_mode, presence: true, inclusion: { in: %w[single_file multi_file] }
+
+    # Scopes
+    scope :latest, -> { order(created_at: :desc).first }
+    scope :by_format, ->(type) { where(format_type: type) }
+    scope :by_output_mode, ->(mode) { where(output_mode: mode) }
+    scope :recent, ->(limit) { order(created_at: :desc).limit(limit) }
+    scope :oldest_first, -> { order(created_at: :asc) }
+
+    # Instance methods
+    def size
+      # Use stored content_size if available and content hasn't changed
+      if content_size.present? && !content_changed?
+        content_size
+      else
+        content.bytesize
+      end
+    end
+
+    # Returns human-readable size string
+    #
+    # @return [String] Formatted size (e.g., "1.5 MB", "250 KB")
+    def formatted_size
+      bytes = size
+      if bytes < 1024
+        "#{bytes} bytes"
+      elsif bytes < 1024 * 1024
+        "#{(bytes / 1024.0).round(2)} KB"
+      else
+        "#{(bytes / 1024.0 / 1024.0).round(2)} MB"
+      end
+    end
+
+    # Checks if this version uses multi-file format
+    #
+    # @return [Boolean] True if multi-file format
+    def multi_file?
+      output_mode == 'multi_file'
+    end
+
+    # Checks if this version has a ZIP archive
+    #
+    # @return [Boolean] True if ZIP archive exists
+    def zip_archive?
+      zip_archive.present?
+    end
+
+    # Extracts ZIP archive to target directory
+    #
+    # @param target_dir [String, Pathname] Target directory path
+    # @return [String, nil] Target directory path or nil if no archive
+    def extract_zip_to_directory(target_dir)
+      return nil unless zip_archive?
+
+      ZipGenerator.extract_to_directory(zip_archive, target_dir)
+      target_dir
+    end
+
+    private
+
+    def set_metadata
+      return unless content_changed?
+
+      self.content_size = content.bytesize
+      self.line_count = content.lines.count
+    end
+  end
+end