shikibu 0.1.0

data/lib/shikibu/storage/migrations.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+module Shikibu
+  module Storage
+    # Handles database schema migrations from shared durax-io/schema
+    # Compatible with dbmate migration format and schema_migrations tracking
+    class Migrations
+      SCHEMA_PATH = File.expand_path('../../../schema/db/migrations', __dir__)
+
+      # Advisory lock key for migration (consistent across workers)
+      MIGRATION_LOCK_KEY = 20_251_217_000_000
+
+      class << self
+        # Apply migrations to the database
+        # @param db [Sequel::Database] The database connection
+        # @return [Array<String>] List of applied migration versions
+        def apply(db)
+          db_type = detect_db_type(db)
+          migration_dir = File.join(SCHEMA_PATH, db_type)
+
+          raise Error, "Migration directory not found: #{migration_dir}" unless File.directory?(migration_dir)
+
+          # Ensure schema_migrations table exists
+          ensure_schema_migrations_table(db)
+
+          # Use advisory lock to ensure only one worker applies migrations
+          with_migration_lock(db, db_type) do |acquired|
+            unless acquired
+              # Another worker is applying migrations, wait and return
+              sleep(1)
+              return []
+            end
+
+            apply_pending_migrations(db, migration_dir)
+          end
+        end
+
+        private
+
+        def detect_db_type(db)
+          case db.database_type
+          when :postgres then 'postgresql'
+          when :mysql, :mysql2 then 'mysql'
+          else 'sqlite'
+          end
+        end
+
+        # Create schema_migrations table if it doesn't exist (dbmate compatible)
+        def ensure_schema_migrations_table(db)
+          db.run <<~SQL
+            CREATE TABLE IF NOT EXISTS schema_migrations (
+              version VARCHAR(255) PRIMARY KEY
+            )
+          SQL
+        rescue Sequel::DatabaseError => e
+          # Handle concurrent table creation
+          raise unless e.message.include?('already exists') || e.message.include?('duplicate')
+        end
+
+        # Get set of already applied migration versions
+        def get_applied_migrations(db)
+          db[:schema_migrations].select_map(:version).to_set
+        rescue Sequel::DatabaseError
+          # Table might not exist yet
+          Set.new
+        end
+
+        # Record a migration as applied
+        # @return [Boolean] true if recorded, false if already exists (race condition)
+        def record_migration(db, version)
+          db[:schema_migrations].insert(version: version)
+          true
+        rescue Sequel::UniqueConstraintViolation
+          # Another worker already recorded this migration
+          false
+        end
+
+        # Extract version from migration filename
+        # e.g., "20251217000000_initial_schema.sql" -> "20251217000000"
+        def extract_version(filename)
+          basename = File.basename(filename)
+          match = basename.match(/^(\d+)_/)
+          match ? match[1] : basename.sub('.sql', '')
+        end
+
+        # Apply pending migrations with version tracking
+        def apply_pending_migrations(db, migration_dir)
+          applied = get_applied_migrations(db)
+          migration_files = Dir.glob(File.join(migration_dir, '*.sql'))
+          applied_versions = []
+
+          migration_files.each do |file|
+            version = extract_version(file)
+
+            # Skip if already applied
+            next if applied.include?(version)
+
+            # Apply migration
+            apply_migration(db, file)
+
+            # Record as applied (handles race condition)
+            applied_versions << version if record_migration(db, version)
+          end
+
+          applied_versions
+        end
+
+        # Acquire advisory lock for migrations (database-specific)
+        def with_migration_lock(db, db_type, &)
+          case db_type
+          when 'postgresql'
+            with_postgres_lock(db, &)
+          when 'mysql'
+            with_mysql_lock(db, &)
+          else
+            # SQLite doesn't need advisory locks (single-writer)
+            yield true
+          end
+        end
+
+        def with_postgres_lock(db)
+          acquired = db.get(Sequel.function(:pg_try_advisory_lock, MIGRATION_LOCK_KEY))
+          begin
+            yield acquired
+          ensure
+            db.get(Sequel.function(:pg_advisory_unlock, MIGRATION_LOCK_KEY)) if acquired
+          end
+        end
+
+        def with_mysql_lock(db)
+          acquired = db.get(Sequel.function(:GET_LOCK, 'shikibu_migration', 0)) == 1
+          begin
+            yield acquired
+          ensure
+            db.get(Sequel.function(:RELEASE_LOCK, 'shikibu_migration')) if acquired
+          end
+        end
+
+        def apply_migration(db, file)
+          sql = File.read(file)
+
+          # Extract migrate:up section
+          up_sql = extract_up_section(sql)
+          return if up_sql.nil? || up_sql.strip.empty?
+
+          # Execute each statement
+          statements = split_statements(up_sql)
+          statements.each do |statement|
+            next if statement.strip.empty?
+
+            begin
+              db.run(statement)
+            rescue Sequel::DatabaseError => e
+              # Ignore "table already exists" errors for idempotent migrations
+              raise unless e.message.include?('already exists') ||
+                           e.message.include?('duplicate')
+            end
+          end
+        end
+
+        def extract_up_section(sql)
+          # Split by "-- migrate:down" and take the first part
+          parts = sql.split(/--\s*migrate:down/i)
+          up_section = parts.first
+
+          # Remove "-- migrate:up" marker
+          up_section&.sub(/--\s*migrate:up/i, '')
+        end
+
+        def split_statements(sql)
+          # Split by semicolon at end of line
+          sql.split(/;\s*$/).map(&:strip).reject(&:empty?)
+        end
+      end
+    end
+  end
+end