rubydb 0.1.0

data/lib/rubydb/migrations/migration_lock.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "time"
+require "fileutils"
+require "monitor"
+
+module RubyDB
+  module Migrations
+    # MigrationLock - Prevents concurrent migrations
+    class MigrationLock
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @lock_table = config[:lock_table] || "migration_lock"
+        @lock_path = config[:lock_path] || "#{engine.path}.migration.lock"
+        @lock_timeout = config[:lock_timeout] || 300 # 5 minutes
+        @lock_acquired = false
+        @lock_id = nil
+        @lock_holder = nil
+        @lock_acquired_at = nil
+        @stats = {
+          locks_acquired: 0,
+          locks_released: 0,
+          locks_failed: 0,
+          lock_contention: 0,
+          lock_timeouts: 0
+        }
+        @lock = Monitor.new
+        @lock_file = nil
+      end
+
+      def acquire_lock
+        @lock.synchronize do
+          return true if @lock_acquired
+
+          @stats[:locks_acquired] += 1
+
+          # Check if lock exists
+          if lock_exists?
+            owner, acquired_at = get_lock_info
+
+            # Check if lock is stale
+            if Time.now - acquired_at > @lock_timeout
+              # Force release stale lock
+              release_lock_force
+              @stats[:lock_timeouts] += 1
+            else
+              @stats[:lock_contention] += 1
+              @stats[:locks_failed] += 1
+              return false
+            end
+          end
+
+          # Acquire lock
+          begin
+            acquire_lock_force
+          rescue Errno::EACCES, Errno::EAGAIN, Errno::EWOULDBLOCK
+            @stats[:lock_contention] += 1
+            @stats[:locks_failed] += 1
+            return false
+          end
+          @lock_acquired = true
+          @lock_acquired_at = Time.now
+          @lock_id = generate_lock_id
+
+          true
+        end
+      end
+
+      def release_lock
+        @lock.synchronize do
+          return false unless @lock_acquired
+
+          release_lock_force
+          @lock_acquired = false
+          @lock_id = nil
+          @lock_acquired_at = nil
+          @stats[:locks_released] += 1
+
+          true
+        end
+      end
+
+      def lock_acquired?
+        @lock_acquired
+      end
+
+      def lock_holder
+        @lock.synchronize do
+          return nil unless lock_exists?
+          get_lock_info
+        end
+      end
+
+      def lock_age
+        @lock.synchronize do
+          return nil unless @lock_acquired
+          Time.now - @lock_acquired_at
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            lock_acquired: @lock_acquired,
+            lock_id: @lock_id,
+            lock_age: lock_age
+          })
+        end
+      end
+
+      private
+
+      def lock_exists?
+        !@lock_file.nil?
+      end
+
+      def get_lock_info
+        [@lock_id || "external", @lock_acquired_at || Time.now]
+      end
+
+      def acquire_lock_force
+        FileUtils.mkdir_p(File.dirname(@lock_path))
+        file = File.open(@lock_path, "a+")
+        unless file.flock(File::LOCK_EX | File::LOCK_NB)
+          file.close
+          raise Errno::EWOULDBLOCK
+        end
+        @lock_file = file
+      end
+
+      def release_lock_force
+        return unless @lock_file
+        @lock_file.flock(File::LOCK_UN)
+        @lock_file.close
+        @lock_file = nil
+      end
+
+      def generate_lock_id
+        "lock_#{Time.now.to_i}_#{rand(10000)}"
+      end
+    end
+  end
+end

data/lib/rubydb/migrations/migration_manager.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module RubyDB
+  module Migrations
+    class MigrationError < StandardError; end unless const_defined?(:MigrationError)
+
+    # Loads and applies migrations with durable version tracking and a
+    # cross-process lock. Migration files must evaluate to a Migration.
+    class MigrationManager
+      attr_reader :database, :engine, :migrations, :stats
+
+      def initialize(database, options = {})
+        @database = database
+        @engine = database.respond_to?(:engine) ? database.engine : database
+        @options = options
+        @migration_path = options[:path] || options[:migrations_path] || "db/migrate"
+        @migrations = options[:migrations] || load_migrations
+        @lock = MigrationLock.new(@engine, options)
+        @stats = { applied: 0, rolled_back: 0, failed: 0 }
+      end
+
+      def migrate
+        with_lock do
+          ensure_schema
+          applied = applied_versions
+          validate_applied_migrations(applied)
+          target = target_version
+          pending = ordered_migrations.reject { |migration| applied.key?(migration.version.to_s) }
+          pending = pending.select { |migration| migration_key(migration.version) <= migration_key(target) } if target
+          apply_migrations(pending)
+        end
+      end
+
+      def rollback(steps = 1)
+        raise ArgumentError, "steps must be a positive integer" unless steps.is_a?(Integer) && steps.positive?
+
+        with_lock do
+          ensure_schema
+          applied = applied_versions
+          validate_applied_migrations(applied)
+          to_rollback = ordered_migrations.select { |m| applied.key?(m.version.to_s) }
+                                      .sort_by { |m| migration_key(m.version) }
+                                      .reverse
+                                      .first(steps)
+          to_rollback.each { |migration| rollback_migration(migration) }
+          to_rollback
+        end
+      end
+
+      def status
+        ensure_schema
+        applied = applied_versions
+        ordered_migrations.map do |migration|
+          record = applied[migration.version.to_s]
+          { version: migration.version.to_s, name: migration.name,
+            state: record ? :applied : :pending, checksum: record && record[:checksum] }
+        end
+      end
+
+      private
+
+      def with_lock
+        raise MigrationError, "could not acquire migration lock" unless @lock.acquire_lock
+        yield
+      ensure
+        @lock.release_lock if @lock&.lock_acquired?
+      end
+
+      def ensure_schema
+        @database.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, migration_name TEXT, applied_at TIMESTAMP, checksum TEXT)")
+        ensure_column("migration_name", "TEXT")
+        ensure_column("checksum", "TEXT")
+      end
+
+      def ensure_column(name, type)
+        @database.execute("ALTER TABLE schema_migrations ADD COLUMN #{name} #{type}")
+      rescue StandardError => error
+        raise unless error.message =~ /already exists|duplicate|exists/i
+      end
+
+      def applied_versions
+        rows = @database.query("SELECT version, migration_name, checksum FROM schema_migrations")
+        Array(rows).each_with_object({}) do |row, result|
+          version = row[:version] || row["version"]
+          result[version.to_s] = { name: row[:migration_name] || row["migration_name"], checksum: row[:checksum] || row["checksum"] }
+        end
+      end
+
+      def apply_migrations(migrations)
+        migrations.each do |migration|
+          existing = applied_versions[migration.version.to_s]
+          if existing && existing[:checksum] && existing[:checksum] != migration_checksum(migration)
+            raise MigrationError, "migration checksum mismatch for #{migration.version}"
+          end
+
+          begin
+            @database.transaction do
+              migration.apply_up(@engine)
+              insert_version(migration)
+            end
+            @stats[:applied] += 1
+          rescue StandardError
+            migration.mark_failed
+            @stats[:failed] += 1
+            raise
+          end
+        end
+      end
+
+      def rollback_migration(migration)
+        @database.transaction do
+          migration.apply_down(@engine)
+          @database.execute("DELETE FROM schema_migrations WHERE version = #{quote(migration.version.to_s)}")
+        end
+        @stats[:rolled_back] += 1
+      end
+
+      def insert_version(migration)
+        values = [migration.version.to_s, migration.name.to_s, Time.now.iso8601, migration_checksum(migration)].map { |v| quote(v) }
+        @database.execute("INSERT INTO schema_migrations (version, migration_name, applied_at, checksum) VALUES (#{values.join(', ')})")
+      end
+
+      def quote(value)
+        "'#{value.to_s.gsub("'", "''")}'"
+      end
+
+      def ordered_migrations
+        @migrations.sort_by { |migration| migration_key(migration.version) }
+      end
+
+      def migration_key(version)
+        version.to_s =~ /\A\d+\z/ ? version.to_i : version.to_s
+      end
+
+      def target_version
+        @options[:version]
+      end
+
+      def migration_checksum(migration)
+        migration.checksum
+      end
+
+      def validate_applied_migrations(applied)
+        migrations_by_version = @migrations.each_with_object({}) do |migration, result|
+          result[migration.version.to_s] = migration
+        end
+
+        applied.each do |version, record|
+          migration = migrations_by_version[version]
+          raise MigrationError, "applied migration #{version} is missing from the migration path" unless migration
+
+          expected = migration_checksum(migration)
+          recorded = record[:checksum].to_s
+          unless recorded.empty? || recorded == expected
+            raise MigrationError, "migration checksum mismatch for #{version}"
+          end
+        end
+      end
+
+      def load_migrations
+        return [] unless Dir.exist?(@migration_path)
+
+        Dir.glob(File.join(@migration_path, "*.rb")).sort.map do |path|
+          migration = eval(File.read(path), TOPLEVEL_BINDING, path, 1)
+          unless migration.is_a?(Migration)
+            raise MigrationError, "#{path} must evaluate to a Migration"
+          end
+          migration
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/migrations/migration_version.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Migrations
+    # MigrationVersion - Version management for migrations
+    class MigrationVersion
+      attr_reader :version, :timestamp, :sequence
+
+      def initialize(version = nil)
+        if version
+          @version = version
+          parse_version
+        else
+          @timestamp = Time.now
+          @sequence = 0
+          @version = generate_version
+        end
+      end
+
+      def parse_version
+        if @version =~ /^(\d{14})_(\d+)$/
+          @timestamp = Time.strptime($1, "%Y%m%d%H%M%S")
+          @sequence = $2.to_i
+        else
+          @timestamp = Time.now
+          @sequence = 0
+        end
+      end
+
+      def generate_version
+        "#{@timestamp.strftime('%Y%m%d%H%M%S')}_#{@sequence}"
+      end
+
+      def to_s
+        @version
+      end
+
+      def to_i
+        @version.gsub(/[^0-9]/, "").to_i
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(MigrationVersion)
+        @timestamp <=> other.timestamp
+      end
+
+      def <(other)
+        return false unless other.is_a?(MigrationVersion)
+        @timestamp < other.timestamp
+      end
+
+      def >(other)
+        return false unless other.is_a?(MigrationVersion)
+        @timestamp > other.timestamp
+      end
+
+      def next
+        MigrationVersion.new("#{@timestamp.strftime('%Y%m%d%H%M%S')}_#{@sequence + 1}")
+      end
+
+      def prev
+        return nil if @sequence == 0
+        MigrationVersion.new("#{@timestamp.strftime('%Y%m%d%H%M%S')}_#{@sequence - 1}")
+      end
+
+      def inspect
+        "#<MigrationVersion version=#{@version} timestamp=#{@timestamp}>"
+      end
+    end
+  end
+end

data/lib/rubydb/migrations/schema_diff.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module RubyDB
+  module Migrations
+    # SchemaDiff - Compares schemas and generates migrations
+    class SchemaDiff
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @stats = {
+          diffs_computed: 0,
+          migrations_generated: 0,
+          tables_added: 0,
+          tables_removed: 0,
+          columns_added: 0,
+          columns_removed: 0,
+          columns_changed: 0
+        }
+        @lock = Monitor.new
+      end
+
+      def diff(source_schema, target_schema)
+        @lock.synchronize do
+          @stats[:diffs_computed] += 1
+
+          result = {
+            added_tables: [],
+            removed_tables: [],
+            changed_tables: [],
+            added_columns: [],
+            removed_columns: [],
+            changed_columns: [],
+            warnings: [],
+            target_schema: target_schema
+          }
+
+          # Compare tables
+          source_tables = source_schema.keys
+          target_tables = target_schema.keys
+
+          added = target_tables - source_tables
+          removed = source_tables - target_tables
+          common = source_tables & target_tables
+
+          result[:added_tables] = added
+          result[:removed_tables] = removed
+
+          # Compare common tables
+          common.each do |table|
+            source_cols = source_schema[table] || {}
+            target_cols = target_schema[table] || {}
+
+            # Find added/removed columns
+            added_cols = target_cols.keys - source_cols.keys
+            removed_cols = source_cols.keys - target_cols.keys
+            common_cols = source_cols.keys & target_cols.keys
+
+            result[:added_columns] += added_cols.map { |c| { table: table, column: c } }
+            result[:removed_columns] += removed_cols.map { |c| { table: table, column: c } }
+
+            # Find changed columns
+            common_cols.each do |col|
+              if source_cols[col] != target_cols[col]
+                result[:changed_columns] << {
+                  table: table,
+                  column: col,
+                  old_type: source_cols[col],
+                  new_type: target_cols[col]
+                }
+              end
+            end
+          end
+
+          result
+        end
+      end
+
+      def generate_migration(source_schema, target_schema, options = {})
+        @lock.synchronize do
+          diff_result = diff(source_schema, target_schema)
+          @stats[:migrations_generated] += 1
+
+          @stats[:tables_added] += diff_result[:added_tables].size
+          @stats[:tables_removed] += diff_result[:removed_tables].size
+          @stats[:columns_added] += diff_result[:added_columns].size
+          @stats[:columns_removed] += diff_result[:removed_columns].size
+          @stats[:columns_changed] += diff_result[:changed_columns].size
+
+          migration_name = options[:name] || "auto_migration_#{Time.now.strftime('%Y%m%d%H%M%S')}"
+          migration_code = generate_migration_code(diff_result, migration_name)
+
+          {
+            success: true,
+            migration_name: migration_name,
+            code: migration_code,
+            diff: diff_result,
+            summary: {
+              tables_added: diff_result[:added_tables].size,
+              tables_removed: diff_result[:removed_tables].size,
+              columns_added: diff_result[:added_columns].size,
+              columns_removed: diff_result[:removed_columns].size,
+              columns_changed: diff_result[:changed_columns].size
+            }
+          }
+        end
+      end
+
+      def diff_to_sql(source_schema, target_schema)
+        @lock.synchronize do
+          diff_result = diff(source_schema, target_schema)
+          sql = []
+
+          # Tables to create
+          diff_result[:added_tables].each do |table|
+            columns = target_schema[table] || {}
+            col_defs = columns.map { |name, type| "  #{name} #{type}" }.join(",\n")
+            sql << "CREATE TABLE #{table} (\n#{col_defs}\n);"
+          end
+
+          # Tables to drop
+          diff_result[:removed_tables].each do |table|
+            sql << "DROP TABLE #{table};"
+          end
+
+          # Columns to add
+          diff_result[:added_columns].each do |col|
+            sql << "ALTER TABLE #{col[:table]} ADD COLUMN #{col[:column]} #{target_schema[col[:table]][col[:column]]};"
+          end
+
+          # Columns to remove
+          diff_result[:removed_columns].each do |col|
+            sql << "ALTER TABLE #{col[:table]} DROP COLUMN #{col[:column]};"
+          end
+
+          # Columns to change
+          diff_result[:changed_columns].each do |col|
+            sql << "ALTER TABLE #{col[:table]} ALTER COLUMN #{col[:column]} TYPE #{col[:new_type]};"
+          end
+
+          sql.join("\n")
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            diff_enabled: true
+          })
+        end
+      end
+
+      private
+
+      def generate_migration_code(diff_result, name)
+        # Generate Ruby migration code
+        code = []
+        code << "# frozen_string_literal: true"
+        code << ""
+        code << "# Migration: #{name}"
+        code << "# Generated: #{Time.now.iso8601}"
+        code << ""
+        code << "migration = Migration.new('#{Time.now.strftime('%Y%m%d%H%M%S')}', '#{name}')"
+        code << ""
+        code << "migration.up do |engine|"
+
+        # Tables to create
+        diff_result[:added_tables].each do |table|
+          code << "  engine.create_table('#{table}') do |t|"
+          (diff_result[:target_schema] || {})[table]&.each do |col_name, col_type|
+            code << "    t.column('#{col_name}', '#{col_type}')"
+          end
+          code << "  end"
+        end
+
+        # Tables to drop
+        diff_result[:removed_tables].each do |table|
+          code << "  engine.drop_table('#{table}')"
+        end
+
+        # Columns to add
+        diff_result[:added_columns].each do |col|
+          code << "  engine.add_column('#{col[:table]}', '#{col[:column]}', '#{diff_result[:target_schema][col[:table]][col[:column]]}')"
+        end
+
+        # Columns to remove
+        diff_result[:removed_columns].each do |col|
+          code << "  engine.remove_column('#{col[:table]}', '#{col[:column]}')"
+        end
+
+        # Columns to change
+        diff_result[:changed_columns].each do |col|
+          code << "  engine.change_column('#{col[:table]}', '#{col[:column]}', '#{col[:new_type]}')"
+        end
+
+        code << "end"
+        code << ""
+        code << "migration.down do |engine|"
+        code << "  # Rollback changes (reverse order)"
+        code << "end"
+        code << ""
+        code << "migration"
+
+        code.join("\n")
+      end
+    end
+  end
+end

data/lib/rubydb/migrations/schema_version.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "time"
+require "json"
+
+module RubyDB
+  module Migrations
+    # SchemaVersion - Tracks schema version information
+    class SchemaVersion
+      attr_reader :version, :applied_at, :migration_name
+      attr_reader :description, :author, :checksum
+
+      def initialize(version, migration_name, options = {})
+        @version = version
+        @migration_name = migration_name
+        @description = options[:description] || ""
+        @author = options[:author]
+        @applied_at = Time.now
+        @checksum = options[:checksum]
+        @metadata = options[:metadata] || {}
+        @status = :applied
+        @database_version = options[:database_version]
+      end
+
+      def to_hash
+        {
+          version: @version,
+          migration_name: @migration_name,
+          description: @description,
+          author: @author,
+          applied_at: @applied_at.iso8601,
+          checksum: @checksum,
+          metadata: @metadata,
+          status: @status,
+          database_version: @database_version
+        }
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      def self.from_json(json_data)
+        data = JSON.parse(json_data, symbolize_names: true)
+        version = new(
+          data[:version],
+          data[:migration_name],
+          description: data[:description],
+          author: data[:author],
+          checksum: data[:checksum],
+          metadata: data[:metadata] || {},
+          database_version: data[:database_version]
+        )
+        version.instance_variable_set(:@applied_at, Time.parse(data[:applied_at]))
+        version.instance_variable_set(:@status, data[:status].to_sym)
+        version
+      end
+
+      def inspect
+        "#<SchemaVersion version=#{@version} migration=#{@migration_name} applied=#{@applied_at}>"
+      end
+    end
+  end
+end