dbviewer 0.6.3 → 0.6.4

data/app/helpers/dbviewer/filter_helper.rb

@@ -0,0 +1,137 @@
+module Dbviewer
+  module FilterHelper
+    # Determine default operator based on column type
+    def default_operator_for_column_type(column_type)
+      if column_type && column_type =~ /char|text|string|uuid|enum/i
+        "contains"
+      else
+        "eq"
+      end
+    end
+
+    # Generate operator options based on column type
+    def operator_options_for_column_type(column_type)
+      # Common operators for all types
+      common_operators = [
+        [ "is null", "is_null" ],
+        [ "is not null", "is_not_null" ]
+      ]
+
+      type_specific_operators = if column_type && (column_type =~ /datetime/ || column_type =~ /^date$/ || column_type =~ /^time$/)
+        # Date/Time operators
+        [
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "<", "lt" ],
+          [ ">", "gt" ],
+          [ "≤", "lte" ],
+          [ "≥", "gte" ]
+        ]
+      elsif column_type && column_type =~ /int|float|decimal|double|number|numeric|real|money|bigint|smallint|tinyint|mediumint|bit/i
+        # Numeric operators
+        [
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "<", "lt" ],
+          [ ">", "gt" ],
+          [ "≤", "lte" ],
+          [ "≥", "gte" ]
+        ]
+      else
+        # Text operators
+        [
+          [ "contains", "contains" ],
+          [ "not contains", "not_contains" ],
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "starts with", "starts_with" ],
+          [ "ends with", "ends_with" ]
+        ]
+      end
+
+      # Return type-specific operators first, then common operators
+      type_specific_operators + common_operators
+    end
+
+    # Render column filter input based on column type
+    def render_column_filter_input(form, column_name, column_type, column_filters)
+      # Get selected operator to check if it's a null operator
+      operator = column_filters["#{column_name}_operator"]
+      is_null_operator = operator == "is_null" || operator == "is_not_null"
+
+      # Clean up the value for non-null operators if the value contains a null operator
+      # This ensures we don't carry over 'is_null' or 'is_not_null' values when switching operators
+      value = column_filters[column_name]
+      if !is_null_operator && value.present? && (value == "is_null" || value == "is_not_null")
+        value = nil
+      end
+
+      # For null operators, display a non-editable field without placeholder
+      if is_null_operator
+        # Keep a hidden field for the actual value
+        hidden_field = form.hidden_field("column_filters[#{column_name}]",
+          value: operator,
+          class: "null-filter-value",
+          data: { column: column_name })
+
+        # Add a visible but disabled text field with no placeholder or value
+        visible_field = form.text_field("column_filters[#{column_name}_display]",
+          disabled: true,
+          value: "",
+          class: "form-control form-control-sm column-filter rounded-0 disabled-filter",
+          data: { column: "#{column_name}_display" })
+
+        hidden_field + visible_field
+      elsif column_type && column_type =~ /datetime/
+        form.datetime_local_field("column_filters[#{column_name}]",
+          value: value,
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      elsif column_type && column_type =~ /^date$/
+        form.date_field("column_filters[#{column_name}]",
+          value: value,
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      elsif column_type && column_type =~ /^time$/
+        form.time_field("column_filters[#{column_name}]",
+          value: value,
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      else
+        form.text_field("column_filters[#{column_name}]",
+          value: value,
+          placeholder: "",
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      end
+    end
+
+    # Render operator select for column filter
+    def render_operator_select(form, column_name, column_type, column_filters)
+      # Get previously selected operator or default
+      default_operator = default_operator_for_column_type(column_type)
+      selected_operator = column_filters["#{column_name}_operator"]
+      selected_operator = default_operator if selected_operator.nil? || selected_operator == "default"
+
+      # Get appropriate options
+      operator_options = operator_options_for_column_type(column_type)
+
+      form.select("column_filters[#{column_name}_operator]",
+        options_for_select(operator_options, selected_operator),
+        { include_blank: false },
+        { class: "form-select form-select-sm operator-select" })
+    end
+
+    # Render complete filter input group for a column
+    def render_column_filter(form, column_name, columns, column_filters)
+      column_type = column_type_from_info(column_name, columns)
+
+      content_tag(:div, class: "filter-input-group") do
+        operator_select = render_operator_select(form, column_name, column_type, column_filters)
+        input_field = render_column_filter_input(form, column_name, column_type, column_filters)
+
+        operator_select + input_field
+      end
+    end
+  end
+end

data/app/helpers/dbviewer/formatting_helper.rb

@@ -0,0 +1,30 @@
+module Dbviewer
+  module FormattingHelper
+    def format_cell_value(value)
+      return "NULL" if value.nil?
+      return value.to_s.truncate(100) unless value.is_a?(String)
+
+      case value
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+        # ISO 8601 datetime
+        begin
+          Time.parse(value).strftime("%Y-%m-%d %H:%M:%S")
+        rescue
+          value.to_s.truncate(100)
+        end
+      when /\A\d{4}-\d{2}-\d{2}\z/
+        # Date
+        value
+      when /\A{.+}\z/, /\A\[.+\]\z/
+        # JSON
+        begin
+          JSON.pretty_generate(JSON.parse(value)).truncate(100)
+        rescue
+          value.to_s.truncate(100)
+        end
+      else
+        value.to_s.truncate(100)
+      end
+    end
+  end
+end

data/app/helpers/dbviewer/navigation_helper.rb

@@ -0,0 +1,35 @@
+module Dbviewer
+  module NavigationHelper
+    # Helper method to determine if current controller and action match
+    def active_nav_class(controller_name, action_name = nil)
+      current_controller = params[:controller].split("/").last
+      active = current_controller == controller_name
+
+      if action_name.present?
+        active = active && params[:action] == action_name
+      end
+
+      active ? "active" : ""
+    end
+
+    # Helper for highlighting dashboard link
+    def dashboard_nav_class
+      active_nav_class("home")
+    end
+
+    # Helper for highlighting tables link
+    def tables_nav_class
+      active_nav_class("tables")
+    end
+
+    # Helper for highlighting ERD link
+    def erd_nav_class
+      active_nav_class("entity_relationship_diagrams")
+    end
+
+    # Helper for highlighting SQL Logs link
+    def logs_nav_class
+      active_nav_class("logs")
+    end
+  end
+end

data/app/helpers/dbviewer/pagination_helper.rb

@@ -0,0 +1,72 @@
+module Dbviewer
+  module PaginationHelper
+    # Common parameters for pagination and filtering
+    def common_params(options = {})
+      params = {
+        order_by: @order_by,
+        order_direction: @order_direction,
+        per_page: @per_page,
+        column_filters: @column_filters
+      }.merge(options)
+
+      # Add creation filters if they exist
+      params[:creation_filter_start] = @creation_filter_start if @creation_filter_start.present?
+      params[:creation_filter_end] = @creation_filter_end if @creation_filter_end.present?
+
+      params
+    end
+
+    # Render pagination UI
+    def render_pagination(table_name, current_page, total_pages, params = {})
+      return unless total_pages && total_pages > 1
+
+      content_tag(:nav, 'aria-label': "Page navigation") do
+        content_tag(:ul, class: "pagination justify-content-center") do
+          prev_link = content_tag(:li, class: "page-item #{current_page == 1 ? 'disabled' : ''}") do
+            link_to "«", table_path(table_name, params.merge(page: [ current_page - 1, 1 ].max)), class: "page-link"
+          end
+
+          # Calculate page range to display
+          start_page = [ 1, current_page - 2 ].max
+          end_page = [ start_page + 4, total_pages ].min
+          start_page = [ 1, end_page - 4 ].max
+
+          # Generate page links
+          page_links = (start_page..end_page).map do |page_num|
+            content_tag(:li, class: "page-item #{page_num == current_page ? 'active' : ''}") do
+              link_to page_num, table_path(table_name, params.merge(page: page_num)), class: "page-link"
+            end
+          end.join.html_safe
+
+          next_link = content_tag(:li, class: "page-item #{current_page == total_pages ? 'disabled' : ''}") do
+            link_to "»", table_path(table_name, params.merge(page: [ current_page + 1, total_pages ].min)), class: "page-link"
+          end
+
+          prev_link + page_links + next_link
+        end
+      end
+    end
+
+    # Generate URL parameters for per-page dropdown
+    def per_page_url_params(table_name)
+      # Start with the dynamic part for the select element
+      url_params = "per_page=' + this.value + '&page=1"
+
+      # Add all other common parameters except per_page and page which we already set
+      params = common_params.except(:per_page, :page)
+
+      # Convert the params hash to URL parameters
+      params.each do |key, value|
+        if key == :column_filters && value.is_a?(Hash) && value.reject { |_, v| v.blank? }.any?
+          value.reject { |_, v| v.blank? }.each do |filter_key, filter_value|
+            url_params += "&column_filters[#{filter_key}]=#{CGI.escape(filter_value.to_s)}"
+          end
+        elsif value.present?
+          url_params += "&#{key}=#{CGI.escape(value.to_s)}"
+        end
+      end
+
+      url_params
+    end
+  end
+end

data/app/helpers/dbviewer/sorting_helper.rb

@@ -0,0 +1,47 @@
+module Dbviewer
+  module SortingHelper
+    # 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
+
+      # Use common_params helper to build parameters
+      sort_params = common_params(order_by: column_name, order_direction: sort_direction)
+
+      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/helpers/dbviewer/table_rendering_helper.rb

@@ -0,0 +1,145 @@
+module Dbviewer
+  module TableRenderingHelper
+    # Render a complete table header row with sortable columns
+    def render_sortable_header_row(records, order_by, order_direction, table_name, current_page, per_page, column_filters)
+      return content_tag(:tr) { content_tag(:th, "No columns available") } unless records&.columns
+
+      content_tag(:tr) do
+        # Start with action column header (sticky first column)
+        headers = [
+          content_tag(:th, class: "px-3 py-2 text-center action-column action-column-header", width: "60px", rowspan: 2) do
+            content_tag(:span, "Actions")
+          end
+        ]
+
+        # Add all data columns
+        headers += records.columns.map do |column_name|
+          is_sorted = order_by == column_name
+          content_tag(:th, class: "px-3 py-2 sortable-column #{is_sorted ? 'sorted' : ''}") do
+            sortable_column_header(column_name, order_by, order_direction, table_name, current_page, per_page, column_filters)
+          end
+        end
+
+        headers.join.html_safe
+      end
+    end
+
+    # Render the column filters row
+    def render_column_filters_row(form, records, columns, column_filters)
+      return content_tag(:tr) { content_tag(:th, "") } unless records&.columns
+
+      content_tag(:tr, class: "column-filters") do
+        filters = records.columns.map do |column_name|
+          content_tag(:th, class: "p-0") do
+            render_column_filter(form, column_name, columns, column_filters)
+          end
+        end
+
+        filters.join.html_safe
+      end
+    end
+
+    # Render a cell that may include a foreign key link
+    def render_table_cell(cell, column_name, metadata)
+      cell_value = format_cell_value(cell)
+      foreign_key = metadata && metadata[:foreign_keys] ?
+                    metadata[:foreign_keys].find { |fk| fk[:column] == column_name } :
+                    nil
+
+      if foreign_key && !cell.nil?
+        fk_params = { column_filters: { foreign_key[:primary_key] => cell } }
+        fk_params = fk_params.merge(common_params.except(:column_filters))
+
+        content_tag(:td, title: "#{cell_value} (Click to view referenced record)") do
+          link_to(cell_value, table_path(foreign_key[:to_table], fk_params),
+                  class: "text-decoration-none foreign-key-link") +
+          content_tag(:i, "", class: "bi bi-link-45deg text-muted small")
+        end
+      else
+        content_tag(:td, cell_value, title: cell_value)
+      end
+    end
+
+    # Render a table row with cells
+    def render_table_row(row, records, metadata)
+      content_tag(:tr) do
+        # Start with action column (sticky first column)
+        cells = [ render_action_cell(row, records.columns, metadata) ]
+
+        # Add all data cells
+        cells += row.each_with_index.map do |cell, cell_index|
+          column_name = records.columns[cell_index]
+          render_table_cell(cell, column_name, metadata)
+        end
+
+        cells.join.html_safe
+      end
+    end
+
+    # Render the entire table body with rows
+    def render_table_body(records, metadata)
+      if records.nil? || records.rows.nil? || records.empty?
+        content_tag(:tbody) do
+          content_tag(:tr) do
+            # Adding +1 to account for the action column
+            total_columns = records&.columns&.size.to_i + 1
+            content_tag(:td, "No records found or table is empty.", colspan: total_columns, class: "text-center")
+          end
+        end
+      else
+        content_tag(:tbody) do
+          records.rows.map do |row|
+            render_table_row(row, records, metadata)
+          end.join.html_safe
+        end
+      end
+    end
+
+    # Render action buttons for a record
+    def render_action_cell(row_data, columns, metadata = nil)
+      data_attributes = {}
+
+      # Create a hash of column_name: value pairs for data attributes
+      columns.each_with_index do |column_name, index|
+        data_attributes[column_name] = row_data[index].to_s
+      end
+
+      content_tag(:td, class: "text-center action-column") do
+        content_tag(:div, class: "d-flex gap-1 justify-content-center") do
+          # View Record button (existing)
+          view_button = button_tag(
+            type: "button",
+            class: "btn btn-sm btn-primary view-record-btn",
+            title: "View Record Details",
+            data: {
+              bs_toggle: "modal",
+              bs_target: "#recordDetailModal",
+              record_data: data_attributes.to_json,
+              foreign_keys: metadata && metadata[:foreign_keys] ? metadata[:foreign_keys].to_json : "[]",
+              reverse_foreign_keys: metadata && metadata[:reverse_foreign_keys] ? metadata[:reverse_foreign_keys].to_json : "[]"
+            }
+          ) do
+            content_tag(:i, "", class: "bi bi-eye")
+          end
+
+          # Copy FactoryBot button (new)
+          copy_factory_button = button_tag(
+            type: "button",
+            class: "btn btn-sm btn-outline-secondary copy-factory-btn",
+            title: "Copy to JSON",
+            data: {
+              record_data: data_attributes.to_json,
+              table_name: @table_name
+            },
+            onclick: "copyToJson(this)"
+          ) do
+            content_tag(:i, "", class: "bi bi-clipboard")
+          end
+
+          # Concatenate both buttons
+          view_button + copy_factory_button
+        end
+      end
+    end
+  end
+end

data/app/helpers/dbviewer/ui_helper.rb

@@ -0,0 +1,41 @@
+module Dbviewer
+  module UiHelper
+    # Dark mode helper methods
+
+    # Returns the theme toggle icon based on the current theme
+    def theme_toggle_icon
+      '<i class="bi bi-moon"></i><i class="bi bi-sun"></i>'.html_safe
+    end
+
+    # Returns the aria label for the theme toggle button
+    def theme_toggle_label
+      "Toggle dark mode"
+    end
+
+    # Returns the appropriate background class for stat cards that adapts to dark mode
+    def stat_card_bg_class
+      "stat-card-bg"
+    end
+
+    # Helper method for code blocks background that adapts to dark mode
+    def code_block_bg_class
+      "sql-code-block"
+    end
+
+    # Render time grouping links
+    def time_grouping_links(table_name, current_grouping)
+      params = common_params
+
+      content_tag(:div, class: "btn-group btn-group-sm", role: "group", 'aria-label': "Time grouping") do
+        [
+          link_to("Hourly", table_path(table_name, params.merge(time_group: "hourly")),
+                 class: "btn btn-outline-primary #{current_grouping == 'hourly' ? 'active' : ''}"),
+          link_to("Daily", table_path(table_name, params.merge(time_group: "daily")),
+                 class: "btn btn-outline-primary #{current_grouping == 'daily' ? 'active' : ''}"),
+          link_to("Weekly", table_path(table_name, params.merge(time_group: "weekly")),
+                 class: "btn btn-outline-primary #{current_grouping == 'weekly' ? 'active' : ''}")
+        ].join.html_safe
+      end
+    end
+  end
+end

data/lib/dbviewer/database/manager.rb

@@ -17,7 +17,6 @@ module Dbviewer
         @table_query_operations = ::Dbviewer::Datatable::QueryOperations.new(
           @connection,
           @dynamic_model_factory,
-          @query_executor,
           @table_metadata_manager
         )
         reset_cache_if_needed
@@ -108,7 +107,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)
-        @table_query_operations.execute_query(sql)
+        @query_executor.execute_query(sql)
       end
 
       # Execute a SQLite PRAGMA command without adding a LIMIT clause
@@ -116,7 +115,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)
-        @table_query_operations.execute_sqlite_pragma(pragma)
+        @query_executor.execute_sqlite_pragma(pragma)
       end
 
       # Get table indexes

data/lib/dbviewer/datatable/query_operations.rb

@@ -8,13 +8,11 @@ module Dbviewer
       # Initialize with dependencies
       # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] The database connection
       # @param dynamic_model_factory [Dbviewer::Database::DynamicModelFactory] Factory for creating dynamic AR models
-      # @param query_executor [Dbviewer::Query::Executor] Executor for raw SQL queries
       # @param table_metadata_manager [Dbviewer::Database::MetadataManager] Manager for table metadata
-      def initialize(connection, dynamic_model_factory, query_executor, table_metadata_manager)
+      def initialize(connection, dynamic_model_factory, table_metadata_manager)
         @connection = connection
         @adapter_name = connection.adapter_name.downcase
         @dynamic_model_factory = dynamic_model_factory
-        @query_executor = query_executor
         @table_metadata_manager = table_metadata_manager
         @query_analyzer = ::Dbviewer::Query::Analyzer.new(connection)
       end
@@ -49,7 +47,7 @@ module Dbviewer
         column_names = table_columns(table_name).map { |c| c[:name] }
 
         # Format results
-        @query_executor.to_result_set(records, column_names)
+        to_result_set(records, column_names)
       rescue => e
         Rails.logger.error("[DBViewer] Error executing table query: #{e.message}")
         raise e
@@ -92,22 +90,6 @@ module Dbviewer
 
       ## -- Delegator
 
-      # Execute a raw SQL query after validating for safety
-      # @param sql [String] SQL query to execute
-      # @return [ActiveRecord::Result] Result set with columns and rows
-      # @raise [StandardError] If the query is invalid or unsafe
-      def execute_query(sql)
-        @query_executor.execute_query(sql)
-      end
-
-      # Execute a SQLite PRAGMA command without adding a LIMIT clause
-      # @param pragma [String] PRAGMA command to execute (without the "PRAGMA" keyword)
-      # @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)
-        @query_executor.execute_sqlite_pragma(pragma)
-      end
-
       # Analyze query patterns and return performance recommendations
       # @param table_name [String] Name of the table
       # @param query_params [Dbviewer::Datatable::QueryParams] Query parameters
@@ -200,6 +182,39 @@ module Dbviewer
       def primary_key(table_name)
         @table_metadata_manager.primary_key(table_name)
       end
+
+      # Convert ActiveRecord::Relation to a standard result format
+      # @param records [ActiveRecord::Relation] Records to convert
+      # @param column_names [Array<String>] Column names
+      # @return [ActiveRecord::Result] Result set with columns and rows
+      def to_result_set(records, column_names)
+        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: #{e.message}")
+        ActiveRecord::Result.new([], [])
+      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
+      end
     end
   end
 end

data/lib/dbviewer/query/executor.rb

@@ -53,41 +53,6 @@ module Dbviewer
         Rails.logger.error("[DBViewer] SQLite pragma error: #{e.message} for pragma: #{pragma}")
         raise e
       end
-
-      # Convert ActiveRecord::Relation to a standard result format
-      # @param records [ActiveRecord::Relation] Records to convert
-      # @param column_names [Array<String>] Column names
-      # @return [ActiveRecord::Result] Result set with columns and rows
-      def to_result_set(records, column_names)
-        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: #{e.message}")
-        ActiveRecord::Result.new([], [])
-      end
-
-      private
-
-      # 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
-      end
     end
   end
 end

data/lib/dbviewer/version.rb

@@ -1,3 +1,3 @@
 module Dbviewer
-  VERSION = "0.6.3"
+  VERSION = "0.6.4"
 end