query_guard 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d723cebf19844b600f9e9eac77de7b3f38365528445edad233c64d40ec34c4a9
-  data.tar.gz: 4d0195a46bb85f9761ffd8aed0da8f5a2826356615cea117b47e27095e99f358
+  metadata.gz: 3c49c4ea0d69a65cc4f68add6d1ba70b4ae35f4df1099ccf3d920be37d540b3f
+  data.tar.gz: ee58b9a08573ae7d47d15ab7d8188fd768d83c11d8a9e35e71ee0dbe511acf45
 SHA512:
-  metadata.gz: 19b5411f363a8fffb31360146221fce7d37014cb6be395e39ca36d14ec8c2bee0247cf357905eeb9e592854201fc414efe9195a314a671674ea2612fb0069d31
-  data.tar.gz: f07a0a99f4bce9428f26927c05b0bf4e82568a7ae554a1fbfa35eda77a45d9ce69842b021833293a77b7885bf93b30d6c13b307a09438bed45320fedea48b4cb
+  metadata.gz: 50d9586e1bb88b11087bc3538c1d89459d99ffdf42001f5998eab5b86d8c6bad006e29d7ca64724693c5fcc6a5087353fb82f101881d9ac9f6a2560306cda858
+  data.tar.gz: 8668aa0e2808b835b85dfa5aae308fc3cf4386f696316bd9b89d2c140b93c2cb7bd97d643328030e8737be0a4e6dc30a7f3fa3410fd00feef3083443e348ad33

data/lib/query_guard/migrations/migration_risk_detectors.rb

@@ -12,9 +12,11 @@ module QueryGuard
 
         # Run all detectors
         risks.concat(detect_unsafe_index_additions(migration_content, migration_name))
+        risks.concat(detect_concurrent_index_without_disable_ddl(migration_content, migration_name))
         risks.concat(detect_table_locking_operations(migration_content, migration_name))
         risks.concat(detect_non_null_additions(migration_content, migration_name))
         risks.concat(detect_full_table_updates(migration_content, migration_name))
+        risks.concat(detect_data_backfill_in_migration(migration_content, migration_name))
         risks.concat(detect_unsafe_raw_sql(migration_content, migration_name))
 
         risks
@@ -29,6 +31,8 @@ module QueryGuard
         # Find all add_index occurrences
         lines = content.lines
         lines.each_with_index do |line, index|
+          # Skip commented-out lines
+          next if line.strip.start_with?("#")
           next unless line.include?("add_index")
 
           # Check if line includes algorithm: :concurrently
@@ -54,6 +58,105 @@ module QueryGuard
         risks
       end
 
+      # Detect algorithm: :concurrently without disable_ddl_transaction!
+      # This is necessary for PostgreSQL to allow concurrent index creation
+      def self.detect_concurrent_index_without_disable_ddl(content, migration_name)
+        risks = []
+
+        # Check if migration uses algorithm: :concurrently
+        has_concurrent_index = content.include?("algorithm: :concurrently")
+        return [] unless has_concurrent_index
+
+        # Check if disable_ddl_transaction! is present (but not in a comment)
+        lines = content.lines
+        has_disable_ddl = lines.any? do |line|
+          # Remove comment part
+          code_part = line.split('#').first
+          code_part.include?("disable_ddl_transaction!")
+        end
+
+        unless has_disable_ddl
+          lines.each_with_index do |line, index|
+            # Skip if this line is commented out
+            code_part = line.split('#').first
+            next unless code_part.include?("algorithm: :concurrently")
+
+            risks << {
+              type: :concurrent_index_no_disable_ddl,
+              severity: :error,
+              line_number: index + 1,
+              migration_name: migration_name,
+              title: "algorithm: :concurrently Without disable_ddl_transaction!",
+              description: "Using algorithm: :concurrently requires disable_ddl_transaction! in the migration class to avoid transaction errors.",
+              message: "algorithm: :concurrently found but disable_ddl_transaction! not set",
+              recommendation: "Add `disable_ddl_transaction!` to the migration class definition",
+              metadata: {
+                operation: "add_index",
+                risk_level: :high,
+                module: :schema_safety
+              }
+            }
+          end
+        end
+
+        risks
+      end
+
+      # Detect data backfill / app model usage inside migrations
+      # Migrations that use ActiveRecord models are risky because:
+      # - Models can change independently of migrations
+      # - Queries can fail if code changes
+      # - Large updates lock tables
+      def self.detect_data_backfill_in_migration(content, migration_name)
+        risks = []
+        lines = content.lines
+
+        has_model_usage = false
+        model_usage_lines = []
+
+        lines.each_with_index do |line, index|
+          next if line.strip.start_with?("#")
+          next if line.strip.empty?
+
+          # Detect direct model class usage (User.find_each, Comment.update_all, etc.)
+          if line.match?(/\b[A-Z]\w*\.(find|find_each|find_in_batches|all|where|update|create|delete|update_all|delete_all|execute)\b/)
+            # Skip if it's obviously not a model (like Date, Time, etc.)
+            unless line.match?(/\b(Date|Time|DateTime|Hash|Array|String|Integer|Float|Symbol|Regexp)\b/)
+              has_model_usage = true
+              model_usage_lines << { line_num: index + 1, content: line.strip }
+            end
+          end
+
+          # Also detect batched iterations (common pattern in data migrations)
+          if line.include?("find_each") || line.include?("find_in_batches")
+            has_model_usage = true
+            model_usage_lines << { line_num: index + 1, content: line.strip }
+          end
+        end
+
+        if has_model_usage
+          model_usage_lines.each do |item|
+            risks << {
+              type: :data_backfill_in_migration,
+              severity: :error,
+              line_number: item[:line_num],
+              migration_name: migration_name,
+              title: "Data Backfill Using App Models in Migration",
+              description: "Using ActiveRecord models in migrations is risky because models can change independently. Large data operations should use batching and happen separately from schema changes.",
+              message: "ActiveRecord model usage detected (#{item[:content][0..50]}...)",
+              recommendation: "Move data backfill to a separate rake task or post-deploy job. Use raw SQL with batching if migration-embedded, or use a data migration gem.",
+              metadata: {
+                operation: "data_backfill",
+                risk_level: :high,
+                module: :schema_safety
+              }
+            }
+          end
+        end
+
+        risks
+      end
+
       # Detect operations that lock the table: remove_column, change_column, rename_column
       def self.detect_table_locking_operations(content, migration_name)
         risks = []

data/lib/query_guard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QueryGuard
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: query_guard
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Chitradevi36
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake