dbdoc_engine 0.1.0

data/app/models/dbdoc_engine/db_design_dynamic_column.rb

@@ -0,0 +1,211 @@
+# Model for dynamically created columns
+module DbdocEngine
+  class DbDesignDynamicColumn < ApplicationRecord
+    include DbdocEngine::Concerns::SoftDeletable
+    self.table_name = 'db_design_dynamic_columns'
+    
+    # Constants for relationship types
+    RELATIONSHIP_ONE_TO_ONE = 'one_to_one'.freeze
+    RELATIONSHIP_ONE_TO_MANY = 'one_to_many'.freeze
+    RELATIONSHIP_MANY_TO_ONE = 'many_to_one'.freeze
+    RELATIONSHIP_MANY_TO_MANY = 'many_to_many'.freeze
+    RELATIONSHIP_TYPES = [RELATIONSHIP_ONE_TO_ONE, RELATIONSHIP_ONE_TO_MANY, RELATIONSHIP_MANY_TO_ONE, RELATIONSHIP_MANY_TO_MANY].freeze
+    
+    # Association: Each column belongs to a dynamic table
+    belongs_to :db_design_dynamic_table
+
+    # === Validations ===
+
+    # Ensures the column name is present, unique within the table, and follows naming conventions
+    validates :column_name,
+              presence: true,
+              uniqueness: { scope: :db_design_dynamic_table_id },
+              format: { with: /\A[a-z_]+\z/ }
+
+    # Ensures the physical column name is present
+    validates :physical_column_name, presence: true
+
+    # Ensures a data type is selected
+    validates :data_type, presence: true
+
+    # Ensures the creator's name is recorded
+    validates :created_by, presence: true
+
+    # Ensures foreign key constraints are properly defined when applicable
+    validates :foreign_table_name, presence: true, if: -> { is_foreign_key }
+    validates :foreign_column_name, presence: true, if: -> { is_foreign_key }
+    
+    # Validates relationship_type when it's a foreign key
+    validates :relationship_type, inclusion: { in: RELATIONSHIP_TYPES }, if: -> { is_foreign_key && relationship_type.present? }
+
+    # === Callbacks ===
+
+    # Normalizes column name format before saving
+    before_save :normalize_column_name
+
+    # Prevents deletion if the column is referenced as a foreign key
+    before_destroy :check_foreign_key_dependencies
+
+    # Logs changes after creation, update, and deletion
+    after_create :log_creation
+    after_update :log_update
+    before_destroy :log_deletion
+
+    # Default scope to exclude soft-deleted records
+    default_scope { without_deleted }
+
+    private
+
+    # Converts column name to lowercase and replaces spaces with underscores
+    def normalize_column_name
+      self.column_name = column_name.downcase.gsub(/\s+/, '_')
+    end
+
+    # Prevents deletion if the column is referenced as a foreign key in another table
+    def check_foreign_key_dependencies
+      table_name = db_design_dynamic_table.table_name
+      return unless DbdocEngine::DbDesignDynamicColumnQueries.column_referenced_as_foreign_key?(table_name, column_name)
+
+      errors.add(:base, "Cannot delete column '#{column_name}' because it is referenced as a foreign key in another table.")
+      throw :abort
+    end
+
+    # Logs column creation in the changelog
+    def log_creation
+      table_name = db_design_dynamic_table.table_name
+      entity_name = "#{table_name}.#{column_name}"
+
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_CREATE,
+        DbDesignChangelog::ENTITY_COLUMN,
+        entity_name,
+        "Added column '#{column_name}' to table '#{table_name}'",
+        created_by,
+        nil,
+        {
+          column_name: column_name,
+          physical_column_name: physical_column_name,
+          data_type: data_type,
+          length: length,
+          decimal_precision: decimal_precision,
+          is_primary_key: is_primary_key,
+          is_foreign_key: is_foreign_key,
+          foreign_table_name: foreign_table_name,
+          foreign_column_name: foreign_column_name,
+          relationship_type: relationship_type,
+          not_null: not_null,
+          default_value: default_value,
+          sample_value: sample_value,
+          description: description
+        }
+      )
+    end
+
+    # Logs updates to column attributes in the changelog
+    def log_update
+      changes_data = collect_attribute_changes
+      return unless changes_data[:changes_desc].any?
+    
+      # Use updated_by from the associated dynamic_table instead of created_by
+      user_who_updated = db_design_dynamic_table&.updated_by || updated_by || created_by
+    
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_UPDATE,
+        DbDesignChangelog::ENTITY_COLUMN,
+        changes_data[:entity_name],
+        "Updated column '#{column_name}' in table '#{changes_data[:table_name]}': #{changes_data[:changes_desc].join(', ')}",
+        user_who_updated,
+        changes_data[:previous_values],
+        changes_data[:new_values]
+      )
+    end
+
+    # Collects changes to column attributes for logging
+    def collect_attribute_changes
+      table_name = db_design_dynamic_table.table_name
+      entity_name = "#{table_name}.#{column_name}"
+      changes_desc = []
+      previous_values = {}
+      new_values = {}
+
+      # Mapping attribute names to human-readable labels for logging
+      attribute_mappings.each do |attr, label|
+        next unless saved_change_to_attribute?(attr.to_s)
+
+        old_val, new_val = saved_change_to_attribute(attr.to_s)
+
+        # Format boolean values for better readability
+        if [true, false].include?(old_val)
+          old_val = old_val ? 'Yes' : 'No'
+          new_val = new_val ? 'Yes' : 'No'
+        end
+
+        changes_desc << "#{label} changed from '#{old_val}' to '#{new_val}'"
+        previous_values[attr] = old_val
+        new_values[attr] = new_val
+      end
+
+      {
+        table_name: table_name,
+        entity_name: entity_name,
+        changes_desc: changes_desc,
+        previous_values: previous_values,
+        new_values: new_values
+      }
+    end
+
+    # Define attribute mappings for logging
+    def attribute_mappings
+      {
+        column_name: 'name',
+        physical_column_name: 'physical name',
+        data_type: 'data type',
+        length: 'length',
+        decimal_precision: 'decimal_precision',
+        is_primary_key: 'primary key status',
+        is_foreign_key: 'foreign key status',
+        foreign_table_name: 'foreign table',
+        foreign_column_name: 'foreign column',
+        relationship_type: 'relationship type',
+        is_candidate_key: 'candidate key status',
+        is_unique_key: 'unique key status',
+        is_indexed: 'index status',
+        not_null: 'nullable status',
+        default_value: 'default value',
+        sample_value: 'sample value',
+        description: 'description'
+      }
+    end
+
+    # Logs column deletion in the changelog
+    def log_deletion
+      table_name = db_design_dynamic_table.table_name
+      entity_name = "#{table_name}.#{column_name}"
+
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_DELETE,
+        DbDesignChangelog::ENTITY_COLUMN,
+        entity_name,
+        "Deleted column '#{column_name}' from table '#{table_name}'",
+        created_by,
+        {
+          column_name: column_name,
+          physical_column_name: physical_column_name,
+          data_type: data_type,
+          length: length,
+          decimal_precision: decimal_precision,
+          is_primary_key: is_primary_key,
+          is_foreign_key: is_foreign_key,
+          foreign_table_name: foreign_table_name,
+          foreign_column_name: foreign_column_name,
+          relationship_type: relationship_type,
+          not_null: not_null,
+          default_value: default_value,
+          sample_value: sample_value,
+          description: description
+        },
+        nil
+      )
+    end
+  end
+end

data/app/models/dbdoc_engine/db_design_dynamic_table.rb

@@ -0,0 +1,124 @@
+# Model for dynamic tables
+module DbdocEngine
+  class DbDesignDynamicTable < ApplicationRecord
+    # Include concern to support soft deletion functionality
+    include DbdocEngine::Concerns::SoftDeletable
+    self.table_name = 'db_design_dynamic_tables'
+    # Associations
+    belongs_to :db_design_table_group
+    has_many :db_design_dynamic_columns, dependent: :destroy
+
+    # Validations
+    validates :table_name, presence: true, uniqueness: { case_sensitive: false },
+                          format: { with: /\A[a-z0-9_]+\z/ } # Only lowercase and underscores allowed
+    validates :created_by, presence: true
+    validates :physical_table_name, presence: true
+    validates :db_design_table_group_id, presence: true
+
+    # Accept nested attributes for associated models
+    accepts_nested_attributes_for :db_design_dynamic_columns, allow_destroy: true
+
+    # Lifecycle callbacks
+    before_save :normalize_table_name
+    before_destroy :prevent_deletion_if_referenced
+    before_destroy :log_deletion
+    after_create :log_creation
+    after_update :log_update
+
+    # Scope to exclude soft-deleted records
+    default_scope { without_deleted }
+
+    private
+
+    # Normalize the table name: downcase, remove extra spaces, convert spaces to underscores
+    def normalize_table_name
+      self.table_name = table_name.downcase.strip.gsub(/\s+/, '_').gsub(/_{2,}/, '_')
+    end
+
+    # Prevent deletion if this table is referenced by any foreign key in another table
+    def prevent_deletion_if_referenced
+      DbDesignDynamicColumn.joins(:referencing_relations).where(db_design_dynamic_table_id: id)
+      # NOTE: You might want to add a condition to actually abort deletion with an error here.
+    end
+
+    # Log creation of a new dynamic table
+    def log_creation
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_CREATE,
+        DbDesignChangelog::ENTITY_TABLE,
+        table_name,
+        "Created new table '#{table_name}'",
+        created_by,
+        nil,
+        {
+          table_name: table_name,
+          group_id: db_design_table_group_id,
+          description: description
+        }
+      )
+    end
+
+    # Log updates with a summary of changes
+    def log_update
+      changes_desc = []
+      previous_values = {}
+      new_values = {}
+
+      # Track table name change
+      if saved_change_to_table_name?
+        old_name, new_name = saved_change_to_table_name
+        changes_desc << "name changed from '#{old_name}' to '#{new_name}'"
+        previous_values[:table_name] = old_name
+        new_values[:table_name] = new_name
+      end
+
+      # Track table group change
+      if saved_change_to_db_design_table_group_id?
+        old_group_id, new_group_id = saved_change_to_db_design_table_group_id
+        old_group = DbdocEngine::DbDesignTableGroupQueries.find_group_name(old_group_id) || 'unknown'
+        new_group = DbdocEngine::DbDesignTableGroupQueries.find_group_name(new_group_id) || 'unknown'
+        changes_desc << "group changed from '#{old_group}' to '#{new_group}'"
+        previous_values[:group_id] = old_group_id
+        new_values[:group_id] = new_group_id
+      end
+
+      # Track description change
+      if saved_change_to_description?
+        old_desc, new_desc = saved_change_to_description
+        changes_desc << 'description updated'
+        previous_values[:description] = old_desc
+        new_values[:description] = new_desc
+      end
+
+      # Only log if there are changes
+      return unless changes_desc.any?
+
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_UPDATE,
+        DbDesignChangelog::ENTITY_TABLE,
+        table_name,
+        "Updated table '#{table_name}': #{changes_desc.join(', ')}",
+        updated_by,
+        previous_values,
+        new_values
+      )
+    end
+
+    # Log deletion of the dynamic table
+    def log_deletion
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_DELETE,
+        DbDesignChangelog::ENTITY_TABLE,
+        table_name,
+        "Deleted table '#{table_name}'",
+        updated_by,
+        {
+          table_name: table_name,
+          group_id: db_design_table_group_id,
+          description: description
+        },
+        nil
+      )
+    end
+  end
+end

data/app/models/dbdoc_engine/db_design_table_group.rb

@@ -0,0 +1,88 @@
+# Model representing a group of dynamic tables
+module DbdocEngine
+  class DbDesignTableGroup < ApplicationRecord
+    # Include concern to enable soft deletion functionality
+    include DbdocEngine::Concerns::SoftDeletable
+    self.table_name = 'db_design_table_groups'
+    # Associations
+    has_many :db_design_dynamic_tables, dependent: :destroy # Deleting a group will delete all its associated tables
+
+    # Validations
+    validates :group_name, presence: true, uniqueness: true # Ensure unique group name
+    validates :group_color, presence: true # Group must have a color assigned
+    validates :created_by, presence: true, if: :new_record? # Track who created the group
+    validates :updated_by, presence: true, unless: :new_record?, on: :update
+
+    # Callbacks
+    after_create :log_creation # Log group creation
+    after_update :log_update # Log group updates
+    before_destroy :log_deletion # Log group deletion before removing it
+
+    # Scope to exclude soft-deleted records from default queries
+    default_scope { without_deleted }
+
+    private
+
+    # Log the creation of a new table group
+    def log_creation
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_CREATE,
+        DbDesignChangelog::ENTITY_TABLE_GROUP,
+        group_name,
+        "Created new table group '#{group_name}'",
+        created_by || updated_by || 'system', # Default to 'system' if no user info is available
+        nil, # No previous values for creation
+        { group_name: group_name, group_color: group_color } # New values being logged
+      )
+    end
+
+    # Log changes made to the table group
+    def log_update
+      changes_desc = [] # Store descriptions of changes
+      previous_values = {} # Store old values
+      new_values = {} # Store new values
+
+      # Track group name changes
+      if saved_change_to_group_name?
+        old_name, new_name = saved_change_to_group_name
+        changes_desc << "name changed from '#{old_name}' to '#{new_name}'"
+        previous_values[:group_name] = old_name
+        new_values[:group_name] = new_name
+      end
+
+      # Track group color changes
+      if saved_change_to_group_color?
+        old_color, new_color = saved_change_to_group_color
+        changes_desc << "color changed from '#{old_color}' to '#{new_color}'"
+        previous_values[:group_color] = old_color
+        new_values[:group_color] = new_color
+      end
+
+      # Only log updates if there are actual changes
+      return unless changes_desc.any?
+
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_UPDATE,
+        DbDesignChangelog::ENTITY_TABLE_GROUP,
+        group_name,
+        "Updated table group '#{group_name}': #{changes_desc.join(', ')}",
+        updated_by || 'system',
+        previous_values,
+        new_values
+      )
+    end
+
+    # Log deletion of a table group
+    def log_deletion
+      DbdocEngine::DbDesignChangelogQueries.log_change(
+        DbDesignChangelog::ACTION_DELETE,
+        DbDesignChangelog::ENTITY_TABLE_GROUP,
+        group_name,
+        "Deleted table group '#{group_name}'",
+        updated_by || 'system',
+        { group_name: group_name, group_color: group_color }, # Old values being removed
+        nil # No new values after deletion
+      )
+    end
+  end
+end

data/app/models/dbdoc_engine/user.rb

@@ -0,0 +1,21 @@
+module DbdocEngine
+  class User < ApplicationRecord
+    self.table_name = "dbdoc_engine_users"
+    has_secure_password
+
+    validates :username, presence: true, uniqueness: true
+    validates :role, presence: true, inclusion: { in: %w[user admin superadmin] }
+
+    def admin?
+      role == "admin"
+    end
+
+    def superadmin?
+      role == "superadmin"
+    end
+
+    def admin_or_higher?
+      admin? || superadmin?
+    end
+  end
+end

data/app/queries/dbdoc_engine/admin_dashboard_queries.rb

@@ -0,0 +1,71 @@
+# app/queries/admin_dashboard_queries.rb
+
+# Service class for handling admin dashboard statistics and data formatting
+module DbdocEngine
+  class AdminDashboardQueries
+    class << self
+      # Get total count of table groups
+      # @return [Integer] Number of existing table groups
+      def groups_count
+        DbDesignTableGroup.count
+      end
+
+      # Get total count of dynamic tables
+      # @return [Integer] Number of existing tables
+      def tables_count
+        DbDesignDynamicTable.count
+      end
+
+      # Get total count of columns across all tables
+      # @return [Integer] Number of existing columns
+      def columns_count
+        DbDesignDynamicColumn.count
+      end
+
+      # Get filtered changelogs for audit history
+      # @param params [Hash] Filter parameters:
+      #   - :action_type (optional) Filter by specific action type
+      # @return [ActiveRecord::Relation] Filtered changelogs ordered by timestamp
+      def filtered_changelogs(params)
+        scope = DbDesignChangelog.order(change_timestamp: :desc)
+        scope = scope.where(action_type: params[:action_type]) if params[:action_type].present?
+        scope
+      end
+
+      # Format changelog data for chart visualization
+      # @param changelogs [Array<DbDesignChangelog>] Collection of changelog records
+      # @return [Hash] Structured data for chart rendering with:
+      #   - labels: Chart category labels
+      #   - datasets: Chart data series with colors and values
+      def prepare_chart_data(changelogs)
+        # Define entity types for chart categorization
+        entities = %w[table_group table column]
+
+        # Extract unique action types from changelogs
+        action_types = changelogs.pluck(:action_type).uniq
+
+        # Build datasets for each action type
+        datasets = action_types.map do |action|
+          {
+            label: action.titleize,
+            # Count occurrences per entity type for this action
+            data: entities.map { |e| changelogs.count { |log| log.action_type == action && log.entity_type == e } },
+            # Assign color based on action type
+            backgroundColor: case action
+                            when 'create' then '#4CAF50' # Green
+                            when 'update' then '#FFC107' # Amber
+                            when 'delete' then '#F44336' # Red
+                            else '#CCCCCC'               # Default gray
+                            end
+          }
+        end
+
+        # Return structured chart data
+        {
+          labels: %w[Groups Tables Columns], # X-axis labels
+          datasets: datasets                 # Data series collection
+        }
+      end
+    end
+  end
+end

data/app/queries/dbdoc_engine/db_design_changelog_queries.rb

@@ -0,0 +1,68 @@
+# queries/db_design_changelog_queries.rb
+
+# Query class handling database operations for change logs
+module DbdocEngine
+  class DbDesignChangelogQueries
+    class << self
+      # Fetch filtered changelogs based on provided parameters
+      # @param params [Hash] Filter parameters including:
+      #   - entity_type: Filter by entity type (table_group/table/column)
+      #   - entity_name: Partial match for entity name
+      #   - action_type: Filter by action type (create/update/delete)
+      #   - date_from: Start date filter
+      #   - date_to: End date filter
+      # @return [ActiveRecord::Relation] Filtered and ordered changelogs
+      def filtered_changelogs(params = {})
+        scope = DbDesignChangelog.all
+
+        scope = scope.where(entity_type: params[:entity_type]) if params[:entity_type].present?
+        scope = scope.where('entity_name ILIKE ?', "%#{params[:entity_name]}%") if params[:entity_name].present?
+        scope = scope.where(action_type: params[:action_type]) if params[:action_type].present?
+
+        if params[:date_from].present? && params[:date_to].present?
+          from_date = Date.parse(params[:date_from]).beginning_of_day
+          to_date = Date.parse(params[:date_to]).end_of_day
+          scope = scope.where(change_timestamp: from_date..to_date)
+        end
+
+        scope.order(change_timestamp: :desc)
+      end
+
+      # Find a specific changelog entry by ID
+      # @param id [Integer] Changelog ID to find
+      # @return [DbDesignChangelog, nil] Found changelog or nil
+      def find_changelog(id)
+        DbDesignChangelog.find_by(id: id)
+      end
+
+      # Create a new changelog entry with audit information
+      # @param action_type [String] Type of action performed
+      # @param entity_type [String] Type of entity affected
+      # @param entity_name [String] Name of the affected entity
+      # @param description [String] Human-readable change description
+      # @param changed_by [String] Identifier of who made the change
+      # @param previous_values [Hash] Optional previous state values
+      # @param new_values [Hash] Optional new state values
+      # @return [DbDesignChangelog] Newly created changelog record
+      def log_change(action_type, entity_type, entity_name, description, changed_by, previous_values = nil, new_values = nil)
+        DbDesignChangelog.create!(
+          change_timestamp: Time.current,
+          action_type: action_type,
+          entity_type: entity_type,
+          entity_name: entity_name,
+          description: description,
+          changed_by: changed_by,
+          previous_values: previous_values,
+          new_values: new_values
+        )
+      end
+
+      # Get group name by ID through TableGroupQueries
+      # @param id [Integer] Group ID to lookup
+      # @return [String, nil] Group name or nil if not found
+      def find_group_name(id)
+        DbDesignTableGroupQueries.find_group_name(id)
+      end
+    end
+  end
+end

data/app/queries/dbdoc_engine/db_design_dynamic_column_queries.rb

@@ -0,0 +1,37 @@
+# queries/db_design_dynamic_column_queries.rb
+
+# Query class for dynamic column-related database operations
+module DbdocEngine
+  class DbDesignDynamicColumnQueries
+    # Returns the DbDesignDynamicColumn model (centralized reference)
+    def self.model
+      DbDesignDynamicColumn
+    end
+
+    class << self
+      # Counts the number of columns in the given table.
+      # Uses .size to leverage eager-loaded associations when available,
+      # avoiding N+1 COUNT queries in loops.
+      def count_columns_in_table(table)
+        table.db_design_dynamic_columns.size
+      end
+
+      # Checks if a column is referenced as a foreign key in any (non-deleted) table
+      def column_referenced_as_foreign_key?(table_name, column_name)
+        # Joins with parent table, filters by foreign key reference and non-deleted tables
+        model.joins(:db_design_dynamic_table)
+            .where(
+              foreign_table_name: table_name,
+              foreign_column_name: column_name,
+              db_design_dynamic_tables: { deleted_at: nil }
+            )
+            .exists?
+      end
+
+      def all_foreign_keys_with_tables
+        model.joins(:db_design_dynamic_table)
+             .where(is_foreign_key: true, db_design_dynamic_tables: { deleted_at: nil })
+      end
+    end
+  end
+end