databasium 0.1.0

data/app/controllers/databasium/records_controller.rb

@@ -0,0 +1,156 @@
+class Databasium::RecordsController < Databasium::ApplicationController
+  before_action :create_schema_service
+  before_action :set_model_and_record_service
+  include Pagy::Method
+  include ActionView::RecordIdentifier
+
+  def index
+    render Views::Databasium::Records::Index.new
+  end
+
+  def create
+    new_record = @record_service.create_new(attributes: model_columns_params)
+    raise ActiveRecord::RecordInvalid, new_record.errors.full_messages.join(", ") unless new_record
+
+    render turbo_stream: [
+             turbo_stream.append(
+               "records_body",
+               Components::Databasium::Records::Table::Row.new(
+                 record: new_record,
+                 turbo_frame: "records_list"
+               )
+             ),
+             turbo_stream.remove("suggestion")
+           ]
+  end
+
+  def records
+    @context = records_context
+    pagy, records =
+      pagy(
+        @record_service.filter_records(filter_params),
+        limit: params[:limit].presence || 10,
+        root_key: "records"
+      )
+
+    if foreign_records_frame?(@context[:turbo_frame])
+      render_foreign_records_table
+    else
+      respond_to do |format|
+        format.html { render_records_table(records: records, pagy: pagy) }
+        format.turbo_stream { render_records_table_turbo_stream(records: records, pagy: pagy) }
+      end
+    end
+  end
+
+  def update
+    record = @record_service.update_by_id(params[:id], attributes: model_columns_params)
+    raise ActiveRecord::RecordInvalid, record.errors.full_messages.join(", ") unless record
+    render turbo_stream:
+             turbo_stream.replace(
+               dom_id(record),
+               Components::Databasium::Records::Table::Row.new(
+                 record: record,
+                 turbo_frame: "records_list"
+               )
+             )
+  end
+
+  def bulk_destroy
+    deleted_records = @record_service.bulk_destroy(params[:ids])
+    unless deleted_records
+      raise ActiveRecord::RecordInvalid, deleted_records.errors.full_messages.join(", ")
+    end
+
+    doms_ids = deleted_records.map { |record| dom_id(record) }
+
+    render turbo_stream:
+             doms_ids.flat_map { |dom_id|
+               [
+                 turbo_stream.remove(dom_id),
+                 turbo_stream.remove("record-tab-#{dom_id}"),
+                 turbo_stream.remove("record-form-#{dom_id}")
+               ]
+             }
+  end
+
+  def sidebar
+    @pagy_tables, @tables =
+      pagy(@schema_service.get_tables(params[:search]), limit: 7, root_key: "tables")
+    render Components::Databasium::SearchResults::Tables.new(tables: @tables, pagy: @pagy_tables)
+  end
+
+  private
+
+  def render_foreign_records_table
+    render Components::Databasium::Records::ForeignRecords.new(
+             model: @model,
+             columns_names_types: @context[:columns_names_types],
+             frame_id: @context[:turbo_frame]
+           )
+  end
+
+  def render_records_table_turbo_stream(records:, pagy:)
+    render Components::Databasium::Records::ShowTurboStream.new(
+             **@context,
+             records: records,
+             pagy: pagy
+           ),
+           layout: false
+  end
+
+  def render_records_table(records:, pagy:)
+    render Components::Databasium::Records::Table.new(
+             records: records,
+             model: @context[:model],
+             turbo_frame: @context[:turbo_frame],
+             pagy: pagy,
+             feedback: @context[:feedback]
+           )
+  end
+
+  def records_context
+    {
+      refresh: params[:refresh].presence || false,
+      filter: filter_params,
+      table: params[:table],
+      model: @model,
+      turbo_frame: params[:frame_id].presence || "records_list",
+      feedback: @feedback,
+      columns_names_types: @schema_service.get_columns(@model),
+      limit: params[:limit].presence || 10
+    }
+  end
+
+  def set_model_and_record_service
+    @model, @feedback = @schema_service.get_model_from_table(params[:table])
+    @record_service = Databasium::Record.new(model: @model)
+  end
+
+  def create_schema_service
+    @schema_service = Databasium::Schema.new
+  end
+
+  def foreign_records_frame?(frame_id)
+    frame_id.start_with?("foreign_records_") && !foreign_records_table_frame?(frame_id)
+  end
+
+  def foreign_records_table_frame?(frame_id)
+    frame_id.start_with?("foreign_records_table_")
+  end
+
+  def filter_params
+    return nil if @model.nil?
+    allowed_columns = @model&.columns.map { |c| c.name.to_s }
+
+    params.fetch(:filter, {}).permit(
+      allowed_columns.index_with { |_col| %i[operator value] },
+      operator_types: []
+    )
+  end
+
+  def model_columns_params
+    return if params[:table].nil?
+    params.require(:record).permit(*@schema_service.get_columns_names(params[:table]))
+  end
+end

data/app/controllers/databasium/schemas_controller.rb

@@ -0,0 +1,52 @@
+class Databasium::SchemasController < Databasium::ApplicationController
+  include Pagy::Method
+  before_action :create_schema_service, except: [ :sidebar ]
+
+  def index
+    layers = params[:layers].nil? ? nil : params[:layers].presence.try(:to_i) || 1
+    model = params[:model]
+    if params[:model].present?
+      schema = @schema_service.get_model_and_layers_BFS(model, layers)
+    else
+      schema = @schema_service.schema
+    end
+
+    models, pagy = get_models
+
+    respond_to do |format|
+      format.html do
+        render Views::Databasium::Schemas::Index.new(
+                 schema: schema,
+                 models: models,
+                 pagy: pagy,
+                 model: model,
+                 layers: layers
+               )
+      end
+      format.json { render json: @schema }
+    end
+  end
+
+  def sidebar
+    models, pagy = get_models
+
+    render Components::Databasium::SearchResults::SchemaModels.new(models: models, pagy: pagy)
+  end
+
+  def sync_schema
+    @schema_service.sync!
+    redirect_back fallback_location: schemas_path
+  end
+
+  private
+
+  def create_schema_service
+    @schema_service = Databasium::Schema.new
+  end
+
+  def get_models
+    raw_models = Databasium::Model.new.get_all_models_from_db(search: params[:search])
+    pagy, models = pagy(raw_models, limit: 7, root_key: "models")
+    [ models, pagy ]
+  end
+end

data/app/helpers/databasium/application_helper.rb

@@ -0,0 +1,4 @@
+module Databasium
+  module ApplicationHelper
+  end
+end

data/app/helpers/databasium/heroicon_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Databasium
+  module HeroiconHelper
+    def heroicon(name, variant: Heroicon.configuration.variant, options: {}, path_options: {})
+      svg =
+        Heroicon::Icon.render(
+          name: name,
+          variant: variant,
+          options: options,
+          path_options: path_options
+        ).to_s
+
+      if respond_to?(:safe)
+        raw safe(svg)
+      else
+        svg.html_safe
+      end
+    end
+  end
+end

data/app/helpers/databasium/models_helper.rb

@@ -0,0 +1,4 @@
+module Databasium
+  module ModelsHelper
+  end
+end

data/app/jobs/databasium/application_job.rb

@@ -0,0 +1,4 @@
+module Databasium
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/databasium/application_mailer.rb

@@ -0,0 +1,6 @@
+module Databasium
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/databasium/application_record.rb

@@ -0,0 +1,5 @@
+module Databasium
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/services/databasium/migration.rb

@@ -0,0 +1,176 @@
+class Databasium::Migration
+  attr_reader :migration_context, :migrations, :pending_migrations
+  MIGRATIONS_PATHS = [ "db/migrate" ]
+  MIGRATIONS_TEMPLATE_PATH =
+    Databasium::Engine.root.join("lib/databasium/templates/migration.rb.tt")
+  CREATE_TABLE_MIGRATIONS_TEMPLATE_PATH =
+    Databasium::Engine.root.join("lib/databasium/templates/create_table_migration.rb.tt")
+
+  def initialize
+    @migration_context = ActiveRecord::MigrationContext.new(MIGRATIONS_PATHS)
+    @migrations = @migration_context.migrations
+    @pending_migrations = @migration_context.pending_migration_versions
+  end
+
+  def get_migrations(search)
+    return @migrations unless search.present?
+    @migrations.select { |m| m.name =~ /#{Regexp.escape(search)}/i } if search
+  end
+
+  def find_migration!(version)
+    migration = migration_context.migrations.find { |m| m.version.to_s == version.to_s }
+    unless migration && File.file?(migration.filename)
+      raise ActiveRecord::RecordNotFound, "Migration #{version} not found"
+    end
+    migration
+  end
+
+  def run_pending_migrations
+    versions = migration_context.pending_migration_versions
+    begin
+      versions.each { |version| migration_context.run(:up, version) }
+    rescue => e
+      raise "There was an error running the pending migrations: #{e.message}"
+    end
+    versions
+  end
+
+  def rollback_migration(version, rollback_steps, till_this_migration)
+    begin
+      if rollback_steps.present?
+        migration_context.rollback(rollback_steps.to_i)
+      elsif till_this_migration == "true"
+        migration_context.down(version.to_i)
+      else
+        migration_context.run(:down, version.to_i)
+      end
+    rescue => e
+      raise "There was an error rolling back the #{version} migration: #{e.message}"
+    end
+  end
+
+  def run_migration(version)
+    begin
+      migration_context.run(:up, version.to_i)
+    rescue => e
+      raise "There was an error running the #{version} migration: #{e.message}"
+    end
+  end
+
+  def save_migration(params)
+    require "rails/generators/active_record/migration/migration_generator"
+    require "rails/generators"
+    Rails.application.load_generators
+    args = build_generator_args(params)
+    if params[:add_migration] == "Save" && params[:add_model] == "1"
+      generator = "model"
+    else
+      generator = "migration"
+    end
+    Rails::Generators.invoke(generator, args, behavior: :invoke, destination_root: Rails.root.to_s)
+    true
+  end
+
+  def generate_migration(params)
+    unless params[:table_name_from].present? || params[:table_name_to].present? ||
+             params[:table_name].present?
+      raise "Please provide a table name to generate a migration"
+    end
+
+    require "rails/generators/active_record/migration/migration_generator"
+    require "rails/generators"
+    Rails.application.load_generators
+    args = build_generator_args(params)
+    gen =
+      ActiveRecord::Generators::MigrationGenerator.new(
+        args,
+        {},
+        behavior: :invoke,
+        destination_root: Rails.root.to_s
+      )
+
+    gen.send(:set_local_assigns!)
+    gen.set_migration_assigns!(gen.file_name)
+
+    if params[:migration_action] == "create"
+      source = CREATE_TABLE_MIGRATIONS_TEMPLATE_PATH
+    else
+      source = MIGRATIONS_TEMPLATE_PATH
+    end
+    ERB.new(File.read(source), trim_mode: "-", eoutvar: "@output_buffer").result(
+      gen.instance_eval("binding")
+    )
+  end
+
+  private
+
+  def build_generator_args(params)
+    table_name_with_action = set_generator_base(params)
+
+    table_name_with_action +=
+      if params[:migration_action] != "create"
+        set_all_affected_columns(params)
+      else
+        params[:table_name]&.capitalize&.pluralize
+      end
+
+    table_name_with_action +=
+      if params[:migration_action] == "add"
+        "To#{params[:table_name_to]&.capitalize&.pluralize}"
+      elsif params[:migration_action] == "remove"
+        "From#{params[:table_name_from]&.capitalize&.pluralize}"
+      else
+        ""
+      end
+
+    generator_args = [ table_name_with_action ]
+
+    generator_args += set_contrains_on_columns(params)
+  end
+
+  def set_generator_base(params)
+    if params[:add_migration] != "Save" || params[:add_model] != "1"
+      params[:migration_action]&.capitalize
+    else
+      ""
+    end
+  end
+
+  def set_all_affected_columns(params)
+    return "" unless params[:columns].present?
+    if params[:columns].size > 4
+      "Columns"
+    else
+      params[:columns]
+        .filter { |c| c[:column_name].present? && c[:column_type].present? }
+        .map { |c| c[:column_name].capitalize }
+        .join("And")
+    end
+  end
+
+  def set_contrains_on_columns(params)
+    return nil unless params[:columns].present?
+    not_null_validation = build_not_null_validation(params)
+    uniqueness_validation = build_uniqueness_validation(params)
+
+    params[:columns]
+      .filter { |c| c[:column_name].present? && c[:column_type].present? }
+      .map do |c|
+        "#{c[:column_name]}:#{c[:column_type]}" +
+          (not_null_validation.include?(c[:column_name]) ? "!" : "") +
+          (uniqueness_validation.include?(c[:column_name]) ? ":uniq" : "")
+      end
+  end
+
+  def build_not_null_validation(params)
+    params[:validation]
+      .filter { |c| c[:column_name].present? && c[:type] == "not_null" }
+      .map { |c| c[:column_name] }
+  end
+
+  def build_uniqueness_validation(params)
+    params[:validation]
+      .filter { |c| c[:column_name].present? && c[:type] == "uniqueness" }
+      .map { |c| c[:column_name] }
+  end
+end

data/app/services/databasium/model.rb

@@ -0,0 +1,182 @@
+class Databasium::Model
+  attr_reader :model_name, :attributes, :relations
+  PATHS = [ "models" ].freeze
+  RELATIONS = %w[belongs_to has_many has_one has_and_belongs_to_many].freeze
+  RELATIONS_REGEX = /\A(#{Regexp.union(RELATIONS).source})/
+
+  def initialize
+  end
+
+  #  might be worth switching to reading from the dir directly in future
+  # def get_all_models_from_dir(search: nil)
+  #   model_files = []
+  #   PATHS.each { |path| model_files += Dir.glob(Rails.root.join("app", path, "**/*.rb")) }
+  #   model_names =
+  #     model_files
+  #       .map { |file| File.basename(file).sub(/\.rb$/, "").classify }
+  #       .reject do |name|
+  #         %w[ApplicationRecord Concerns].include?(name) || !name.safe_constantize&.table_exists?
+  #       end
+  #   model_names = model_names.select { |name| name =~ /#{search}/i } if search
+  #   model_names
+  # end
+
+  def get_all_models_from_db(search: nil)
+    conn = ActiveRecord::Base.connection
+    tables = conn.tables - %w[ar_internal_metadata schema_migrations]
+    tables = tables.map { |t| t.classify }
+    tables = tables.select { |t| t =~ /#{search}/i } if search
+    tables
+  end
+
+  def read_model_file(model_name)
+    File.read(model_file_path(model_name))
+  end
+
+  def get_model_data_from_file(model_name)
+    raw_model = constantize_model(model_name)
+    model = { validations: [], columns: [], unknown: [], relations: [], columns_hash: {} }
+    raw_model.columns.each do |column|
+      model[:columns_hash][column.name] = { type: column.type, validations: [] }
+    end
+
+    index = 0
+    inside_class = false
+    File.foreach(model_file_path(model_name)) do |line|
+      raw_line = line
+      line = line.strip.lstrip
+
+      parsed_line = {}
+
+      if line.start_with?("#")
+        parsed_line = parse_column(line)
+      elsif line.start_with?("validates :")
+        parsed_line = parse_validation(line)
+        scan_name = parsed_line[:content][:name]
+        model_column = model[:columns_hash].fetch(scan_name, nil)
+        if model_column.present?
+          model_column[:validations] << {
+            type: parsed_line[:content][:type],
+            value: parsed_line[:content][:value]
+          }
+        end
+      elsif line.match?(RELATIONS_REGEX)
+        parsed_line = parse_relation(line)
+      else
+        if !raw_line.include?("class")
+          parsed_line = { type: :unknown, content: {} }
+        else
+          inside_class = true
+        end
+      end
+
+      if parsed_line.present? && !(raw_line.blank? && !inside_class)
+        parsed_line[:content].merge!(
+          { index: index, line: parsed_line[:type] == :unknown ? raw_line : line }
+        )
+        model[parsed_line[:type]] << parsed_line[:content]
+      end
+      index += 1
+    end
+    model
+  end
+
+  def create_model_data(model_name:, attributes:, relations:, unknown:)
+    ModelData.new(
+      model_name: model_name,
+      attributes: attributes,
+      relations: relations,
+      unknown: unknown
+    )
+  end
+
+  private
+
+  class ModelData
+    attr_reader :model_name, :attributes, :relations, :unknown
+
+    def initialize(model_name:, attributes:, relations:, unknown: [])
+      @model_name = model_name
+      @attributes = attributes
+      @relations = relations
+      @unknown = unknown
+    end
+
+    def get_binding
+      binding
+    end
+
+    def longest_name_length
+      attributes.map { |a| (a[:name] || a["name"]).to_s.length }.max || 0
+    end
+
+    def relation_name(relation)
+      table_name = relation[:table_name].to_s
+
+      case relation[:type]
+      when "has_many", "has_and_belongs_to_many"
+        table_name.tableize
+      when "belongs_to", "has_one"
+        table_name.singularize.underscore
+      end
+    end
+
+    class Validation
+      attr_reader :name, :value
+      def initialize(name:, value:)
+        @name = name
+        @value = value
+      end
+    end
+
+    class Attribute
+      attr_reader :name, :type, :validations, :relations
+
+      def initialize(name:, type:, validations:)
+        @name = name
+        @type = type
+        @validations = validations
+      end
+    end
+  end
+
+  private
+
+  def model_file_path(model_name)
+    Rails.root.join("app/models/#{model_name.to_s.underscore.singularize}.rb")
+  end
+
+  def constantize_model(model_name)
+    model_name.to_s.safe_constantize || model_name.to_s.classify.safe_constantize
+  end
+
+  def parse_column(line)
+    scan =
+      line
+        .scan(/# (\w+)\s*:\s*(\w+)(.*)/)
+        .map { |match| { name: match[0], type: match[1], unknown: match[2] } }
+    parsed_line = { type: :columns, content: scan.first } if scan.any?
+    parsed_line = { type: :unknown, content: {} } if scan.empty?
+    parsed_line
+  end
+
+  def parse_validation(line)
+    scan =
+      line
+        .scan(/validates :(\w+), (\w+): (.*)/)
+        .map { |match| { name: match[0], type: match[1], value: match[2] } }
+    parsed_line = { type: :validations, content: scan.first } if scan.any?
+    parsed_line = { type: :unknown, content: {} } if scan.empty?
+    parsed_line
+  end
+
+  def parse_relation(line)
+    scan =
+      line
+        .scan(/(\w+) :(\w+)(.*)/)
+        .map { |match| { name: match[0], type: match[1], unknown: match[2] } }
+    parsed_line = { type: :unknown, content: {} } if scan.empty?
+    parsed_line = { type: :relations, content: scan.first } if scan.any?
+    parsed_line
+  end
+end

data/app/services/databasium/record.rb

@@ -0,0 +1,65 @@
+class Databasium::Record
+  def initialize(model: nil)
+    @model = model
+  end
+
+  def update(record, params)
+    return false unless record
+    record.update(params)
+  end
+
+  def create_new(attributes:)
+    return false unless @model
+    @model.create(attributes)
+  end
+
+  def update_by_id(id, attributes:)
+    return nil unless @model || id.blank?
+    record = @model.find(id)
+    return nil unless record
+
+    record.update(attributes)
+    record
+  end
+
+  def bulk_destroy(ids)
+    return nil if @model.blank? || ids.blank?
+    @model.where(id: ids).destroy_all
+  end
+
+  def filter_records(filter)
+    records = @model&.all
+    return records if filter.nil? || @model.nil?
+    connectors = Array(filter[:operator_types]).map(&:to_s)
+    allowed_operators = %w[eq not_eq gt lt gteq lteq matches does_not_match]
+    combined_predicate = nil
+    predicate_index = 0
+
+    filter
+      .except(:operator_types)
+      .each do |name, value|
+        next if value[:operator].blank? || value[:value].blank?
+
+        operator = value[:operator].to_s
+        next unless allowed_operators.include?(operator)
+
+        column = @model.arel_table[name]
+        predicate_value = value[:value].to_s
+        predicate_value = "%#{predicate_value}%" if %w[matches does_not_match].include?(operator)
+        current_predicate = column.public_send(operator, predicate_value)
+
+        if combined_predicate.nil?
+          combined_predicate = current_predicate
+        else
+          connector = connectors[predicate_index - 1] == "or" ? :or : :and
+          combined_predicate = combined_predicate.public_send(connector, current_predicate)
+        end
+
+        predicate_index += 1
+      end
+
+    return records if combined_predicate.nil?
+
+    records.where(combined_predicate)
+  end
+end