dbviewer 0.3.6 → 0.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 151a189372c94a737108969cd768ab9dbc4e16a2abc608f07026d1a6b7ee65a5
-  data.tar.gz: a5fa3a4f4aa8e1acd606f60c2264412a261beec6b6889675ef941d05d1e593cb
+  metadata.gz: 72e7257a74294ca4a6ad8b53fc497ca9eb0727772e798b2c4d7fa2c164b35531
+  data.tar.gz: d01a7c934e3e859f06f94a746671974dd93813e832c6f5f54df49b3071e95178
 SHA512:
-  metadata.gz: e8345197920cf8c6a006d3faecd9a0b9f2a6ef4c972226707203ba43b121e05c3a02195eec4d38a699231ae488741802a9dff5c7317ddc576f4e27381ad897e7
-  data.tar.gz: b9a8ff1804963de25e85f9a288c198ee4aaa23cf25253ff99f0ce84f3e470e2e35a47c304ff24b2cbd962d9c913fb69b08f11d6bbd2d213af52113ce4d048e18
+  metadata.gz: 79511e9ac29ca71e4834b958c54b36ee05f83e831f1426745282139ea6b46d5e0e1bcd2a2b31df956987218bfc44239fa624dba86f74ec4858cc35aea4af8536
+  data.tar.gz: e63f51557b5f2431f63c920989a1b13f7ed5c1cbe5cd708091fc8f728e649caae11a6c09a754d6522b2dbbb3408cb380a2ded2f438770e8b9c2d49b782bdcd7f

data/README.md

@@ -44,7 +44,8 @@ It's designed for development, debugging, and database analysis, offering a clea
 <details>
   <summary>Click to see more screenshots</summary>
   
-  #### Dashboard Overview
+#### Dashboard Overview
+
   <img width="1470" alt="image" src="https://github.com/user-attachments/assets/4e803d51-9a5b-4c80-bb4c-a761dba15a40" />
 
 #### Table Details
@@ -76,7 +77,7 @@ gem "dbviewer", group: :development
 And then execute:
 
 ```bash
-$ bundle
+bundle
 ```
 
 ## 🔧 Usage
@@ -274,6 +275,7 @@ With the addition of Basic Authentication, DBViewer can now be used in any envir
    ```
 
 3. Access the tool through your regular application URL:
+
    ```
    https://yourdomain.com/dbviewer?override_env_check=your_secure_random_key
    ```
@@ -288,6 +290,36 @@ When used in production, ensure:
 - You access DBViewer over HTTPS connections only
 - Access is limited to trusted administrators only
 
+## 🔄 Updating DBViewer
+
+To keep DBViewer up to date with the latest features, security patches, and bug fixes, follow these steps:
+
+### Using Bundler
+
+The simplest way to update is using Bundler:
+
+- Update your Gemfile with the desired version:
+
+   ```ruby
+   # For the latest version
+   gem "dbviewer", group: :development
+   
+   # Or specify a version
+   gem "dbviewer", "~> 0.3.2", group: :development
+   ```
+
+- Run bundle update:
+
+  ```ruby
+  bundle update dbviewer
+  ```
+
+- Restart your Rails server to apply the changes:
+
+  ```ruby
+  rails server
+  ```
+
 ## 🤌🏻 Contributing
 
 Bug reports and pull requests are welcome.

data/app/controllers/concerns/dbviewer/database_operations.rb

@@ -11,6 +11,12 @@ module Dbviewer
       @database_manager ||= ::Dbviewer::DatabaseManager.new
     end
 
+    # Initialize the table query operations manager
+    # This gives direct access to table query operations when needed
+    def table_query_operations
+      @table_query_operations ||= database_manager.table_query_operations
+    end
+
     # Get the name of the current database
     def get_database_name
       adapter = database_manager.connection.adapter_name.downcase
@@ -65,6 +71,19 @@ module Dbviewer
         empty_tables: tables.select { |t| t[:record_count] == 0 }
       }
 
+      # Calculate total foreign key relationships
+      begin
+        total_relationships = 0
+        tables.each do |table|
+          metadata = fetch_table_metadata(table[:name])
+          total_relationships += metadata[:foreign_keys].size if metadata && metadata[:foreign_keys]
+        end
+        analytics[:total_relationships] = total_relationships
+      rescue => e
+        Rails.logger.error("Error calculating relationship count: #{e.message}")
+        analytics[:total_relationships] = 0
+      end
+
       # Calculate schema size if possible
       begin
         analytics[:schema_size] = calculate_schema_size
@@ -138,19 +157,8 @@ module Dbviewer
     end
 
     # Fetch records for a table with pagination and sorting
-    def fetch_table_records(table_name)
-      column_filters = params[:column_filters] || {}
-      # Clean up blank filters
-      column_filters.reject! { |_, v| v.blank? }
-
-      database_manager.table_records(
-        table_name,
-        @current_page,
-        @order_by,
-        @order_direction,
-        @per_page,
-        column_filters || {}
-      )
+    def fetch_table_records(table_name, query_params)
+      database_manager.table_records(table_name, query_params)
     end
 
     # Get filtered record count for a table
@@ -207,6 +215,130 @@ module Dbviewer
       relationships
     end
 
+    # Get mini ERD data for a specific table and its relationships
+    def fetch_mini_erd_for_table(table_name)
+      related_tables = []
+      relationships = []
+
+      # Validate the table exists
+      unless database_manager.tables.include?(table_name)
+        Rails.logger.error("[DBViewer] Table not found for mini ERD: #{table_name}")
+        return {
+          tables: [],
+          relationships: [],
+          error: "Table '#{table_name}' not found in the database"
+        }
+      end
+
+      # Add current table
+      related_tables << { name: table_name }
+
+      Rails.logger.info("[DBViewer] Generating mini ERD for table: #{table_name}")
+
+      # Get foreign keys from this table to others (outgoing relationships)
+      begin
+        metadata = fetch_table_metadata(table_name)
+        Rails.logger.debug("[DBViewer] Table metadata: #{metadata.inspect}")
+
+        if metadata && metadata[:foreign_keys].present?
+          metadata[:foreign_keys].each do |fk|
+            # Ensure all required fields are present
+            next unless fk[:to_table].present? && fk[:column].present?
+
+            # Sanitize table and column names for display
+            from_table = table_name.to_s
+            to_table = fk[:to_table].to_s
+            from_column = fk[:column].to_s
+            to_column = fk[:primary_key].to_s.presence || "id"
+            relationship_name = fk[:name].to_s.presence || "#{from_table}_to_#{to_table}"
+
+            relationship = {
+              from_table: from_table,
+              to_table: to_table,
+              from_column: from_column,
+              to_column: to_column,
+              name: relationship_name,
+              direction: "outgoing"
+            }
+
+            relationships << relationship
+            Rails.logger.debug("[DBViewer] Added outgoing relationship: #{relationship.inspect}")
+
+            # Add the related table if not already included
+            unless related_tables.any? { |t| t[:name] == to_table }
+              related_tables << { name: to_table }
+            end
+          end
+        end
+      rescue => e
+        Rails.logger.error("[DBViewer] Error fetching outgoing relationships for #{table_name}: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n"))
+      end
+
+      # Get foreign keys from other tables to this one (incoming relationships)
+      begin
+        database_manager.tables.each do |other_table_name|
+          next if other_table_name == table_name # Skip self
+
+          begin
+            other_metadata = fetch_table_metadata(other_table_name)
+            if other_metadata && other_metadata[:foreign_keys].present?
+              other_metadata[:foreign_keys].each do |fk|
+                if fk[:to_table] == table_name
+                  # Ensure all required fields are present
+                  next unless fk[:column].present?
+
+                  # Sanitize table and column names for display
+                  from_table = other_table_name.to_s
+                  to_table = table_name.to_s
+                  from_column = fk[:column].to_s
+                  to_column = fk[:primary_key].to_s.presence || "id"
+                  relationship_name = fk[:name].to_s.presence || "#{from_table}_to_#{to_table}"
+
+                  relationship = {
+                    from_table: from_table,
+                    to_table: to_table,
+                    from_column: from_column,
+                    to_column: to_column,
+                    name: relationship_name,
+                    direction: "incoming"
+                  }
+
+                  relationships << relationship
+                  Rails.logger.debug("[DBViewer] Added incoming relationship: #{relationship.inspect}")
+
+                  # Add the related table if not already included
+                  unless related_tables.any? { |t| t[:name] == from_table }
+                    related_tables << { name: from_table }
+                  end
+                end
+              end
+            end
+          rescue => e
+            Rails.logger.error("[DBViewer] Error processing relationships for table #{other_table_name}: #{e.message}")
+            # Continue to the next table
+          end
+        end
+      rescue => e
+        Rails.logger.error("[DBViewer] Error fetching incoming relationships for #{table_name}: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n"))
+      end
+
+      # If no relationships were found, make sure to still include at least the current table
+      if relationships.empty?
+        Rails.logger.info("[DBViewer] No relationships found for table: #{table_name}")
+      end
+
+      result = {
+        tables: related_tables,
+        relationships: relationships,
+        timestamp: Time.now.to_i
+      }
+
+      Rails.logger.info("[DBViewer] Mini ERD data generated: #{related_tables.length} tables, #{relationships.length} relationships")
+      result
+    end
+
     # Prepare the SQL query - either from params or default
     def prepare_query
       quoted_table = safe_quote_table_name(@table_name)
@@ -240,17 +372,24 @@ module Dbviewer
     end
 
     # Export table data to CSV
-    def export_table_to_csv(table_name, limit = 10000, include_headers = true)
+    def export_table_to_csv(table_name, query_params = nil, include_headers = true)
       require "csv"
 
       begin
-        records = database_manager.table_records(
-          table_name,
-          1, # First page
-          nil, # Default sorting
-          "asc",
-          limit # Limit number of records
-        )
+        if query_params.is_a?(Dbviewer::TableQueryParams)
+          # Use the query params object directly
+          records = database_manager.query_operations.table_records(table_name, query_params)
+        else
+          # Legacy support for the old method signature
+          limit = query_params.is_a?(Numeric) ? query_params : 10000
+          records = database_manager.table_records(
+            table_name,
+            1, # First page
+            nil, # Default sorting
+            "asc",
+            limit # Limit number of records
+          )
+        end
 
         csv_data = CSV.generate do |csv|
           # Add headers if requested

data/app/controllers/concerns/dbviewer/pagination_concern.rb

@@ -35,6 +35,14 @@ module Dbviewer
       @order_direction = "ASC" unless self.class::VALID_SORT_DIRECTIONS.include?(@order_direction)
     end
 
+    def fetch_total_count(table_name, query_params)
+      if query_params.column_filters.present? && query_params.column_filters.values.any?(&:present?)
+        fetch_filtered_record_count(table_name, query_params.column_filters)
+      else
+        fetch_table_record_count(table_name)
+      end
+    end
+
     # Calculate the total number of pages
     def calculate_total_pages(total_count, per_page)
       (total_count.to_f / per_page).ceil

data/app/controllers/dbviewer/tables_controller.rb

@@ -2,30 +2,40 @@ module Dbviewer
   class TablesController < ApplicationController
     include Dbviewer::PaginationConcern
 
+    before_action :set_table_name, except: [ :index ]
+
     def index
       @tables = fetch_tables_with_stats(include_record_counts: true)
     end
 
     def show
-      @table_name = params[:id]
-      @columns = fetch_table_columns(@table_name)
-      @metadata = fetch_table_metadata(@table_name)
-      @tables = fetch_tables_with_stats  # Fetch tables for sidebar
-
       set_pagination_params
       set_sorting_params
 
-      # Extract column filters from params
+      # Get column filters from params first
       @column_filters = params[:column_filters].presence ? params[:column_filters].to_enum.to_h : {}
 
-      if @column_filters.present? && @column_filters.values.any?(&:present?)
-        @total_count = fetch_filtered_record_count(@table_name, @column_filters)
-      else
-        @total_count = fetch_table_record_count(@table_name)
-      end
-
+      # Then apply global creation filters (this will modify @column_filters)
+      set_global_filters
+
+      # Now create the query params with the combined filters
+      query_params = Dbviewer::TableQueryParams.new(
+        page: @current_page,
+        per_page: @per_page,
+        order_by: @order_by,
+        direction: @order_direction,
+        column_filters: @column_filters.reject { |_, v| v.blank? }
+      )
+      @total_count = fetch_total_count(@table_name, query_params)
+      @records = fetch_table_records(@table_name, query_params)
       @total_pages = calculate_total_pages(@total_count, @per_page)
-      @records = fetch_table_records(@table_name)
+      @columns = fetch_table_columns(@table_name)
+      @metadata = fetch_table_metadata(@table_name)
+
+      if @records.nil?
+        column_names = @columns.map { |c| c[:name] }
+        @records = ActiveRecord::Result.new(column_names, [])
+      end
 
       # Fetch timestamp visualization data if the table has a created_at column
       if has_timestamp_column?(@table_name)
@@ -46,8 +56,33 @@ module Dbviewer
       end
     end
 
+    def mini_erd
+      begin
+        @erd_data = fetch_mini_erd_for_table(@table_name)
+
+        if @erd_data[:error].present?
+          Rails.logger.error("Mini ERD error: #{@erd_data[:error]}")
+        end
+
+        respond_to do |format|
+          format.json { render json: @erd_data }
+          format.html { render layout: false }
+        end
+      rescue => e
+        Rails.logger.error("Error generating Mini ERD: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n"))
+
+        @error_message = e.message
+        @erd_data = { tables: [], relationships: [], error: @error_message }
+
+        respond_to do |format|
+          format.json { render json: { error: @error_message }, status: :internal_server_error }
+          format.html { render layout: false }
+        end
+      end
+    end
+
     def query
-      @table_name = params[:id]
       @read_only_mode = true # Flag to indicate we're in read-only mode
       @columns = fetch_table_columns(@table_name)
       @tables = fetch_tables_with_stats  # Fetch tables for sidebar
@@ -68,20 +103,98 @@ module Dbviewer
         return
       end
 
-      table_name = params[:id]
       limit = (params[:limit] || 10000).to_i
       include_headers = params[:include_headers] != "0"
 
-      csv_data = export_table_to_csv(table_name, limit, include_headers)
+      # Apply global creation filters
+      set_global_filters
+
+      # Create query parameters for export
+      query_params = Dbviewer::TableQueryParams.new(
+        page: 1,
+        per_page: limit,
+        order_by: nil,
+        direction: "asc",
+        column_filters: @column_filters.reject { |_, v| v.blank? }
+      )
+
+      # Get filtered data for export
+      csv_data = export_table_to_csv(@table_name, query_params, include_headers)
 
       # Set filename with timestamp for uniqueness
       timestamp = Time.now.strftime("%Y%m%d%H%M%S")
-      filename = "#{table_name}_export_#{timestamp}.csv"
+
+      # Add filter info to filename if filters are applied
+      filename_suffix = ""
+      if @creation_filter_start.present? || @creation_filter_end.present?
+        filename_suffix = "_filtered"
+      end
+
+      filename = "#{@table_name}#{filename_suffix}_#{timestamp}.csv"
 
       # Send data as file
       send_data csv_data,
                 type: "text/csv; charset=utf-8; header=present",
                 disposition: "attachment; filename=#{filename}"
     end
+
+    private
+
+    def set_table_name
+      @table_name = params[:id]
+    end    # Handle global creation datetime filters across tables
+    def set_global_filters
+      # Store creation filter datetimes in session to persist between table navigation
+      if params[:creation_filter_start].present?
+        session[:creation_filter_start] = params[:creation_filter_start]
+      end
+
+      if params[:creation_filter_end].present?
+        session[:creation_filter_end] = params[:creation_filter_end]
+      end
+
+      # Clear filters if explicitly requested
+      if params[:clear_creation_filter] == "true"
+        session.delete(:creation_filter_start)
+        session.delete(:creation_filter_end)
+      end
+
+      # Set instance variables for view access
+      @creation_filter_start = session[:creation_filter_start]
+      @creation_filter_end = session[:creation_filter_end]
+
+      # Initialize column_filters if not present
+      @column_filters ||= {}
+
+      # Apply creation filters to column_filters if the table has a created_at column
+      if has_timestamp_column?(@table_name) && (@creation_filter_start.present? || @creation_filter_end.present?)
+        # Clear any existing created_at filters to avoid conflicts
+        @column_filters.delete("created_at")
+        @column_filters.delete("created_at_operator")
+        @column_filters.delete("created_at_end")
+
+        if @creation_filter_start.present? && @creation_filter_end.present?
+          # If both start and end are present, set up a range filter
+          @column_filters["created_at"] = @creation_filter_start
+          @column_filters["created_at_end"] = @creation_filter_end
+          # No need for operator when using start and end together
+          Rails.logger.info("[DBViewer] Setting creation filter range: #{@creation_filter_start} to #{@creation_filter_end}")
+        elsif @creation_filter_start.present?
+          # Only start date is present
+          @column_filters["created_at"] = @creation_filter_start
+          @column_filters["created_at_operator"] = "gte" # Greater than or equal
+          Rails.logger.info("[DBViewer] Setting creation filter start: #{@creation_filter_start}")
+        elsif @creation_filter_end.present?
+          # Only end date is present
+          @column_filters["created_at"] = @creation_filter_end
+          @column_filters["created_at_operator"] = "lte" # Less than or equal
+          Rails.logger.info("[DBViewer] Setting creation filter end: #{@creation_filter_end}")
+        end
+      else
+        if @creation_filter_start.present? || @creation_filter_end.present?
+          Rails.logger.info("[DBViewer] Creation filter present but table #{@table_name} has no created_at column")
+        end
+      end
+    end
   end
 end

data/app/helpers/dbviewer/application_helper.rb

@@ -1,5 +1,19 @@
 module Dbviewer
   module ApplicationHelper
+    # Check if a table has a created_at column
+    def has_timestamp_column?(table_name)
+      return false unless table_name.present?
+
+      # Get the columns for the table directly using DatabaseManager
+      columns = get_database_manager.table_columns(table_name)
+      columns.any? { |col| col[:name] == "created_at" && [ :datetime, :timestamp ].include?(col[:type]) }
+    end
+
+    # Helper to access the database manager
+    def get_database_manager
+      @database_manager ||= ::Dbviewer::DatabaseManager.new
+    end
+
     def format_cell_value(value)
       return "NULL" if value.nil?
       return value.to_s.truncate(100) unless value.is_a?(String)
@@ -114,5 +128,64 @@ module Dbviewer
     def logs_nav_class
       active_nav_class("logs")
     end
+
+    # Returns a sort icon based on the current sort direction
+    def sort_icon(column_name, current_order_by, current_direction)
+      if column_name == current_order_by
+        direction = current_direction == "ASC" ? "up" : "down"
+        "<i class='bi bi-sort-#{direction}'></i>".html_safe
+      else
+        "<i class='bi bi-filter invisible sort-icon'></i>".html_safe
+      end
+    end
+
+    # Determine the next sort direction based on the current one
+    def next_sort_direction(column_name, current_order_by, current_direction)
+      if column_name == current_order_by && current_direction == "ASC"
+        "DESC"
+      else
+        "ASC"
+      end
+    end
+
+    # Generate a sortable column header link
+    def sortable_column_header(column_name, current_order_by, current_direction, table_name, current_page, per_page, column_filters)
+      is_sorted = column_name == current_order_by
+      sort_direction = next_sort_direction(column_name, current_order_by, current_direction)
+
+      aria_sort = if is_sorted
+        current_direction.downcase == "asc" ? "ascending" : "descending"
+      else
+        "none"
+      end
+
+      # Build parameters for the sort link
+      sort_params = {
+        order_by: column_name,
+        order_direction: sort_direction,
+        page: current_page,
+        per_page: per_page,
+        column_filters: column_filters
+      }
+
+      # Add creation filter parameters if they're in the controller
+      if defined?(@creation_filter_start) && @creation_filter_start.present?
+        sort_params[:creation_filter_start] = @creation_filter_start
+      end
+
+      if defined?(@creation_filter_end) && @creation_filter_end.present?
+        sort_params[:creation_filter_end] = @creation_filter_end
+      end
+
+      link_to table_path(table_name, sort_params),
+        class: "d-flex align-items-center text-decoration-none text-reset column-sort-link",
+        title: "Sort by #{column_name} (#{sort_direction.downcase})",
+        "aria-sort": aria_sort,
+        role: "button",
+        tabindex: "0" do
+          content_tag(:span, column_name, class: "column-name") +
+          content_tag(:span, sort_icon(column_name, current_order_by, current_direction), class: "sort-icon-container")
+      end
+    end
   end
 end

data/app/views/dbviewer/home/index.html.erb

@@ -15,37 +15,58 @@
 
   <div class="row g-3 mb-4">
     <div class="col-md-3">
-      <div class="card h-100 text-center border-0 <%= stat_card_bg_class %>">
-        <div class="card-body">
-          <h5 class="mb-1">Tables</h5>
-          <h2 class="mb-0"><%= @analytics[:total_tables] %></h2>
+      <div class="card h-100 border-0 shadow-sm <%= stat_card_bg_class %>">
+        <div class="card-body d-flex align-items-center">
+          <div class="metric-icon me-3">
+            <i class="bi bi-table fs-4"></i>
+          </div>
+          <div class="text-start">
+            <h5 class="mb-1">Tables</h5>
+            <h2 class="mb-0"><%= @analytics[:total_tables] %></h2>
+          </div>
         </div>
       </div>
     </div>
     
     <div class="col-md-3">
-      <div class="card h-100 text-center border-0 <%= stat_card_bg_class %>">
-        <div class="card-body">
-          <h5 class="mb-1">Records</h5>
-          <h2 class="mb-0"><%= number_with_delimiter(@analytics[:total_records]) %></h2>
+      <div class="card h-100 border-0 shadow-sm <%= stat_card_bg_class %>">
+        <div class="card-body d-flex align-items-center">
+          <div class="metric-icon me-3">
+            <i class="bi bi-database fs-4"></i>
+          </div>
+          <div class="text-start">
+            <h5 class="mb-1">Records</h5>
+            <h2 class="mb-0"><%= number_with_delimiter(@analytics[:total_records]) %></h2>
+          </div>
         </div>
       </div>
     </div>
     
     <div class="col-md-3">
-      <div class="card h-100 text-center border-0 <%= stat_card_bg_class %>">
-        <div class="card-body">
-          <h5 class="mb-1">Columns</h5>
-          <h2 class="mb-0"><%= @analytics[:total_columns] %></h2>
+      <div class="card h-100 border-0 shadow-sm <%= stat_card_bg_class %>">
+        <div class="card-body d-flex align-items-center">
+          <div class="metric-icon me-3">
+            <i class="bi bi-link-45deg fs-4"></i>
+          </div>
+          <div class="text-start">
+            <h5 class="mb-1">Relationships</h5>
+            <h2 class="mb-0"><%= @analytics[:total_relationships] %></h2>
+            <small class="text-muted d-block">Foreign Key Connections</small>
+          </div>
         </div>
       </div>
     </div>
     
     <div class="col-md-3">
-      <div class="card h-100 text-center border-0 <%= stat_card_bg_class %>">
-        <div class="card-body">
-          <h5 class="mb-1">Database Size</h5>
-          <h2 class="mb-0"><%= number_to_human_size(@analytics[:schema_size]) %></h2>
+      <div class="card h-100 border-0 shadow-sm <%= stat_card_bg_class %>">
+        <div class="card-body d-flex align-items-center">
+          <div class="metric-icon me-3">
+            <i class="bi bi-hdd fs-4"></i>
+          </div>
+          <div class="text-start">
+            <h5 class="mb-1">Database Size</h5>
+            <h2 class="mb-0"><%= number_to_human_size(@analytics[:schema_size]) %></h2>
+          </div>
         </div>
       </div>
     </div>