dbviewer 0.3.1 → 0.3.3

data/lib/dbviewer/database_manager.rb

@@ -1,114 +1,71 @@
+require "dbviewer/cache_manager"
+require "dbviewer/table_metadata_manager"
+require "dbviewer/dynamic_model_factory"
+require "dbviewer/query_executor"
+require "dbviewer/error_handler"
+
 module Dbviewer
   # DatabaseManager handles all database interactions for the DBViewer engine
   # It provides methods to access database structure and data
   class DatabaseManager
     attr_reader :connection, :adapter_name
 
-    # Default number of records per page if not specified
-    DEFAULT_PER_PAGE = 20
-
-    # Max number of records to return in any query for safety
-    MAX_RECORDS = 10000
-
-    # Cache for dynamically created AR models
-    @@dynamic_models = {}
-
-    # Cache for table column info
-    @@table_columns_cache = {}
+    # Initialize the database manager
+    def initialize
+      ensure_connection
+      @cache_manager = CacheManager.new(self.class.configuration)
+      @table_metadata_manager = TableMetadataManager.new(@connection, @cache_manager)
+      @dynamic_model_factory = DynamicModelFactory.new(@connection, @cache_manager)
+      @query_executor = QueryExecutor.new(@connection, self.class.configuration)
+      reset_cache_if_needed
+    end
 
-    # Cache for table metadata
-    @@table_metadata_cache = {}
+    # Get configuration from class method or Dbviewer
+    def self.configuration
+      Dbviewer.configuration
+    end
 
-    # Cache expiration time in seconds (5 minutes)
-    CACHE_EXPIRY = 300
+    # Get default per page from configuration
+    def self.default_per_page
+      configuration.default_per_page
+    end
 
-    # Last cache reset time
-    @@cache_last_reset = Time.now
+    # Get max records from configuration
+    def self.max_records
+      configuration.max_records
+    end
 
-    def initialize
-      ensure_connection
-      reset_cache_if_needed
+    # Get cache expiry from configuration
+    def self.cache_expiry
+      configuration.cache_expiry
     end
 
     # Returns a sorted list of all tables in the database
     # @return [Array<String>] List of table names
     def tables
-      return [] unless connection.respond_to?(:tables)
-
-      begin
-        # Get and sort tables, cache is handled at the database adapter level
-        connection.tables.sort
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving tables: #{e.message}")
-        []
-      end
+      @table_metadata_manager.tables
     end
 
     # Returns column information for a specific table
     # @param table_name [String] Name of the table
     # @return [Array<Hash>] List of column details with name, type, null, default
     def table_columns(table_name)
-      return [] if table_name.blank?
-
-      # Return from cache if available
-      return @@table_columns_cache[table_name] if @@table_columns_cache[table_name]
-
-      begin
-        columns = connection.columns(table_name).map do |column|
-          {
-            name: column.name,
-            type: column.type,
-            null: column.null,
-            default: column.default,
-            primary: column.name == primary_key(table_name)
-          }
-        end
-
-        # Cache the result
-        @@table_columns_cache[table_name] = columns
-        columns
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving columns for table #{table_name}: #{e.message}")
-        []
-      end
+      @table_metadata_manager.table_columns(table_name)
     end
 
     # Get detailed metadata about a table (primary keys, indexes, foreign keys)
     # @param table_name [String] Name of the table
     # @return [Hash] Table metadata
     def table_metadata(table_name)
-      return {} if table_name.blank?
-
-      # Return from cache if available
-      return @@table_metadata_cache[table_name] if @@table_metadata_cache[table_name]
-
-      begin
-        metadata = {
-          primary_key: primary_key(table_name),
-          indexes: fetch_indexes(table_name),
-          foreign_keys: fetch_foreign_keys(table_name)
-        }
-
-        # Cache the result
-        @@table_metadata_cache[table_name] = metadata
-        metadata
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving metadata for table #{table_name}: #{e.message}")
-        { primary_key: nil, indexes: [], foreign_keys: [] }
-      end
+      @table_metadata_manager.table_metadata(table_name)
     end
 
     # Get the total count of records in a table
     # @param table_name [String] Name of the table
     # @return [Integer] Number of records
     def table_count(table_name)
-      begin
-        model = get_model_for(table_name)
-        model.count
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting records in table #{table_name}: #{e.message}")
-        0
-      end
+      model = get_model_for(table_name)
+      model.count
     end
 
     # Get records from a table with pagination and sorting
@@ -120,13 +77,9 @@ module Dbviewer
     # @return [ActiveRecord::Result] Result set with columns and rows
     def table_records(table_name, page = 1, order_by = nil, direction = "ASC", per_page = nil)
       page = [ 1, page.to_i ].max
-
-      # Use class method if defined, otherwise fall back to constant
-      default_per_page = self.class.respond_to?(:default_per_page) ? self.class.default_per_page : DEFAULT_PER_PAGE
-      max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-
+      default_per_page = self.class.default_per_page
+      max_records = self.class.max_records
       per_page = (per_page || default_per_page).to_i
-      per_page = default_per_page if per_page <= 0
 
       # Ensure we don't fetch too many records for performance/memory reasons
       per_page = [ per_page, max_records ].min
@@ -143,8 +96,11 @@ module Dbviewer
       # Apply pagination
       records = query.limit(per_page).offset((page - 1) * per_page)
 
-      # Transform the ActiveRecord::Relation to the format expected by the application
-      to_result_set(records, table_name)
+      # Get column names for consistent ordering
+      column_names = table_columns(table_name).map { |c| c[:name] }
+
+      # Format results
+      @query_executor.to_result_set(records, column_names)
     end
 
     # Get the number of records in a table (alias for table_count)
@@ -158,24 +114,14 @@ module Dbviewer
     # @param table_name [String] Name of the table
     # @return [Integer] Number of columns
     def column_count(table_name)
-      begin
-        table_columns(table_name).size
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting columns in table #{table_name}: #{e.message}")
-        0
-      end
+      table_columns(table_name).size
     end
 
     # Get the primary key of a table
     # @param table_name [String] Name of the table
     # @return [String, nil] Primary key column name or nil if not found
     def primary_key(table_name)
-      begin
-        connection.primary_key(table_name)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving primary key for table #{table_name}: #{e.message}")
-        nil
-      end
+      @table_metadata_manager.primary_key(table_name)
     end
 
     # Check if a column exists in a table
@@ -183,15 +129,7 @@ module Dbviewer
     # @param column_name [String] Name of the column
     # @return [Boolean] true if column exists, false otherwise
     def column_exists?(table_name, column_name)
-      return false if table_name.blank? || column_name.blank?
-
-      begin
-        columns = table_columns(table_name)
-        columns.any? { |col| col[:name].to_s == column_name.to_s }
-      rescue => e
-        Rails.logger.error("[DBViewer] Error checking column existence for #{column_name} in #{table_name}: #{e.message}")
-        false
-      end
+      @table_metadata_manager.column_exists?(table_name, column_name)
     end
 
     # Execute a raw SQL query after validating for safety
@@ -199,31 +137,7 @@ module Dbviewer
     # @return [ActiveRecord::Result] Result set with columns and rows
     # @raise [StandardError] If the query is invalid or unsafe
     def execute_query(sql)
-      # Use the SqlValidator class to validate and normalize the SQL query
-      begin
-        # Validate and normalize the SQL
-        normalized_sql = ::Dbviewer::SqlValidator.validate!(sql.to_s)
-
-        # Get max records from configuration if available
-        max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-
-        # Add a safety limit if not already present
-        unless normalized_sql =~ /\bLIMIT\s+\d+\s*$/i
-          normalized_sql = "#{normalized_sql} LIMIT #{max_records}"
-        end
-
-        # Log and execute the query
-        Rails.logger.debug("[DBViewer] Executing SQL query: #{normalized_sql}")
-        start_time = Time.now
-        result = connection.exec_query(normalized_sql)
-        duration = Time.now - start_time
-
-        Rails.logger.debug("[DBViewer] Query completed in #{duration.round(2)}s, returned #{result.rows.size} rows")
-        result
-      rescue => e
-        Rails.logger.error("[DBViewer] SQL query error: #{e.message} for query: #{sql}")
-        raise e
-      end
+      @query_executor.execute_query(sql)
     end
 
     # Execute a SQLite PRAGMA command without adding a LIMIT clause
@@ -231,16 +145,7 @@ module Dbviewer
     # @return [ActiveRecord::Result] Result set with the PRAGMA value
     # @raise [StandardError] If the query is invalid or cannot be executed
     def execute_sqlite_pragma(pragma)
-      begin
-        sql = "PRAGMA #{pragma}"
-        Rails.logger.debug("[DBViewer] Executing SQLite pragma: #{sql}")
-        result = connection.exec_query(sql)
-        Rails.logger.debug("[DBViewer] Pragma completed, returned #{result.rows.size} rows")
-        result
-      rescue => error
-        Rails.logger.error("[DBViewer] SQLite pragma error: #{error.message} for pragma: #{pragma}")
-        raise error
-      end
+      @query_executor.execute_sqlite_pragma(pragma)
     end
 
     # Query a table with more granular control using ActiveRecord
@@ -252,76 +157,47 @@ module Dbviewer
     # @param where [String, Hash] Where conditions
     # @return [ActiveRecord::Result] Result set with columns and rows
     def query_table(table_name, select: nil, order: nil, limit: nil, offset: nil, where: nil)
-      begin
-        model = get_model_for(table_name)
-        query = model.all
-
-        query = query.select(select) if select.present?
-        query = query.where(where) if where.present?
-        query = query.order(order) if order.present?
-
-        # Get max records from configuration if available
-        max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-        query = query.limit([ limit || max_records, max_records ].min) # Apply safety limit
-        query = query.offset(offset) if offset.present?
-
-        to_result_set(query, table_name)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error querying table #{table_name}: #{e.message}")
-        raise e
+      model = get_model_for(table_name)
+      query = model.all
+
+      query = query.select(select) if select.present?
+      query = query.where(where) if where.present?
+      query = query.order(order) if order.present?
+
+      # Get max records from configuration
+      max_records = self.class.max_records
+      query = query.limit([ limit || max_records, max_records ].min) # Apply safety limit
+      query = query.offset(offset) if offset.present?
+
+      # Get column names for the result set
+      column_names = if select.is_a?(Array)
+        select
+      elsif select.is_a?(String) && !select.include?("*")
+        select.split(",").map(&:strip)
+      else
+        table_columns(table_name).map { |c| c[:name] }
       end
+
+      @query_executor.to_result_set(query, column_names)
     end
 
     # Get table indexes
     # @param table_name [String] Name of the table
     # @return [Array<Hash>] List of indexes with details
     def fetch_indexes(table_name)
-      return [] if table_name.blank?
-
-      begin
-        # Only some adapters support index retrieval
-        if connection.respond_to?(:indexes)
-          connection.indexes(table_name).map do |index|
-            {
-              name: index.name,
-              columns: index.columns,
-              unique: index.unique
-            }
-          end
-        else
-          []
-        end
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving indexes for table #{table_name}: #{e.message}")
-        []
-      end
+      @table_metadata_manager.fetch_indexes(table_name)
     end
 
     # Get foreign keys
     # @param table_name [String] Name of the table
     # @return [Array<Hash>] List of foreign keys with details
     def fetch_foreign_keys(table_name)
-      return [] if table_name.blank?
-
-      begin
-        # Only some adapters support foreign key retrieval
-        if connection.respond_to?(:foreign_keys)
-          connection.foreign_keys(table_name).map do |fk|
-            {
-              name: fk.name,
-              from_table: fk.from_table,
-              to_table: fk.to_table,
-              column: fk.column,
-              primary_key: fk.primary_key
-            }
-          end
-        else
-          []
-        end
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving foreign keys for table #{table_name}: #{e.message}")
-        []
-      end
+      @table_metadata_manager.fetch_foreign_keys(table_name)
+    end
+
+    # Clear all caches - useful when schema changes are detected
+    def clear_all_caches
+      @cache_manager.clear_all
     end
 
     private
@@ -331,120 +207,23 @@ module Dbviewer
     def ensure_connection
       return @connection if @connection
 
-      begin
+      ErrorHandler.with_error_handling("establishing database connection") do
         @connection = ActiveRecord::Base.connection
         @adapter_name = @connection.adapter_name.downcase
         @connection
-      rescue => e
-        Rails.logger.error("[DBViewer] Database connection error: #{e.message}")
-        raise e
       end
     end
 
     # Reset caches if they've been around too long
     def reset_cache_if_needed
-      # Get cache expiry from configuration if available
-      cache_expiry = self.class.respond_to?(:cache_expiry) ? self.class.cache_expiry : CACHE_EXPIRY
-
-      if Time.now - @@cache_last_reset > cache_expiry
-        @@table_columns_cache = {}
-        @@table_metadata_cache = {}
-        @@cache_last_reset = Time.now
-        Rails.logger.debug("[DBViewer] Cache reset due to expiry after #{cache_expiry} seconds")
-      end
+      @cache_manager.reset_if_needed
     end
 
-    # Clear all caches - useful when schema changes are detected
-    def clear_all_caches
-      @@dynamic_models = {}
-      @@table_columns_cache = {}
-      @@table_metadata_cache = {}
-      @@cache_last_reset = Time.now
-      Rails.logger.debug("[DBViewer] All caches cleared")
-    end
-
-    # Dynamically create an ActiveRecord model for a table
+    # Get a dynamic AR model for a table
     # @param table_name [String] Name of the table
-    # @return [Class] ActiveRecord model class for the table
+    # @return [Class] ActiveRecord model class
     def get_model_for(table_name)
-      return nil if table_name.blank?
-
-      begin
-        model_name = table_name.classify
-
-        # Return cached model if available
-        return @@dynamic_models[table_name] if @@dynamic_models[table_name]
-
-        # Create a new model class dynamically
-        model = Class.new(ActiveRecord::Base) do
-          self.table_name = table_name
-
-          # Some tables might not have primary keys, so we handle that
-          begin
-            primary_key = connection.primary_key(table_name)
-            self.primary_key = primary_key if primary_key.present?
-          rescue => e
-            # If we can't determine the primary key, default to id or set to nil
-            self.primary_key = "id"
-          end
-
-          # Disable STI
-          self.inheritance_column = :_type_disabled
-
-          # Disable timestamps for better compatibility
-          self.record_timestamps = false
-        end
-
-        # Set model name constant if not already taken
-        # Use a namespace to avoid polluting the global namespace
-        unless Dbviewer.const_defined?("DynamicModel_#{model_name}")
-          Dbviewer.const_set("DynamicModel_#{model_name}", model)
-        end
-
-        # Cache the model
-        @@dynamic_models[table_name] = model
-        model
-      rescue => e
-        Rails.logger.error("[DBViewer] Error creating model for table #{table_name}: #{e.message}")
-        raise e
-      end
-    end
-
-    # Convert ActiveRecord::Relation to the expected result format
-    # @param records [ActiveRecord::Relation] Records to convert
-    # @param table_name [String] Name of the table
-    # @return [ActiveRecord::Result] Result set with columns and rows
-    def to_result_set(records, table_name)
-      begin
-        column_names = table_columns(table_name).map { |c| c[:name] }
-
-        rows = records.map do |record|
-          column_names.map do |col|
-            # Handle serialized attributes
-            value = record[col]
-            serialize_if_needed(value)
-          end
-        end
-
-        ActiveRecord::Result.new(column_names, rows)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error converting to result set for table #{table_name}: #{e.message}")
-        ActiveRecord::Result.new([], [])
-      end
-    end
-
-    # Serialize complex objects for display
-    # @param value [Object] Value to serialize
-    # @return [String, Object] Serialized value or original value
-    def serialize_if_needed(value)
-      case value
-      when Hash, Array
-        value.to_json rescue value.to_s
-      when Time, Date, DateTime
-        value.to_s
-      else
-        value
-      end
+      @dynamic_model_factory.get_model_for(table_name)
     end
   end
 end

data/lib/dbviewer/dynamic_model_factory.rb

@@ -0,0 +1,60 @@
+module Dbviewer
+  # DynamicModelFactory creates and manages ActiveRecord models for database tables
+  class DynamicModelFactory
+    # Initialize with a connection and cache manager
+    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+    # @param cache_manager [Dbviewer::CacheManager] Cache manager instance
+    def initialize(connection, cache_manager)
+      @connection = connection
+      @cache_manager = cache_manager
+    end
+
+    # Get or create an ActiveRecord model for a table
+    # @param table_name [String] Name of the table
+    # @return [Class] ActiveRecord model class for the table
+    def get_model_for(table_name)
+      cached_model = @cache_manager.get_model(table_name)
+      return cached_model if cached_model
+
+      model = create_model_for(table_name)
+      @cache_manager.store_model(table_name, model)
+      model
+    end
+
+    private
+
+    # Create a new ActiveRecord model for a table
+    # @param table_name [String] Name of the table
+    # @return [Class] ActiveRecord model class for the table
+    def create_model_for(table_name)
+      model_name = table_name.classify
+
+      # Create a new model class dynamically
+      model = Class.new(ActiveRecord::Base) do
+        self.table_name = table_name
+
+        # Some tables might not have primary keys, so we handle that
+        begin
+          primary_key = connection.primary_key(table_name)
+          self.primary_key = primary_key if primary_key.present?
+        rescue
+          self.primary_key = "id"
+        end
+
+        # Disable STI
+        self.inheritance_column = :_type_disabled
+
+        # Disable timestamps for better compatibility
+        self.record_timestamps = false
+      end
+
+      # Set model name constant if not already taken
+      # Use a namespace to avoid polluting the global namespace
+      unless Dbviewer.const_defined?("DynamicModel_#{model_name}")
+        Dbviewer.const_set("DynamicModel_#{model_name}", model)
+      end
+
+      model
+    end
+  end
+end

data/lib/dbviewer/engine.rb

@@ -12,9 +12,11 @@ module Dbviewer
       Dbviewer.setup
     end
 
-    # Handle database connections at the appropriate time
-    config.to_prepare do
-      ActiveRecord::Base.connection if Rails.application.initialized?
+    initializer "dbviewer.notifications" do
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        Logger.instance.add(event)
+      end
     end
   end
 end

data/lib/dbviewer/error_handler.rb

@@ -0,0 +1,18 @@
+module Dbviewer
+  # ErrorHandler provides centralized error handling for database operations
+  class ErrorHandler
+    class << self
+      # Execute a block with error handling
+      # @param operation_name [String] Description of the operation for logging
+      # @param default_return [Object] Value to return on error
+      # @yield Block to execute
+      # @return [Object] Result of block or default value on error
+      def with_error_handling(operation_name, default_return = nil)
+        yield
+      rescue => e
+        Rails.logger.error("[DBViewer] Error #{operation_name}: #{e.message}")
+        default_return
+      end
+    end
+  end
+end