rails_lens 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41ebdd3c52cca1c77790aa896dcc5962acb92c44eec90a2dceeda98f310aefb7
-  data.tar.gz: 72e49695a796e9d030fd80aedab53d7dea055db82c98e8023a6a2bb4293e139f
+  metadata.gz: 7b17142784a27f1ffd45512665eea05a135e1c97b0e1dcc38505f8a07b067ad0
+  data.tar.gz: 9ae11ad7619a74b5662a8b6bb2e767c33ad1523f5c6a2cf590cb809389d0ab9e
 SHA512:
-  metadata.gz: d0e890e0ae21326d6176542668277a1c8e5d6336f013dec8cc8854f892c0136c6a40fb4557789dc661c47de70fbf82c0e59dcc75769b4a41e613f681e75f9a9f
-  data.tar.gz: d5c0d6aaecbd3a46986cc86507b3550347bd09e69f4126721fdb9acec05110a2f622fa2555d8c37151144efdd89ef5b87129576d3bc66c02f2b8cdd3404fcb77
+  metadata.gz: 7ebe5bfc79a4415138fc65f03f393796780e514a32f5226c0fbf66acb2d4d6dd2ac5e1b8878429f3383023f7489b5b40a35d9930876d8ffecf563a14f8bdbfb5
+  data.tar.gz: 2b40b476f42536db544130081063e3a0e992bbeda51d4ff993b4b3be3d0b8073a5ea00c3df98d57321de995d3dca6120f335fc9c2fca652abe3794cc4c704cdd

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.2.4](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.3...rails_lens/v0.2.4) (2025-07-31)
+
+
+### Bug Fixes
+
+* centralize connection management to prevent "too many clients" errors ([#10](https://github.com/seuros/rails_lens/issues/10)) ([1f9adf9](https://github.com/seuros/rails_lens/commit/1f9adf9b7dd0648add324492189c1322726da52f))
+
+## [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/generated_columns.rb

@@ -25,7 +25,7 @@ module RailsLens
       def detect_generated_columns
         # PostgreSQL system query to find generated columns
         sql = <<-SQL.squish
-          SELECT#{' '}
+          SELECT
             a.attname AS column_name,
             pg_get_expr(d.adbin, d.adrelid) AS generation_expression
           FROM pg_attribute a

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