migflow 0.2.0

data/lib/migflow/services/report_generator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../parsers/migration_parser"
+require_relative "snapshot_builder"
+require_relative "scoped_migration_warnings"
+require_relative "risk_scorer"
+
+module Migflow
+  module Services
+    class ReportGenerator
+      def call(migrations_path:)
+        migrations = Parsers::MigrationParser.call(migrations_path: migrations_path)
+        scorer = RiskScorer.new
+
+        analyzed = migrations.map { |m| analyze(m, migrations, scorer) }
+
+        {
+          generated_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          summary: build_summary(analyzed),
+          migrations: analyzed
+        }
+      end
+
+      private
+
+      def analyze(migration, all_migrations, scorer)
+        result   = SnapshotBuilder.call(migrations: all_migrations, up_to_version: migration[:version])
+        snapshot = snapshot_model(result[:schema_after], migration[:version])
+        warnings = ScopedMigrationWarnings.call(snapshot: snapshot, migration: migration, diff: result[:diff])
+        risk     = scorer.call(warnings)
+
+        {
+          version: migration[:version],
+          name: migration[:name],
+          risk_score: risk[:score],
+          risk_level: risk[:level],
+          warnings: warnings.map { |w| serialize_warning(w) }
+        }
+      end
+
+      def snapshot_model(schema_after, version)
+        Models::MigrationSnapshot.new(
+          version: version,
+          name: "Historical schema",
+          tables: schema_after[:tables],
+          raw_content: ""
+        )
+      end
+
+      def serialize_warning(warning)
+        {
+          rule: warning.rule,
+          severity: warning.severity.to_s,
+          table: warning.table,
+          column: warning.column,
+          message: warning.message
+        }
+      end
+
+      def build_summary(analyzed)
+        with_warnings = analyzed.count { |m| m[:warnings].any? }
+        with_errors   = analyzed.count { |m| m[:warnings].any? { |w| w[:severity] == "error" } }
+        max_score     = analyzed.map { |m| m[:risk_score] }.max || 0
+        max_level     = analyzed.max_by { |m| m[:risk_score] }&.fetch(:risk_level) || "safe"
+
+        {
+          total_migrations: analyzed.size,
+          migrations_with_warnings: with_warnings,
+          migrations_with_errors: with_errors,
+          highest_risk_score: max_score,
+          highest_risk_level: max_level
+        }
+      end
+    end
+  end
+end

data/lib/migflow/services/risk_scorer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Migflow
+  module Services
+    class RiskScorer
+      RULE_WEIGHTS = {
+        "dangerous_migration_rule" => 40,
+        "missing_index_rule" => 15,
+        "missing_foreign_key_rule" => 20,
+        "string_without_limit_rule" => 5,
+        "null_column_without_default_rule" => 20,
+        "missing_timestamps_rule" => 5
+      }.freeze
+
+      LEVELS = [
+        { min: 71, max: 100, level: "high" },
+        { min: 31, max: 70,  level: "medium" },
+        { min: 1,  max: 30,  level: "low" },
+        { min: 0,  max: 0,   level: "safe" }
+      ].freeze
+
+      def call(warnings)
+        factors = warnings.filter_map do |w|
+          weight = RULE_WEIGHTS[w.rule]
+          next unless weight
+
+          { rule: w.rule, message: w.message, weight: weight }
+        end
+
+        raw = factors.sum { |f| f[:weight] }
+        score = [raw, 100].min
+        level = LEVELS.find { |l| score.between?(l[:min], l[:max]) }&.fetch(:level, "safe")
+
+        { score: score, level: level, factors: factors }
+      end
+    end
+  end
+end

data/lib/migflow/services/schema_builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Migflow
+  module Services
+    class SchemaBuilder
+      def self.call(schema_path:)
+        new(schema_path: schema_path).build
+      end
+
+      def initialize(schema_path:)
+        @schema_path = schema_path
+      end
+
+      def build
+        parsed = Parsers::SchemaParser.call(schema_path: @schema_path)
+        Models::MigrationSnapshot.new(
+          version: parsed[:version],
+          name: "Current schema",
+          tables: parsed[:tables],
+          raw_content: Pathname.new(@schema_path).read
+        )
+      end
+    end
+  end
+end

data/lib/migflow/services/schema_patch_builder.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Migflow
+  module Services
+    class SchemaPatchBuilder
+      def self.call(from_tables:, to_tables:, changed_tables: nil, include_unchanged: false)
+        new(
+          from_tables: from_tables || {},
+          to_tables: to_tables || {},
+          changed_tables: changed_tables,
+          include_unchanged: include_unchanged
+        ).build
+      end
+
+      def initialize(from_tables:, to_tables:, changed_tables:, include_unchanged:)
+        @from_tables = from_tables
+        @to_tables = to_tables
+        @changed_tables = changed_tables&.to_set
+        @include_unchanged = include_unchanged
+      end
+
+      def build
+        document = build_document
+        lines = document[:lines]
+        has_diff = lines.any? { |line| ["+", "-"].include?(line[:prefix]) }
+        return "" unless has_diff
+
+        return build_full_patch(lines) if @include_unchanged
+
+        build_collapsed_patch(lines, document[:sections])
+      end
+
+      private
+
+      def build_full_patch(lines)
+        old_count = lines.count { |line| line[:prefix] != "+" }
+        new_count = lines.count { |line| line[:prefix] != "-" }
+
+        [
+          "diff --git a/schema.rb b/schema.rb",
+          "--- a/schema.rb",
+          "+++ b/schema.rb",
+          "@@ -1,#{old_count} +1,#{new_count} @@",
+          *lines.map { |line| "#{line[:prefix]}#{line[:content]}" },
+          ""
+        ].join("\n")
+      end
+
+      def build_collapsed_patch(lines, sections)
+        hunk_ranges = table_hunk_ranges(lines, sections)
+        return "" if hunk_ranges.empty?
+
+        hunk_blocks = hunk_ranges.map do |range|
+          old_start = line_number_before(lines, range.begin, :old) + 1
+          new_start = line_number_before(lines, range.begin, :new) + 1
+          hunk_lines = lines[range]
+          old_count = hunk_lines.count { |line| line[:prefix] != "+" }
+          new_count = hunk_lines.count { |line| line[:prefix] != "-" }
+
+          [
+            "@@ -#{old_start},#{old_count} +#{new_start},#{new_count} @@",
+            *hunk_lines.map { |line| "#{line[:prefix]}#{line[:content]}" }
+          ].join("\n")
+        end
+
+        [
+          "diff --git a/schema.rb b/schema.rb",
+          "--- a/schema.rb",
+          "+++ b/schema.rb",
+          *hunk_blocks,
+          ""
+        ].join("\n")
+      end
+
+      def table_hunk_ranges(lines, sections)
+        sections.each_with_object([]) do |section, ranges|
+          next unless section_changed?(lines, section)
+
+          # Keep schema block anchor visible so columns are not "floating"
+          # Always include full table block so each `create_table` has its
+          # matching `end` and changes never look nested/confusing.
+          ranges << (section[:start]..section[:end])
+        end
+      end
+
+      def line_number_before(lines, idx_exclusive, side)
+        slice = idx_exclusive.zero? ? [] : lines[0...idx_exclusive]
+        case side
+        when :old
+          slice.count { |line| line[:prefix] != "+" }
+        when :new
+          slice.count { |line| line[:prefix] != "-" }
+        else
+          0
+        end
+      end
+
+      def section_changed?(lines, section)
+        has_diff_lines = (section[:start]..section[:end]).any? { |idx| %w[+ -].include?(lines[idx][:prefix]) }
+        return has_diff_lines if @changed_tables.nil?
+        return false unless @changed_tables.include?(section[:table_name])
+
+        has_diff_lines
+      end
+
+      def build_document
+        lines = []
+        sections = []
+        all_table_names.each_with_index do |table_name, idx|
+          from_t = @from_tables[table_name]
+          to_t = @to_tables[table_name]
+          section_start = lines.length
+          section_lines = table_lines(table_name, from_t, to_t)
+          lines.concat(section_lines)
+          section_end = lines.length - 1
+          sections << { table_name: table_name, start: section_start, end: section_end }
+          lines << { prefix: " ", content: "" } if idx < all_table_names.length - 1
+        end
+        { lines: lines, sections: sections }
+      end
+
+      def all_table_names
+        (@from_tables.keys + @to_tables.keys).uniq.sort
+      end
+
+      def table_lines(table_name, from_t, to_t)
+        lines = []
+        is_added = from_t.nil? && !to_t.nil?
+        is_removed = !from_t.nil? && to_t.nil?
+
+        header_prefix = if is_added
+                          "+"
+                        else
+                          is_removed ? "-" : " "
+                        end
+        lines << { prefix: header_prefix, content: "create_table \"#{table_name}\" do |t|" }
+
+        from_columns = columns_map(from_t)
+        to_columns = columns_map(to_t)
+        (from_columns.keys + to_columns.keys).uniq.sort.each do |col_name|
+          from_col = from_columns[col_name]
+          to_col = to_columns[col_name]
+          if from_col.nil?
+            lines << { prefix: "+", content: "  #{format_column(to_col)}" }
+            next
+          end
+
+          if to_col.nil?
+            lines << { prefix: "-", content: "  #{format_column(from_col)}" }
+            next
+          end
+
+          if equivalent_column?(from_col, to_col)
+            lines << { prefix: " ", content: "  #{format_column(to_col)}" }
+          else
+            lines << { prefix: "-", content: "  #{format_column(from_col)}" }
+            lines << { prefix: "+", content: "  #{format_column(to_col)}" }
+          end
+        end
+
+        from_indexes = indexes_map(from_t)
+        to_indexes = indexes_map(to_t)
+        (from_indexes.keys + to_indexes.keys).uniq.sort.each do |idx_key|
+          from_idx = from_indexes[idx_key]
+          to_idx = to_indexes[idx_key]
+          if from_idx.nil?
+            lines << { prefix: "+", content: "  #{format_index(to_idx)}" }
+            next
+          end
+
+          if to_idx.nil?
+            lines << { prefix: "-", content: "  #{format_index(from_idx)}" }
+            next
+          end
+
+          if equivalent_index?(from_idx, to_idx)
+            lines << { prefix: " ", content: "  #{format_index(to_idx)}" }
+          else
+            lines << { prefix: "-", content: "  #{format_index(from_idx)}" }
+            lines << { prefix: "+", content: "  #{format_index(to_idx)}" }
+          end
+        end
+
+        lines << { prefix: " ", content: "end" }
+        lines
+      end
+
+      def columns_map(table)
+        return {} unless table
+
+        table[:columns].to_h { |col| [col[:name], col] }
+      end
+
+      def indexes_map(table)
+        return {} unless table
+
+        table[:indexes].each_with_object({}) do |idx, memo|
+          key = idx[:name] || idx[:columns].join("_")
+          memo[key] = idx
+        end
+      end
+
+      def format_column(col)
+        type = col[:type] || "string"
+        opts = []
+        opts << "null: false" if col[:null] == false
+        opts << "default: #{col[:default]}" unless col[:default].nil?
+        opts << "limit: #{col[:limit]}" unless col[:limit].nil?
+        base = "t.#{type} \"#{col[:name]}\""
+        opts.empty? ? base : "#{base}, #{opts.join(", ")}"
+      end
+
+      def format_index(idx)
+        columns = "[#{idx[:columns].map { |c| "\"#{c}\"" }.join(", ")}]"
+        opts = []
+        opts << "name: \"#{idx[:name]}\"" if idx[:name]
+        opts << "unique: true" if idx[:unique]
+        base = "t.index #{columns}"
+        opts.empty? ? base : "#{base}, #{opts.join(", ")}"
+      end
+
+      def equivalent_column?(one, other)
+        one[:name] == other[:name] &&
+          one[:type] == other[:type] &&
+          one[:null] == other[:null] &&
+          one[:default] == other[:default] &&
+          one[:limit] == other[:limit]
+      end
+
+      def equivalent_index?(one, other)
+        one[:name] == other[:name] &&
+          one[:unique] == other[:unique] &&
+          one[:columns] == other[:columns]
+      end
+    end
+  end
+end

data/lib/migflow/services/scoped_migration_warnings.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../analyzers/audit_analyzer"
+require_relative "../models/warning"
+require_relative "touched_tables_from_migration"
+
+module Migflow
+  module Services
+    class ScopedMigrationWarnings
+      MIGRATION_LEVEL_RULES = %w[
+        dangerous_migration_rule
+        null_column_without_default_rule
+      ].freeze
+
+      NOOP_INFO_RULE = "no_schema_change_migration_rule"
+
+      def self.call(snapshot:, migration:, diff: nil)
+        new(snapshot: snapshot, migration: migration, diff: diff).call
+      end
+
+      def initialize(snapshot:, migration:, diff: nil)
+        @snapshot  = snapshot
+        @migration = migration
+        @diff      = diff
+      end
+
+      def call
+        warnings = Analyzers::AuditAnalyzer.call(snapshot: @snapshot, raw_migrations: [@migration])
+        touched_tables = TouchedTablesFromMigration.call(raw_content: @migration[:raw_content])
+
+        if touched_tables.empty?
+          result = warnings.select { migration_level_warning?(_1) }
+          result << noop_migration_warning if noop_migration?(@migration[:raw_content].to_s)
+          return result
+        end
+
+        warnings.select do |warning|
+          migration_level_warning?(warning) || relevant_schema_warning?(warning, touched_tables)
+        end
+      end
+
+      private
+
+      def relevant_schema_warning?(warning, touched_tables)
+        table = warning.table.to_s
+        return false unless touched_tables.include?(table)
+        return true if @diff.nil?
+
+        change_scoped_relevant?(warning, table)
+      end
+
+      def change_scoped_relevant?(warning, table)
+        return true if added_table?(table)
+
+        col = warning.column.to_s
+        return false if col.empty?
+
+        added_columns_for(table).include?(col)
+      end
+
+      def added_table?(table)
+        (@diff[:added_tables] || []).map(&:to_s).include?(table)
+      end
+
+      def added_columns_for(table)
+        entry = (@diff[:modified_tables] || {})[table] || {}
+        (entry[:added_columns] || []).map(&:to_s)
+      end
+
+      def migration_level_warning?(warning)
+        MIGRATION_LEVEL_RULES.include?(warning.rule.to_s)
+      end
+
+      def noop_migration?(content)
+        return false if content.match?(/\bexecute\b/)
+        return false if content.match?(/\benable_extension\b/)
+        return false if content.match?(/\bcreate_extension\b/)
+
+        true
+      end
+
+      def noop_migration_warning
+        Models::Warning.new(
+          rule: NOOP_INFO_RULE,
+          severity: :info,
+          table: "_",
+          column: nil,
+          message: "No schema operations detected (empty migration or DSL not recognized by Migflow)."
+        )
+      end
+    end
+  end
+end