dbdoc_engine 0.1.0

data/app/services/dbdoc_engine/schema_rb_import_service.rb

@@ -0,0 +1,194 @@
+module DbdocEngine
+  class SchemaRbImportService
+    DEFAULT_GROUP_NAME = "Imported Schema".freeze
+    DEFAULT_GROUP_COLOR = "#6c757d".freeze
+    SKIP_TABLES = %w[
+      ar_internal_metadata
+      schema_migrations
+      active_storage_blobs
+      active_storage_attachments
+      active_storage_variant_records
+      action_text_rich_texts
+      solid_queue_blocked_executions
+      solid_queue_claimed_executions
+      solid_queue_failed_executions
+      solid_queue_jobs
+      solid_queue_pauses
+      solid_queue_processes
+      solid_queue_ready_executions
+      solid_queue_recurring_executions
+      solid_queue_recurring_tasks
+      solid_queue_scheduled_executions
+      solid_queue_semaphores
+      solid_cache_entries
+      solid_cable_messages
+    ].freeze
+
+    def initialize(schema_content, imported_by:)
+      @schema_content = schema_content
+      @imported_by = imported_by
+    end
+
+    def import!
+      parsed = SchemaRbParserService.new(@schema_content).parse
+      tables_data = parsed[:tables].reject { |t| SKIP_TABLES.include?(t[:table_name]) }
+
+      raise "No tables found in the schema file." if tables_data.empty?
+
+      total_columns = 0
+
+      ActiveRecord::Base.transaction do
+        clear_existing_data
+
+        suppress_changelog_callbacks do
+          group = create_default_group
+          total_columns = bulk_import_tables_and_columns(tables_data, group)
+        end
+
+        log_import_summary(tables_data.size, total_columns)
+      end
+
+      { status: "ok", tables_count: tables_data.size }
+    rescue => e
+      { status: "error", error: e.message }
+    end
+
+    private
+
+    def clear_existing_data
+      DbDesignDynamicColumn.unscoped.delete_all
+      DbDesignDynamicTable.unscoped.delete_all
+      DbDesignTableGroup.unscoped.delete_all
+    end
+
+    def create_default_group
+      DbDesignTableGroup.create!(
+        group_name: DEFAULT_GROUP_NAME,
+        group_color: DEFAULT_GROUP_COLOR,
+        created_by: @imported_by
+      )
+    end
+
+    def bulk_import_tables_and_columns(tables_data, group)
+      now = Time.current
+
+      table_rows = tables_data.map do |td|
+        {
+          table_name: td[:table_name],
+          physical_table_name: td[:table_name],
+          db_design_table_group_id: group.id,
+          description: build_table_description(td),
+          created_by: @imported_by,
+          created_at: now,
+          updated_at: now
+        }
+      end
+
+      DbDesignDynamicTable.insert_all!(table_rows)
+
+      inserted_tables = DbDesignDynamicTable.unscoped
+                          .where(db_design_table_group_id: group.id)
+                          .pluck(:table_name, :id)
+                          .to_h
+
+      column_rows = []
+
+      tables_data.each do |td|
+        table_id = inserted_tables[td[:table_name]]
+        next unless table_id
+
+        indexed_columns = collect_indexed_columns(td[:indexes])
+        unique_columns = collect_unique_columns(td[:indexes])
+
+        (td[:columns] || []).each do |col|
+          column_rows << {
+            db_design_dynamic_table_id: table_id,
+            column_name: col[:column_name],
+            physical_column_name: col[:column_name],
+            data_type: col[:data_type],
+            length: col[:length],
+            decimal_precision: col[:decimal_precision],
+            is_primary_key: col[:is_primary_key] || false,
+            is_foreign_key: col[:is_foreign_key] || false,
+            foreign_table_name: col[:foreign_table_name],
+            foreign_column_name: col[:foreign_column_name],
+            is_candidate_key: col[:is_candidate_key] || false,
+            is_unique_key: col[:is_unique_key] || unique_columns.include?(col[:column_name]),
+            is_indexed: col[:is_indexed] || indexed_columns.include?(col[:column_name]),
+            not_null: col[:not_null] || false,
+            default_value: col[:default_value],
+            description: col[:description],
+            created_by: @imported_by,
+            created_at: now,
+            updated_at: now
+          }
+        end
+      end
+
+      DbDesignDynamicColumn.insert_all!(column_rows) if column_rows.any?
+
+      column_rows.size
+    end
+
+    def collect_indexed_columns(indexes)
+      return Set.new if indexes.blank?
+
+      indexes.each_with_object(Set.new) do |idx, set|
+        next unless idx && idx[:columns]
+
+        idx[:columns].each { |c| set.add(c) } if idx[:columns].size == 1
+      end
+    end
+
+    def collect_unique_columns(indexes)
+      return Set.new if indexes.blank?
+
+      indexes.select { |idx| idx && idx[:unique] }.each_with_object(Set.new) do |idx, set|
+        idx[:columns].each { |c| set.add(c) } if idx[:columns].size == 1
+      end
+    end
+
+    def suppress_changelog_callbacks
+      callbacks_to_skip = [
+        [DbDesignTableGroup, :create, :after, :log_creation],
+        [DbDesignTableGroup, :update, :after, :log_update],
+        [DbDesignTableGroup, :destroy, :before, :log_deletion],
+        [DbDesignDynamicTable, :create, :after, :log_creation],
+        [DbDesignDynamicTable, :update, :after, :log_update],
+        [DbDesignDynamicTable, :destroy, :before, :log_deletion],
+        [DbDesignDynamicColumn, :create, :after, :log_creation],
+        [DbDesignDynamicColumn, :update, :after, :log_update],
+        [DbDesignDynamicColumn, :destroy, :before, :log_deletion]
+      ]
+
+      callbacks_to_skip.each { |model, event, timing, method| model.skip_callback(event, timing, method, raise: false) }
+      yield
+    ensure
+      callbacks_to_skip.each { |model, event, timing, method| model.set_callback(event, timing, method) rescue nil }
+    end
+
+    def log_import_summary(tables_count, columns_count)
+      DbDesignChangelog.create!(
+        change_timestamp: Time.current,
+        action_type: DbDesignChangelog::ACTION_CREATE,
+        entity_type: DbDesignChangelog::ENTITY_TABLE,
+        entity_name: "schema_import",
+        description: "Imported #{tables_count} tables with #{columns_count} columns from schema.rb",
+        changed_by: @imported_by
+      )
+    end
+
+    def build_table_description(table_data)
+      parts = []
+      col_count = table_data[:columns]&.size || 0
+      idx_count = table_data[:indexes]&.size || 0
+      fk_count = table_data[:columns]&.count { |c| c[:is_foreign_key] } || 0
+
+      parts << "#{col_count} columns"
+      parts << "#{idx_count} indexes" if idx_count > 0
+      parts << "#{fk_count} foreign keys" if fk_count > 0
+
+      "Imported from schema.rb (#{parts.join(', ')})"
+    end
+  end
+end

data/app/services/dbdoc_engine/schema_rb_parser_service.rb

@@ -0,0 +1,339 @@
+module DbdocEngine
+  class SchemaRbParserService
+    RAILS_TYPE_MAP = {
+      "string" => "varchar",
+      "text" => "text",
+      "integer" => "integer",
+      "bigint" => "bigint",
+      "float" => "float",
+      "decimal" => "decimal",
+      "boolean" => "boolean",
+      "datetime" => "datetime",
+      "date" => "date",
+      "time" => "time",
+      "binary" => "binary",
+      "json" => "json",
+      "jsonb" => "jsonb",
+      "uuid" => "uuid",
+      "inet" => "inet",
+      "cidr" => "cidr",
+      "macaddr" => "macaddr",
+      "hstore" => "hstore",
+      "serial" => "serial",
+      "tsrange" => "tsrange",
+      "daterange" => "daterange",
+      "int4range" => "int4range",
+      "int8range" => "int8range",
+      "numrange" => "numrange",
+      "point" => "point",
+      "line" => "line",
+      "circle" => "circle",
+      "polygon" => "polygon",
+      "xml" => "xml",
+      "money" => "money",
+      "virtual" => "virtual"
+    }.freeze
+
+    TIMESTAMP_COLUMNS = %w[created_at updated_at].freeze
+
+    def initialize(schema_content)
+      @schema_content = schema_content
+      @tables = []
+      @foreign_keys = []
+      @standalone_indexes = []
+    end
+
+    def parse
+      extract_tables
+      extract_standalone_foreign_keys
+      extract_standalone_indexes
+      apply_foreign_keys_to_columns
+      apply_standalone_indexes
+
+      { tables: @tables, foreign_keys: @foreign_keys }
+    end
+
+    private
+
+    def extract_tables
+      @schema_content.scan(/create_table\s+["'](\w+)["'].*?do\s*\|(\w+)\|(.*?)^\s*end/m).each do |match|
+        table_name = match[0]
+        block_var = match[1]
+        block_body = match[2]
+
+        columns = []
+        indexes = []
+
+        block_body.each_line do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#")
+
+          if line.match?(/\A#{Regexp.escape(block_var)}\.index\b/)
+            indexes << parse_inline_index(line, block_var)
+          elsif line.match?(/\A#{Regexp.escape(block_var)}\.timestamps\b/)
+            columns.concat(build_timestamp_columns(line))
+          elsif line.match?(/\A#{Regexp.escape(block_var)}\.(references|belongs_to)\b/)
+            columns << parse_reference_column(line, block_var)
+          elsif line.match?(/\A#{Regexp.escape(block_var)}\.(\w+)\s/)
+            col = parse_column(line, block_var)
+            columns << col if col
+          end
+        end
+
+        @tables << {
+          table_name: table_name,
+          columns: columns,
+          indexes: indexes
+        }
+      end
+    end
+
+    def parse_column(line, block_var)
+      match = line.match(/\A#{Regexp.escape(block_var)}\.(\w+)\s+["'](\w+)["'](.*)/)
+      return nil unless match
+
+      rails_type = match[1]
+      column_name = match[2]
+      options_str = match[3]
+
+      return nil unless RAILS_TYPE_MAP.key?(rails_type)
+
+      options = parse_options(options_str)
+
+      {
+        column_name: column_name,
+        data_type: RAILS_TYPE_MAP[rails_type],
+        not_null: options[:null] == false,
+        default_value: format_default(options[:default]),
+        length: options[:limit],
+        decimal_precision: options[:precision],
+        description: options[:comment],
+        is_primary_key: false,
+        is_foreign_key: false,
+        is_indexed: false,
+        is_candidate_key: false,
+        is_unique_key: false
+      }
+    end
+
+    def parse_reference_column(line, block_var)
+      match = line.match(/\A#{Regexp.escape(block_var)}\.(references|belongs_to)\s+[:]?["']?(\w+)["']?(.*)/)
+      return nil unless match
+
+      ref_name = match[2]
+      options_str = match[3]
+      options = parse_options(options_str)
+
+      column_name = "#{ref_name}_id"
+      foreign_table = options[:to_table] || ref_name.pluralize
+
+      col = {
+        column_name: column_name,
+        data_type: "bigint",
+        not_null: options[:null] == false,
+        default_value: nil,
+        length: nil,
+        decimal_precision: nil,
+        description: options[:comment],
+        is_primary_key: false,
+        is_foreign_key: !!options[:foreign_key],
+        foreign_table_name: options[:foreign_key] ? foreign_table : nil,
+        foreign_column_name: options[:foreign_key] ? "id" : nil,
+        is_indexed: true,
+        is_candidate_key: false,
+        is_unique_key: false
+      }
+
+      if options[:foreign_key].is_a?(Hash) && options[:foreign_key][:to_table]
+        col[:foreign_table_name] = options[:foreign_key][:to_table].to_s
+      end
+
+      col
+    end
+
+    def build_timestamp_columns(line)
+      options = parse_options(line.sub(/\A\w+\.timestamps/, ""))
+      is_not_null = options[:null] == false
+
+      TIMESTAMP_COLUMNS.map do |col_name|
+        {
+          column_name: col_name,
+          data_type: "datetime",
+          not_null: is_not_null,
+          default_value: nil,
+          length: nil,
+          decimal_precision: nil,
+          description: nil,
+          is_primary_key: false,
+          is_foreign_key: false,
+          is_indexed: false,
+          is_candidate_key: false,
+          is_unique_key: false
+        }
+      end
+    end
+
+    def parse_inline_index(line, block_var)
+      cols_match = line.match(/\A#{Regexp.escape(block_var)}\.index\s+\[([^\]]+)\](.*)/) ||
+                   line.match(/\A#{Regexp.escape(block_var)}\.index\s+["'](\w+)["'](.*)/)
+
+      return nil unless cols_match
+
+      raw_cols = cols_match[1]
+      options_str = cols_match[2]
+
+      columns = if raw_cols.include?(",")
+                  raw_cols.scan(/["'](\w+)["']/).flatten
+                else
+                  [raw_cols.delete("'\"").strip]
+                end
+
+      options = parse_options(options_str)
+
+      {
+        columns: columns,
+        unique: options[:unique] == true,
+        name: options[:name]
+      }
+    end
+
+    def extract_standalone_foreign_keys
+      @schema_content.scan(/add_foreign_key\s+["'](\w+)["']\s*,\s*["'](\w+)["'](.*)/).each do |match|
+        from_table = match[0]
+        to_table = match[1]
+        options_str = match[2]
+        options = parse_options(options_str)
+        column = options[:column] || "#{to_table.singularize}_id"
+
+        @foreign_keys << {
+          from_table: from_table,
+          to_table: to_table,
+          column: column.to_s,
+          primary_key: (options[:primary_key] || "id").to_s
+        }
+      end
+    end
+
+    def extract_standalone_indexes
+      @schema_content.scan(/^\s*add_index\s+[:"'](\w+)["']?\s*,\s*(.+)/).each do |match|
+        table_name = match[0]
+        rest = match[1]
+
+        cols_match = rest.match(/\[([^\]]+)\](.*)/) || rest.match(/[:"'](\w+)["']?(.*)/)
+        next unless cols_match
+
+        raw_cols = cols_match[1]
+        options_str = cols_match[2]
+
+        columns = if raw_cols.include?(",")
+                    raw_cols.scan(/["']?(\w+)["']?/).flatten
+                  else
+                    [raw_cols.delete(":'\"").strip]
+                  end
+
+        options = parse_options(options_str)
+
+        @standalone_indexes << {
+          table_name: table_name,
+          columns: columns,
+          unique: options[:unique] == true,
+          name: options[:name]
+        }
+      end
+    end
+
+    def apply_foreign_keys_to_columns
+      @foreign_keys.each do |fk|
+        table = @tables.find { |t| t[:table_name] == fk[:from_table] }
+        next unless table
+
+        col = table[:columns].find { |c| c[:column_name] == fk[:column] }
+        next unless col
+
+        col[:is_foreign_key] = true
+        col[:foreign_table_name] = fk[:to_table]
+        col[:foreign_column_name] = fk[:primary_key]
+      end
+    end
+
+    def apply_standalone_indexes
+      @standalone_indexes.each do |idx|
+        table = @tables.find { |t| t[:table_name] == idx[:table_name] }
+        next unless table
+
+        if idx[:columns].size == 1
+          col = table[:columns].find { |c| c[:column_name] == idx[:columns].first }
+          if col
+            col[:is_indexed] = true
+            col[:is_unique_key] = true if idx[:unique]
+          end
+        end
+
+        table[:indexes] << idx
+      end
+    end
+
+    def parse_options(options_str)
+      return {} if options_str.nil? || options_str.strip.empty?
+
+      opts = {}
+
+      opts[:null] = false if options_str.match?(/null:\s*false/)
+      opts[:null] = true if options_str.match?(/null:\s*true/)
+
+      opts[:unique] = true if options_str.match?(/unique:\s*true/)
+
+      if (m = options_str.match(/default:\s*("([^"]*)"|'([^']*)'|(\S+?)(?:\s*,|\s*$))/))
+        val = m[2] || m[3] || m[4]
+        opts[:default] = coerce_default(val)
+      end
+
+      if (m = options_str.match(/limit:\s*(\d+)/))
+        opts[:limit] = m[1].to_i
+      end
+
+      if (m = options_str.match(/precision:\s*(\d+)/))
+        opts[:precision] = m[1].to_i
+      end
+
+      if (m = options_str.match(/comment:\s*["']([^"']+)["']/))
+        opts[:comment] = m[1]
+      end
+
+      if (m = options_str.match(/name:\s*["']([^"']+)["']/))
+        opts[:name] = m[1]
+      end
+
+      opts[:foreign_key] = true if options_str.match?(/foreign_key:\s*true/)
+
+      if (m = options_str.match(/foreign_key:\s*\{([^}]+)\}/))
+        fk_opts = {}
+        fk_opts[:to_table] = m[1].match(/to_table:\s*[:"'](\w+)/)[1] if m[1].match?(/to_table:/)
+        opts[:foreign_key] = fk_opts
+      end
+
+      if (m = options_str.match(/column:\s*[:"'](\w+)/))
+        opts[:column] = m[1]
+      end
+
+      if (m = options_str.match(/primary_key:\s*[:"'](\w+)/))
+        opts[:primary_key] = m[1]
+      end
+
+      opts
+    end
+
+    def coerce_default(val)
+      return nil if val.nil?
+      return val.to_s if val.is_a?(String)
+
+      val.to_s
+    end
+
+    def format_default(val)
+      return nil if val.nil?
+
+      val.to_s
+    end
+  end
+end

data/app/services/dbdoc_engine/table_filter_service.rb

@@ -0,0 +1,35 @@
+# Service for filtering table queries based on group and search parameters
+module DbdocEngine
+class TableFilterService
+  attr_reader :tables, :params
+
+  # Initialize with a base tables relation and filtering params
+  def initialize(tables, params)
+    @tables = tables
+    @params = params
+  end
+
+  # Apply all filters and return the filtered tables relation
+  def filter
+    @tables = apply_group_filter      # Filter by group if param present
+    @tables = apply_search            # Filter by search if param present
+    tables                            # Return the final filtered relation
+  end
+
+  private
+
+  # Filter tables by group if group_filter param is present
+  def apply_group_filter
+    return tables unless params[:group_filter].present?
+
+    DbdocEngine::DbDesignDynamicTableQueries.filter_by_group(tables, params[:group_filter])
+  end
+
+  # Filter tables by search term if search param is present
+  def apply_search
+    return tables unless params[:search].present?
+
+    DbdocEngine::DbDesignDynamicTableQueries.search_tables(tables, params[:search])
+  end
+end
+end