rails_lens 0.2.2 → 0.2.4

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

@@ -104,8 +104,8 @@ module RailsLens
           return [] unless adapter_name == 'PostgreSQL'
 
           connection.select_values(<<-SQL.squish)
-            SELECT schema_name#{' '}
-            FROM information_schema.schemata#{' '}
+            SELECT schema_name
+            FROM information_schema.schemata
             WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
             ORDER BY schema_name
           SQL

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,129 @@ 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/schema/annotation_manager.rb

@@ -61,7 +61,33 @@ module RailsLens
 
       def generate_annotation
         pipeline = AnnotationPipeline.new
-        results = pipeline.process(model_class)
+
+        # If we have a connection set by annotate_all, use it to process all providers
+        if @connection
+          results = { schema: nil, sections: [], notes: [] }
+
+          pipeline.instance_variable_get(:@providers).each do |provider|
+            next unless provider.applicable?(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))
+              end
+            rescue StandardError => e
+              warn "Provider #{provider.class} error for #{model_class}: #{e.message}"
+            end
+          end
+        else
+          # Fall back to normal processing without connection management
+          results = pipeline.process(model_class)
+        end
 
         annotation = Annotation.new
 
@@ -105,51 +131,77 @@ module RailsLens
 
         results = { annotated: [], skipped: [], failed: [] }
 
-        models.each do |model|
-          # Ensure model is actually a class, not a hash or other object
-          unless model.is_a?(Class)
-            results[:failed] << { model: model.inspect, error: "Expected Class, got #{model.class}" }
-            next
-          end
+        # Group models by their connection pool to process each database separately
+        models_by_connection_pool = models.group_by do |model|
+          model.connection_pool
+        rescue StandardError
+          nil # Models without connection pools will be processed separately
+        end
 
-          # Skip models without tables or with missing tables (but not abstract classes)
-          unless model.abstract_class? || model.table_exists?
-            results[:skipped] << model.name
-            warn "Skipping #{model.name} - table does not exist" if options[:verbose]
-            next
+        models_by_connection_pool.each do |connection_pool, pool_models|
+          if connection_pool
+            # Process all models for this database using a single connection
+            connection_pool.with_connection do |connection|
+              pool_models.each do |model|
+                process_model_with_connection(model, connection, results, options)
+              end
+            end
+          else
+            # Process models without connection pools individually
+            pool_models.each do |model|
+              process_model_with_connection(model, nil, results, options)
+            end
           end
+        end
 
-          manager = new(model)
-
-          # Determine file path based on options
-          file_path = if options[:models_path]
-                        File.join(options[:models_path], "#{model.name.underscore}.rb")
-                      else
-                        nil # Use default model_file_path
-                      end
+        results
+      end
 
-          # Allow external files when models_path is provided (for testing)
-          allow_external = options[:models_path].present?
+      def self.process_model_with_connection(model, connection, results, options)
+        # Ensure model is actually a class, not a hash or other object
+        unless model.is_a?(Class)
+          results[:failed] << { model: model.inspect, error: "Expected Class, got #{model.class}" }
+          return
+        end
 
-          if manager.annotate_file(file_path, allow_external_files: allow_external)
-            results[:annotated] << model.name
-          else
-            results[:skipped] << model.name
-          end
-        rescue ActiveRecord::StatementInvalid => e
-          # Handle database-related errors (missing tables, schemas, etc.)
+        # Skip models without tables or with missing tables (but not abstract classes)
+        unless model.abstract_class? || model.table_exists?
           results[:skipped] << model.name
-          warn "Skipping #{model.name} - database error: #{e.message}" if options[:verbose]
-        rescue StandardError => e
-          model_name = if model.is_a?(Class) && model.respond_to?(:name)
-                         model.name
-                       else
-                         model.inspect
-                       end
-          results[:failed] << { model: model_name, error: e.message }
+          warn "Skipping #{model.name} - table does not exist" if options[:verbose]
+          return
         end
 
-        results
+        manager = new(model)
+
+        # Set the connection in the manager if provided
+        manager.instance_variable_set(:@connection, connection) if connection
+
+        # Determine file path based on options
+        file_path = if options[:models_path]
+                      File.join(options[:models_path], "#{model.name.underscore}.rb")
+                    else
+                      nil # Use default model_file_path
+                    end
+
+        # Allow external files when models_path is provided (for testing)
+        allow_external = options[:models_path].present?
+
+        if manager.annotate_file(file_path, allow_external_files: allow_external)
+          results[:annotated] << model.name
+        else
+          results[:skipped] << model.name
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        # Handle database-related errors (missing tables, schemas, etc.)
+        results[:skipped] << model.name
+        warn "Skipping #{model.name} - database error: #{e.message}" if options[:verbose]
+      rescue StandardError => e
+        model_name = if model.is_a?(Class) && model.respond_to?(:name)
+                       model.name
+                     else
+                       model.inspect
+                     end
+        results[:failed] << { model: model_name, error: e.message }
       end
 
       def self.remove_all(options = {})

data/lib/rails_lens/version.rb

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