rails_lens 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41ebdd3c52cca1c77790aa896dcc5962acb92c44eec90a2dceeda98f310aefb7
-  data.tar.gz: 72e49695a796e9d030fd80aedab53d7dea055db82c98e8023a6a2bb4293e139f
+  metadata.gz: 7eaa2e258c8608dfd893bb5220840fc9febce43478aca9573ae0dbb885b33bf5
+  data.tar.gz: ed99614fc744e7f32e6c439a8f61e99b5d94787a684c694fbca7ed1eb546e6c6
 SHA512:
-  metadata.gz: d0e890e0ae21326d6176542668277a1c8e5d6336f013dec8cc8854f892c0136c6a40fb4557789dc661c47de70fbf82c0e59dcc75769b4a41e613f681e75f9a9f
-  data.tar.gz: d5c0d6aaecbd3a46986cc86507b3550347bd09e69f4126721fdb9acec05110a2f622fa2555d8c37151144efdd89ef5b87129576d3bc66c02f2b8cdd3404fcb77
+  metadata.gz: 0fc9a2a6d597e0d5a5e9b5e1c5eddf79bdca77448e780686fd28eabc26c5085829fe543595bdde05d31949a0e5ca42475bd379d89b9d552c128c06070d7a555c
+  data.tar.gz: 3982294a0d8a11b0ba516a7f90dc5595b488a3dcae79ef874c8d7d0cb0369f4a6438304adf1dd476d3aa8542bd445ec44022b549dcdeb48bf63084b5bebdd22d

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.3](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.2...rails_lens/v0.2.3) (2025-07-31)
+
+
+### Features
+
+* add database view annotation support ([#7](https://github.com/seuros/rails_lens/issues/7)) ([a42fdcd](https://github.com/seuros/rails_lens/commit/a42fdcdfe4da9e2a086488e0c5e0c72d2f3c5d3d))
+
+
+### Bug Fixes
+
+* centralize connection management to prevent "too many clients" errors ([#9](https://github.com/seuros/rails_lens/issues/9)) ([c5d85c7](https://github.com/seuros/rails_lens/commit/c5d85c7239d1eff49494a05582cb00a8e7402618))
+
 ## [0.2.2](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.1...rails_lens/v0.2.2) (2025-07-31)
 
 

data/lib/rails_lens/analyzers/notes.rb

@@ -29,12 +29,22 @@ module RailsLens
 
         notes = []
 
-        notes.concat(analyze_indexes)
-        notes.concat(analyze_foreign_keys)
-        notes.concat(analyze_associations)
-        notes.concat(analyze_columns)
-        notes.concat(analyze_performance)
-        notes.concat(analyze_best_practices)
+        # Check if this model is backed by a view
+        is_view = ModelDetector.view_exists?(model_class)
+
+        if is_view
+          # For views, add view-specific checks
+          notes.concat(analyze_view_readonly)
+          notes.concat(analyze_view_gotchas)
+        else
+          # For tables, run all standard checks
+          notes.concat(analyze_indexes)
+          notes.concat(analyze_foreign_keys)
+          notes.concat(analyze_associations)
+          notes.concat(analyze_columns)
+          notes.concat(analyze_performance)
+          notes.concat(analyze_best_practices)
+        end
 
         notes.compact.uniq
       rescue ActiveRecord::StatementInvalid => e
@@ -47,6 +57,54 @@ module RailsLens
 
       private
 
+      def analyze_view_readonly
+        notes = []
+
+        # Check if this model is backed by a database view
+        if ModelDetector.view_exists?(model_class)
+          notes << '👁️ View-backed model: read-only'
+
+          # Check if model has readonly implementation
+          unless has_readonly_implementation?
+            notes << 'Add readonly? method'
+          end
+        end
+
+        notes
+      rescue StandardError => e
+        Rails.logger.debug { "Error checking view readonly status for #{model_class.name}: #{e.message}" }
+        []
+      end
+
+      def analyze_view_gotchas
+        notes = []
+        view_metadata = ViewMetadata.new(model_class)
+
+        # Check for materialized view specific issues
+        if view_metadata.materialized_view?
+          notes << '🔄 Materialized view: data may be stale until refreshed'
+          unless has_refresh_methods?
+            notes << 'Add refresh! method for manual updates'
+          end
+        end
+
+        # Check for nested views (view depending on other views)
+        dependencies = view_metadata.dependencies
+        if dependencies.any? { |dep| view_exists_by_name?(dep) }
+          notes << '⚠️ Nested views detected: may impact query performance'
+        end
+
+        # Check for readonly implementation
+        unless has_readonly_implementation?
+          notes << '🔒 Add readonly protection to prevent write operations'
+        end
+
+        notes
+      rescue StandardError => e
+        Rails.logger.debug { "Error analyzing view gotchas for #{model_class.name}: #{e.message}" }
+        []
+      end
+
       def analyze_indexes
         notes = []
 
@@ -320,6 +378,56 @@ module RailsLens
           column.type == :uuid || (column.type == :string && column.name.match?(/uuid|guid/))
         end
       end
+
+      def has_readonly_implementation?
+        # Check if model has readonly? method defined (not just inherited from ActiveRecord)
+        model_class.method_defined?(:readonly?) &&
+          model_class.instance_method(:readonly?).owner != ActiveRecord::Base
+      rescue StandardError
+        false
+      end
+
+      def has_refresh_methods?
+        # Check if model has refresh! method for materialized views
+        model_class.respond_to?(:refresh!) || model_class.respond_to?(:refresh_concurrently!)
+      rescue StandardError
+        false
+      end
+
+      def view_exists_by_name?(view_name)
+        # Check if a view exists in the database by name
+        case @connection.adapter_name.downcase
+        when 'postgresql'
+          result = @connection.exec_query(<<~SQL.squish, 'Check PostgreSQL View Existence')
+            SELECT 1 FROM information_schema.views#{' '}
+            WHERE table_name = '#{@connection.quote_string(view_name)}'
+            UNION ALL
+            SELECT 1 FROM pg_matviews#{' '}
+            WHERE matviewname = '#{@connection.quote_string(view_name)}'
+            LIMIT 1
+          SQL
+          result.rows.any?
+        when 'mysql', 'mysql2'
+          result = @connection.exec_query(<<~SQL.squish, 'Check MySQL View Existence')
+            SELECT 1 FROM information_schema.views#{' '}
+            WHERE table_name = '#{@connection.quote_string(view_name)}'
+            LIMIT 1
+          SQL
+          result.rows.any?
+        when 'sqlite', 'sqlite3'
+          result = @connection.exec_query(<<~SQL.squish, 'Check SQLite View Existence')
+            SELECT 1 FROM sqlite_master#{' '}
+            WHERE type = 'view' AND name = '#{@connection.quote_string(view_name)}'
+            LIMIT 1
+          SQL
+          result.rows.any?
+        else
+          false
+        end
+      rescue StandardError => e
+        Rails.logger.debug { "Error checking view existence for #{view_name}: #{e.message}" }
+        false
+      end
     end
   end
 end

data/lib/rails_lens/annotation_pipeline.rb

@@ -27,30 +27,33 @@ module RailsLens
         notes: []
       }
 
-      @providers.each do |provider|
-        next unless provider.applicable?(model_class)
+      # Use the model's connection pool to manage a single connection for all providers
+      model_class.connection_pool.with_connection do |connection|
+        @providers.each do |provider|
+          next unless provider.applicable?(model_class)
 
-        begin
-          result = provider.process(model_class)
+          begin
+            result = provider.process(model_class, connection)
 
-          case provider.type
-          when :schema
-            results[:schema] = result
-          when :section
-            results[:sections] << result if result
-          when :notes
-            results[:notes].concat(Array(result))
+            case provider.type
+            when :schema
+              results[:schema] = result
+            when :section
+              results[:sections] << result if result
+            when :notes
+              results[:notes].concat(Array(result))
+            end
+          rescue ActiveRecord::StatementInvalid => e
+            warn "Provider #{provider.class} database error for #{model_class}: #{e.message}"
+          rescue ActiveRecord::ConnectionNotDefined => e
+            warn "Provider #{provider.class} connection error for #{model_class}: #{e.message}"
+          rescue NameError, NoMethodError => e
+            warn "Provider #{provider.class} method error for #{model_class}: #{e.message}"
+          rescue RailsLens::Error => e
+            warn "Provider #{provider.class} rails_lens error for #{model_class}: #{e.message}"
+          rescue StandardError => e
+            warn "Provider #{provider.class} unexpected error for #{model_class}: #{e.message}"
           end
-        rescue ActiveRecord::StatementInvalid => e
-          warn "Provider #{provider.class} database error for #{model_class}: #{e.message}"
-        rescue ActiveRecord::ConnectionNotDefined => e
-          warn "Provider #{provider.class} connection error for #{model_class}: #{e.message}"
-        rescue NameError, NoMethodError => e
-          warn "Provider #{provider.class} method error for #{model_class}: #{e.message}"
-        rescue RailsLens::Error => e
-          warn "Provider #{provider.class} rails_lens error for #{model_class}: #{e.message}"
-        rescue StandardError => e
-          warn "Provider #{provider.class} unexpected error for #{model_class}: #{e.message}"
         end
       end
 
@@ -65,6 +68,7 @@ module RailsLens
 
       # Section providers (additional structured content)
       register(Providers::ExtensionsProvider.new) if RailsLens.config.extensions[:enabled]
+      register(Providers::ViewProvider.new)
       register(Providers::InheritanceProvider.new)
       register(Providers::EnumsProvider.new)
       register(Providers::DelegatedTypesProvider.new)
@@ -75,6 +79,7 @@ module RailsLens
       # Notes providers (analysis and recommendations)
       return unless RailsLens.config.schema[:include_notes]
 
+      register(Providers::ViewNotesProvider.new)
       register(Providers::IndexNotesProvider.new)
       register(Providers::ForeignKeyNotesProvider.new)
       register(Providers::AssociationNotesProvider.new)

data/lib/rails_lens/connection.rb

@@ -3,12 +3,12 @@
 module RailsLens
   class Connection
     class << self
-      def adapter_for(model_class)
-        connection = model_class.connection
-        adapter_name = detect_adapter_name(connection)
+      def adapter_for(model_class, connection = nil)
+        conn = connection || model_class.connection
+        adapter_name = detect_adapter_name(conn)
 
         adapter_class = resolve_adapter_class(adapter_name)
-        adapter_class.new(connection, model_class.table_name)
+        adapter_class.new(conn, model_class.table_name)
       end
 
       def resolve_adapter_class(adapter_name)

data/lib/rails_lens/erd/visualizer.rb

@@ -66,8 +66,11 @@ module RailsLens
             # Additional safety check: Skip abstract models that might have slipped through
             next if model.abstract_class?
 
-            # Skip models without valid tables or columns
-            next unless model.table_exists? && model.columns.present?
+            # Skip models without valid tables/views or columns
+            # Include both table-backed and view-backed models
+            is_view = ModelDetector.view_exists?(model)
+            has_data_source = is_view || (model.table_exists? && model.columns.present?)
+            next unless has_data_source
 
             model_display_name = format_model_name(model)
 
@@ -105,12 +108,19 @@ module RailsLens
           end
         end
 
+        # Add visual styling for views vs tables
+        add_visual_styling(output, models)
+
         # Add relationships
         output << '  %% Relationships'
         models.each do |model|
           # Skip abstract models in relationship generation too
           next if model.abstract_class?
-          next unless model.table_exists? && model.columns.present?
+
+          # Include both table-backed and view-backed models
+          is_view = ModelDetector.view_exists?(model)
+          has_data_source = is_view || (model.table_exists? && model.columns.present?)
+          next unless has_data_source
 
           add_model_relationships(output, model, models)
         end
@@ -253,6 +263,43 @@ module RailsLens
         output << '  }}%%'
       end
 
+      def add_visual_styling(output, models)
+        # Add class definitions for visual distinction between tables and views
+        output << ''
+        output << '  %% Entity Styling'
+
+        # Define styling classes
+        output << '  classDef tableEntity fill:#f9f9f9,stroke:#333,stroke-width:2px'
+        output << '  classDef viewEntity fill:#e6f3ff,stroke:#333,stroke-width:2px,stroke-dasharray: 5 5'
+        output << '  classDef materializedViewEntity fill:#ffe6e6,stroke:#333,stroke-width:3px,stroke-dasharray: 5 5'
+
+        # Apply styling to each model
+        models.each do |model|
+          next if model.abstract_class?
+
+          is_view = ModelDetector.view_exists?(model)
+          has_data_source = is_view || (model.table_exists? && model.columns.present?)
+          next unless has_data_source
+
+          model_display_name = format_model_name(model)
+
+          if is_view
+            view_metadata = ViewMetadata.new(model)
+            output << if view_metadata.materialized_view?
+                        "  class #{model_display_name} materializedViewEntity"
+                      else
+                        "  class #{model_display_name} viewEntity"
+                      end
+          else
+            output << "  class #{model_display_name} tableEntity"
+          end
+        rescue StandardError => e
+          Rails.logger.debug { "Warning: Could not apply styling to #{model.name}: #{e.message}" }
+        end
+
+        output << ''
+      end
+
       def group_models_by_database(models)
         grouped = Hash.new { |h, k| h[k] = [] }
 

data/lib/rails_lens/model_detector.rb

@@ -37,8 +37,81 @@ module RailsLens
         concrete_models.select { |model| model.superclass != ActiveRecord::Base && concrete_models.include?(model.superclass) }
       end
 
+      def view_backed_models
+        detect_models.select { |model| view_exists?(model) }
+      end
+
+      def table_backed_models
+        detect_models.reject { |model| view_exists?(model) }
+      end
+
+      def view_exists?(model_class)
+        return false if model_class.abstract_class?
+        return false unless model_class.table_name
+
+        # Cache view existence checks for performance
+        @view_cache ||= {}
+        cache_key = "#{model_class.connection.object_id}_#{model_class.table_name}"
+
+        return @view_cache[cache_key] if @view_cache.key?(cache_key)
+
+        @view_cache[cache_key] = check_view_existence(model_class)
+      end
+
       private
 
+      def check_view_existence(model_class)
+        connection = model_class.connection
+        table_name = model_class.table_name
+
+        case connection.adapter_name.downcase
+        when 'postgresql'
+          check_postgresql_view(connection, table_name)
+        when 'mysql', 'mysql2'
+          check_mysql_view(connection, table_name)
+        when 'sqlite', 'sqlite3'
+          check_sqlite_view(connection, table_name)
+        else
+          false # Unsupported adapter
+        end
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined
+        false # If we can't check, assume it's not a view
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def check_postgresql_view(connection, table_name)
+        # Check both regular views and materialized views
+        result = connection.exec_query(<<~SQL.squish, 'Check PostgreSQL View')
+          SELECT 1 FROM information_schema.views#{' '}
+          WHERE table_name = '#{connection.quote_string(table_name)}'
+          UNION ALL
+          SELECT 1 FROM pg_matviews#{' '}
+          WHERE matviewname = '#{connection.quote_string(table_name)}'
+          LIMIT 1
+        SQL
+        result.rows.any?
+      end
+
+      def check_mysql_view(connection, table_name)
+        result = connection.exec_query(<<~SQL.squish, 'Check MySQL View')
+          SELECT 1 FROM information_schema.views#{' '}
+          WHERE table_name = '#{connection.quote_string(table_name)}'
+          AND table_schema = DATABASE()
+          LIMIT 1
+        SQL
+        result.rows.any?
+      end
+
+      def check_sqlite_view(connection, table_name)
+        result = connection.exec_query(<<~SQL.squish, 'Check SQLite View')
+          SELECT 1 FROM sqlite_master#{' '}
+          WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
+          LIMIT 1
+        SQL
+        result.rows.any?
+      end
+      # rubocop:enable Naming/PredicateMethod
+
       def eager_load_models
         # Zeitwerk is always available in Rails 7+
         Zeitwerk::Loader.eager_load_all

data/lib/rails_lens/providers/base.rb

@@ -21,7 +21,7 @@ module RailsLens
       # For :schema type - returns a string with the schema content
       # For :section type - returns a hash with { title: String, content: String } or nil
       # For :notes type - returns an array of note strings
-      def process(model_class)
+      def process(model_class, connection = nil)
         raise NotImplementedError, "#{self.class} must implement #process"
       end
 

data/lib/rails_lens/providers/extension_notes_provider.rb

@@ -8,10 +8,11 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        RailsLens.config.extensions[:enabled] && model_has_table?(model_class)
+        # Only applicable to tables, not views
+        RailsLens.config.extensions[:enabled] && model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         results = ExtensionLoader.apply_extensions(model_class)
         results[:notes]
       end

data/lib/rails_lens/providers/extensions_provider.rb

@@ -7,7 +7,7 @@ module RailsLens
         :section
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         results = ExtensionLoader.apply_extensions(model_class)
 
         return nil if results[:annotations].empty?

data/lib/rails_lens/providers/index_notes_provider.rb

@@ -8,10 +8,11 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        model_has_table?(model_class)
+        # Only applicable to tables, not views
+        model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = Analyzers::IndexAnalyzer.new(model_class)
         analyzer.analyze
       end

data/lib/rails_lens/providers/inheritance_provider.rb

@@ -7,7 +7,7 @@ module RailsLens
         :section
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = Analyzers::Inheritance.new(model_class)
         content = analyzer.analyze
 

data/lib/rails_lens/providers/notes_provider_base.rb

@@ -9,14 +9,15 @@ module RailsLens
       end
 
       def applicable?(model_class)
-        model_has_table?(model_class)
+        # Only applicable to tables, not views
+        model_has_table?(model_class) && !ModelDetector.view_exists?(model_class)
       end
 
       def analyzer_class
         raise NotImplementedError, "#{self.class} must implement #analyzer_class"
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = analyzer_class.new(model_class)
         analyzer.analyze
       end

data/lib/rails_lens/providers/schema_provider.rb

@@ -11,17 +11,19 @@ module RailsLens
         true # Always applicable - handles both abstract and regular models
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
+        # Use passed connection or fall back to model's connection
+        conn = connection || model_class.connection
+
         if model_class.abstract_class?
           # For abstract classes, show database connection information in TOML format
-          connection = model_class.connection
-          adapter_name = connection.adapter_name
+          adapter_name = conn.adapter_name
 
           lines = []
 
           # Get connection name
           begin
-            connection_name = connection.pool.db_config.name
+            connection_name = conn.pool.db_config.name
             lines << "connection = \"#{connection_name}\""
           rescue StandardError
             lines << 'connection = "unknown"'
@@ -31,7 +33,7 @@ module RailsLens
 
           # Add database version information
           begin
-            db_version = connection.database_version
+            db_version = conn.database_version
             lines << "database_version = \"#{db_version}\""
           rescue StandardError
             lines << 'database_version = "unknown"'
@@ -39,7 +41,7 @@ module RailsLens
 
           # Add database name if available
           begin
-            db_name = connection.current_database
+            db_name = conn.current_database
             lines << "database_name = \"#{db_name}\"" if db_name
           rescue StandardError
             # Skip if can't get database name
@@ -51,8 +53,8 @@ module RailsLens
 
           lines.join("\n")
         else
-          # Add schema information for regular models
-          adapter = Connection.adapter_for(model_class)
+          # Add schema information for regular models (tables or views)
+          adapter = Connection.adapter_for(model_class, conn)
           adapter.generate_annotation(model_class)
         end
       end

data/lib/rails_lens/providers/section_provider_base.rb

@@ -12,7 +12,7 @@ module RailsLens
         raise NotImplementedError, "#{self.class} must implement #analyzer_class"
       end
 
-      def process(model_class)
+      def process(model_class, connection = nil)
         analyzer = analyzer_class.new(model_class)
         content = analyzer.analyze
 

data/lib/rails_lens/providers/view_notes_provider.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    # View-specific notes provider that wraps the Notes analyzer for views only
+    class ViewNotesProvider < Base
+      def type
+        :notes
+      end
+
+      def applicable?(model_class)
+        # Only applicable to views
+        model_has_table?(model_class) && ModelDetector.view_exists?(model_class)
+      end
+
+      def process(model_class, connection = nil)
+        analyzer = Analyzers::Notes.new(model_class)
+        analyzer.analyze
+      end
+    end
+  end
+end

data/lib/rails_lens/providers/view_provider.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Providers
+    class ViewProvider < SectionProviderBase
+      def applicable?(model_class)
+        # Only applicable for models backed by views
+        ModelDetector.view_exists?(model_class)
+      end
+
+      def process(model_class, connection = nil)
+        view_metadata = ViewMetadata.new(model_class)
+
+        return nil unless view_metadata.view_exists?
+
+        {
+          title: '== View Information',
+          content: generate_view_content(view_metadata)
+        }
+      end
+
+      private
+
+      def generate_view_content(view_metadata)
+        lines = []
+
+        # View type (regular or materialized)
+        if view_metadata.view_type
+          lines << "View Type: #{view_metadata.view_type}"
+        end
+
+        # Updatable status
+        lines << "Updatable: #{view_metadata.updatable? ? 'Yes' : 'No'}"
+
+        # Dependencies
+        dependencies = view_metadata.dependencies
+        if dependencies.any?
+          lines << "Dependencies: #{dependencies.join(', ')}"
+        end
+
+        # Refresh strategy for materialized views
+        if view_metadata.materialized_view? && view_metadata.refresh_strategy
+          lines << "Refresh Strategy: #{view_metadata.refresh_strategy}"
+        end
+
+        # Last refreshed timestamp for materialized views
+        if view_metadata.materialized_view? && view_metadata.last_refreshed
+          lines << "Last Refreshed: #{view_metadata.last_refreshed}"
+        end
+
+        # View definition (truncated for readability)
+        if view_metadata.view_definition
+          definition = view_metadata.view_definition
+          # Truncate long definitions
+          if definition.length > 200
+            definition = "#{definition[0..200]}..."
+          end
+          # Remove extra whitespace and newlines
+          definition = definition.gsub(/\s+/, ' ').strip
+          lines << "Definition: #{definition}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_lens/schema/adapters/mysql.rb

@@ -8,7 +8,15 @@ module RailsLens
           'MySQL'
         end
 
-        def generate_annotation(_model_class)
+        def generate_annotation(model_class)
+          if model_class && ModelDetector.view_exists?(model_class)
+            generate_view_annotation(model_class)
+          else
+            generate_table_annotation(model_class)
+          end
+        end
+
+        def generate_table_annotation(_model_class)
           lines = []
           lines << "table = \"#{table_name}\""
           lines << "database_dialect = \"#{database_dialect}\""
@@ -37,6 +45,27 @@ module RailsLens
           lines.join("\n")
         end
 
+        def generate_view_annotation(model_class)
+          lines = []
+          lines << "view = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Fetch all view metadata in a single query
+          view_info = fetch_view_metadata
+
+          if view_info
+            lines << "view_type = \"#{view_info[:type]}\"" if view_info[:type]
+            lines << "updatable = #{view_info[:updatable]}"
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_view_dependencies_toml(lines, view_info)
+
+          lines.join("\n")
+        end
+
         protected
 
         def format_column(column)
@@ -273,6 +302,89 @@ module RailsLens
           # MySQL specific errors
           Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
+
+        def add_view_dependencies_toml(lines, view_info)
+          return unless view_info && view_info[:dependencies]
+
+          dependencies = view_info[:dependencies]
+          return if dependencies.empty?
+
+          lines << ''
+          lines << "view_dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
+        end
+
+        # MySQL-specific view methods
+        public
+
+        # Fetch all view metadata in a single consolidated query
+        def fetch_view_metadata
+          result = connection.exec_query(<<~SQL.squish, 'MySQL View Metadata')
+            SELECT#{' '}
+              v.is_updatable,
+              COALESCE(
+                (
+                  SELECT GROUP_CONCAT(DISTINCT vtu.table_name ORDER BY vtu.table_name)
+                  FROM information_schema.view_table_usage vtu
+                  WHERE vtu.view_schema = DATABASE()
+                  AND vtu.view_name = '#{connection.quote_string(table_name)}'
+                ),
+                ''
+              ) as dependencies
+            FROM information_schema.views v
+            WHERE v.table_schema = DATABASE()
+            AND v.table_name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          return nil if result.rows.empty?
+
+          row = result.rows.first
+          {
+            type: 'regular', # MySQL only supports regular views
+            updatable: row[0] == 'YES',
+            dependencies: row[1].to_s.split(',').reject(&:empty?)
+          }
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
+          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          nil
+        end
+
+        # Legacy methods - kept for backward compatibility but now use consolidated query
+        def view_type
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:type)
+        end
+
+        def view_updatable?
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:updatable) || false
+        end
+
+        def view_dependencies
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:dependencies) || []
+        end
+
+        def view_definition
+          result = connection.exec_query(<<~SQL.squish, 'MySQL View Definition')
+            SELECT view_definition FROM information_schema.views
+            WHERE table_schema = DATABASE()
+            AND table_name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          result.rows.first&.first&.strip
+        rescue ActiveRecord::StatementInvalid, Mysql2::Error
+          nil
+        end
+
+        def view_refresh_strategy
+          nil # MySQL doesn't have materialized views
+        end
+
+        def view_last_refreshed
+          nil # MySQL doesn't have materialized views
+        end
       end
     end
   end

data/lib/rails_lens/schema/adapters/postgresql.rb

@@ -8,7 +8,15 @@ module RailsLens
           'PostgreSQL'
         end
 
-        def generate_annotation(_model_class)
+        def generate_annotation(model_class)
+          if model_class && ModelDetector.view_exists?(model_class)
+            generate_view_annotation(model_class)
+          else
+            generate_table_annotation(model_class)
+          end
+        end
+
+        def generate_table_annotation(_model_class)
           lines = []
           lines << "table = \"#{table_name}\""
           lines << "database_dialect = \"#{database_dialect}\""
@@ -26,6 +34,35 @@ module RailsLens
           lines.join("\n")
         end
 
+        def generate_view_annotation(model_class)
+          lines = []
+          lines << "view = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Add schema information for PostgreSQL
+          lines << "schema = \"#{schema_name}\"" if schema_name && schema_name != 'public'
+
+          # Fetch all view metadata in a single query
+          view_info = fetch_view_metadata
+
+          if view_info
+            lines << "view_type = \"#{view_info[:type]}\"" if view_info[:type]
+            lines << "updatable = #{view_info[:updatable]}"
+
+            if view_info[:type] == 'materialized'
+              lines << 'materialized = true'
+              lines << 'refresh_strategy = "manual"'
+            end
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_view_dependencies_toml(lines, view_info)
+
+          lines.join("\n")
+        end
+
         protected
 
         def schema_name
@@ -191,6 +228,131 @@ module RailsLens
           lines << ''
           lines << "table_comment = \"#{comment.gsub('"', '\"')}\""
         end
+
+        def add_view_dependencies_toml(lines, view_info)
+          return unless view_info && view_info[:dependencies]
+
+          dependencies = view_info[:dependencies]
+          return if dependencies.empty?
+
+          lines << ''
+          lines << "view_dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
+        end
+
+        # PostgreSQL-specific view methods
+        public
+
+        # Fetch all view metadata in a single consolidated query
+        def fetch_view_metadata
+          result = connection.exec_query(<<~SQL.squish, 'PostgreSQL View Metadata')
+            WITH view_info AS (
+              -- Check for materialized view
+              SELECT#{' '}
+                'materialized' as view_type,
+                false as is_updatable,
+                mv.matviewname as view_name
+              FROM pg_matviews mv
+              WHERE mv.matviewname = '#{connection.quote_string(table_name)}'
+            #{'  '}
+              UNION ALL
+            #{'  '}
+              -- Check for regular view
+              SELECT#{' '}
+                'regular' as view_type,
+                CASE WHEN v.is_updatable = 'YES' THEN true ELSE false END as is_updatable,
+                v.table_name as view_name
+              FROM information_schema.views v
+              WHERE v.table_name = '#{connection.quote_string(table_name)}'
+            ),
+            dependencies AS (
+              SELECT DISTINCT c2.relname as dependency_name
+              FROM pg_class c1
+              JOIN pg_depend d ON c1.oid = d.objid
+              JOIN pg_class c2 ON d.refobjid = c2.oid
+              WHERE c1.relname = '#{connection.quote_string(table_name)}'
+              AND c1.relkind IN ('v', 'm')
+              AND c2.relkind IN ('r', 'v', 'm')
+              AND d.deptype = 'n'
+            )
+            SELECT#{' '}
+              vi.view_type,
+              vi.is_updatable,
+              COALESCE(
+                (SELECT array_agg(dependency_name ORDER BY dependency_name) FROM dependencies),
+                ARRAY[]::text[]
+              ) as dependencies
+            FROM view_info vi
+            LIMIT 1
+          SQL
+
+          return nil if result.rows.empty?
+
+          row = result.rows.first
+          {
+            type: row[0],
+            updatable: ['t', true].include?(row[1]),
+            dependencies: row[2] || []
+          }
+        rescue ActiveRecord::StatementInvalid, PG::Error => e
+          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          nil
+        end
+
+        # Legacy methods - kept for backward compatibility but now use consolidated query
+        def view_type
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:type)
+        end
+
+        def view_updatable?
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:updatable) || false
+        end
+
+        def view_dependencies
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:dependencies) || []
+        end
+
+        def view_definition
+          result = if view_type == 'materialized'
+                     connection.exec_query(<<~SQL.squish, 'PostgreSQL Materialized View Definition')
+                       SELECT definition FROM pg_matviews
+                       WHERE matviewname = '#{connection.quote_string(table_name)}'
+                       LIMIT 1
+                     SQL
+                   else
+                     connection.exec_query(<<~SQL.squish, 'PostgreSQL View Definition')
+                       SELECT view_definition FROM information_schema.views
+                       WHERE table_name = '#{connection.quote_string(table_name)}'
+                       LIMIT 1
+                     SQL
+                   end
+
+          result.rows.first&.first&.strip
+        rescue ActiveRecord::StatementInvalid, PG::Error
+          nil
+        end
+
+        def view_refresh_strategy
+          view_type == 'materialized' ? 'manual' : nil
+        end
+
+        def view_last_refreshed
+          return nil unless view_type == 'materialized'
+
+          # Get the last refresh time from pg_stat_user_tables
+          result = connection.exec_query(<<~SQL.squish, 'PostgreSQL Materialized View Last Refresh')
+            SELECT COALESCE(last_vacuum, last_autovacuum) as last_refreshed
+            FROM pg_stat_user_tables
+            WHERE relname = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          result.rows.first&.first
+        rescue ActiveRecord::StatementInvalid, PG::Error
+          nil
+        end
       end
     end
   end

data/lib/rails_lens/schema/adapters/sqlite3.rb

@@ -8,7 +8,15 @@ module RailsLens
           'SQLite'
         end
 
-        def generate_annotation(_model_class)
+        def generate_annotation(model_class)
+          if model_class && ModelDetector.view_exists?(model_class)
+            generate_view_annotation(model_class)
+          else
+            generate_table_annotation(model_class)
+          end
+        end
+
+        def generate_table_annotation(_model_class)
           lines = []
           lines << "table = \"#{table_name}\""
           lines << "database_dialect = \"#{database_dialect}\""
@@ -22,6 +30,27 @@ module RailsLens
           lines.join("\n")
         end
 
+        def generate_view_annotation(model_class)
+          lines = []
+          lines << "view = \"#{table_name}\""
+          lines << "database_dialect = \"#{database_dialect}\""
+
+          # Fetch all view metadata in a single query
+          view_info = fetch_view_metadata
+
+          if view_info
+            lines << "view_type = \"#{view_info[:type]}\"" if view_info[:type]
+            lines << "updatable = #{view_info[:updatable]}"
+          end
+
+          lines << ''
+
+          add_columns_toml(lines)
+          add_view_dependencies_toml(lines, view_info)
+
+          lines.join("\n")
+        end
+
         protected
 
         def format_column(column)
@@ -90,6 +119,90 @@ module RailsLens
             Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
           end
         end
+
+        def add_view_dependencies_toml(lines, view_info)
+          return unless view_info && view_info[:dependencies]
+
+          dependencies = view_info[:dependencies]
+          return if dependencies.empty?
+
+          lines << ''
+          lines << "view_dependencies = [#{dependencies.map { |d| "\"#{d}\"" }.join(', ')}]"
+        end
+
+        # SQLite-specific view methods
+        public
+
+        # Fetch all view metadata in a single consolidated query
+        def fetch_view_metadata
+          result = connection.exec_query(<<~SQL.squish, 'SQLite View Metadata')
+            SELECT sql FROM sqlite_master#{' '}
+            WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          return nil if result.rows.empty?
+
+          definition = result.rows.first&.first&.strip
+          return nil unless definition
+
+          # Parse dependencies from the SQL definition
+          tables = []
+          definition.scan(/(?:FROM|JOIN)\s+(\w+)/i) do |match|
+            table_name_match = match[0]
+            # Exclude the view itself and common SQL keywords
+            if !table_name_match.downcase.in?(%w[select where order group having limit offset]) &&
+               tables.exclude?(table_name_match) &&
+               table_name_match != table_name
+              tables << table_name_match
+            end
+          end
+
+          {
+            type: 'regular',  # SQLite only supports regular views
+            updatable: false, # SQLite views are generally read-only
+            dependencies: tables.sort
+          }
+        rescue ActiveRecord::StatementInvalid, SQLite3::Exception => e
+          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          nil
+        end
+
+        # Legacy methods - kept for backward compatibility but now use consolidated query
+        def view_type
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:type)
+        end
+
+        def view_updatable?
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:updatable) || false
+        end
+
+        def view_dependencies
+          @view_metadata ||= fetch_view_metadata
+          @view_metadata&.dig(:dependencies) || []
+        end
+
+        def view_definition
+          result = connection.exec_query(<<~SQL.squish, 'SQLite View Definition')
+            SELECT sql FROM sqlite_master#{' '}
+            WHERE type = 'view' AND name = '#{connection.quote_string(table_name)}'
+            LIMIT 1
+          SQL
+
+          result.rows.first&.first&.strip
+        rescue ActiveRecord::StatementInvalid, SQLite3::Exception
+          nil
+        end
+
+        def view_refresh_strategy
+          nil # SQLite doesn't have materialized views
+        end
+
+        def view_last_refreshed
+          nil # SQLite doesn't have materialized views
+        end
       end
     end
   end

data/lib/rails_lens/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsLens
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/lib/rails_lens/view_metadata.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Extracts and manages metadata for database views and materialized views
+  class ViewMetadata
+    attr_reader :model_class, :connection, :table_name
+
+    def initialize(model_class)
+      @model_class = model_class
+      @connection = model_class.connection
+      @table_name = model_class.table_name
+      @adapter_name = connection.adapter_name.downcase
+      @adapter = create_adapter
+    end
+
+    def view_type
+      return nil unless view_exists?
+
+      @adapter&.view_type
+    end
+
+    def view_exists?
+      ModelDetector.view_exists?(model_class)
+    end
+
+    def materialized_view?
+      view_type == 'materialized'
+    end
+
+    def regular_view?
+      view_type == 'regular'
+    end
+
+    def updatable?
+      return false unless view_exists?
+
+      @adapter&.view_updatable? || false
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined
+      false
+    end
+
+    def dependencies
+      return [] unless view_exists?
+
+      @adapter&.view_dependencies || []
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined
+      []
+    end
+
+    def refresh_strategy
+      return nil unless materialized_view?
+
+      @adapter&.view_refresh_strategy
+    end
+
+    def last_refreshed
+      return nil unless materialized_view?
+
+      @adapter&.view_last_refreshed
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined
+      nil
+    end
+
+    def view_definition
+      return nil unless view_exists?
+
+      @adapter&.view_definition
+    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotDefined
+      nil
+    end
+
+    def to_h
+      {
+        view_type: view_type,
+        updatable: updatable?,
+        dependencies: dependencies,
+        refresh_strategy: refresh_strategy,
+        last_refreshed: last_refreshed,
+        view_definition: view_definition
+      }.compact
+    end
+
+    private
+
+    def create_adapter
+      case @adapter_name
+      when 'postgresql'
+        Schema::Adapters::Postgresql.new(connection, table_name)
+      when 'mysql', 'mysql2'
+        Schema::Adapters::Mysql.new(connection, table_name)
+      when 'sqlite', 'sqlite3'
+        Schema::Adapters::Sqlite3.new(connection, table_name)
+      else
+        nil
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_lens
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -219,6 +219,8 @@ files:
 - lib/rails_lens/providers/performance_notes_provider.rb
 - lib/rails_lens/providers/schema_provider.rb
 - lib/rails_lens/providers/section_provider_base.rb
+- lib/rails_lens/providers/view_notes_provider.rb
+- lib/rails_lens/providers/view_provider.rb
 - lib/rails_lens/railtie.rb
 - lib/rails_lens/rake_bootstrapper.rb
 - lib/rails_lens/route/annotator.rb
@@ -237,6 +239,7 @@ files:
 - lib/rails_lens/tasks/routes.rake
 - lib/rails_lens/tasks/schema.rake
 - lib/rails_lens/version.rb
+- lib/rails_lens/view_metadata.rb
 homepage: https://github.com/seuros/rails_lens
 licenses:
 - MIT