databasium 0.1.0

data/app/components/databasium/records/utilities.rb

@@ -0,0 +1,25 @@
+module Components
+  module Databasium
+    class Records::Utilities < Components::Base
+      def initialize(model:, columns_names_types:)
+        @model = model
+        @columns_names_types = columns_names_types
+      end
+
+      def view_template
+        div(id: "records_utilities") do
+          render Components::Databasium::Records::Filter.new(
+                   model: @model,
+                   turbo_frame: "records",
+                   columns_names_types: @columns_names_types,
+                   hidden: true
+                 )
+          render Components::Databasium::Forms::Model.new(
+                   columns_names_types: @columns_names_types,
+                   model: @model
+                 )
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/schemas/header_actions.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class Schemas::HeaderActions < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include Phlex::Rails::Helpers::FormWith
+      include Phlex::Rails::Helpers::HiddenFieldTag
+      attr_reader :model, :layers
+
+      def initialize(model:, layers:)
+        @model = model
+        @layers = layers
+      end
+
+      def view_template
+        div(id: "header_actions", class: "flex max-w-full gap-2 overflow-x-auto") do
+          unless model
+            render Components::Databasium::Navigation::IconPanel.new(
+                     icons_with_text: [
+                       {
+                         icon: "arrow-path-rounded-square",
+                         text: "Sync Schema",
+                         method: :put,
+                         path: databasium.sync_schema_schemas_path
+                       }
+                     ]
+                   )
+          end
+          if model
+            render Components::Databasium::Navigation::IconPanel.new(
+                     icons_with_text: [
+                       {
+                         icon: "arrow-path-rounded-square",
+                         text: "Sync Schema",
+                         method: :put,
+                         path: databasium.sync_schema_schemas_path
+                       },
+                       {
+                         icon: "table-cells",
+                         text: "Model Schema",
+                         method: :get,
+                         turbo_frame: "records",
+                         path: model_layers_path(model, 0),
+                         active: layers == 0
+                       },
+                       {
+                         icon: "share",
+                         text: "Model Associations",
+                         method: :get,
+                         turbo_frame: "records",
+                         path: model_layers_path(model, 1),
+                         active: layers == 1
+                       },
+                       {
+                         icon: "square-2-stack",
+                         text: "Nested associations",
+                         method: :get,
+                         turbo_frame: "records",
+                         path: model_layers_path(model, 2),
+                         active: layers == 2
+                       },
+                       {
+                         icon: "squares-2x2",
+                         text: "All associations",
+                         method: :get,
+                         turbo_frame: "records",
+                         path: model_layers_path(model, nil),
+                         active: layers == nil
+                       }
+                     ]
+                   )
+          end
+          if model
+            form_with(
+              method: :get,
+              url: model_layers_path(model, layers),
+              class: "border-l border-border pl-2 inline-flex gap-2 items-center"
+            ) do |form|
+              hidden_field_tag :model, model
+              form.number_field :layers,
+                                value: layers,
+                                class:
+                                  "w-10 border-1 border-border rounded-xl p-1 text-center text-sm"
+              form.submit "Search for associations",
+                          class: "text-sm bg-accent shadow-accent rounded-xl p-1.5 text-center"
+            end
+          end
+        end
+      end
+
+      private
+
+      def model_layers_path(model, layers)
+        databasium.schemas_path(model: model, layers: layers)
+      end
+    end
+  end
+end

data/app/components/databasium/schemas/sidebar.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class Schemas::Sidebar < Components::Base
+      include Phlex::Rails::Helpers::TurboFrameTag
+
+      def initialize
+      end
+
+      def view_template
+        div(class: "flex flex-col gap-2", data: { controller: "search" }) do
+          render Components::Databasium::Forms::Search.new(
+                   url: databasium.sidebar_schemas_path,
+                   turbo_frame: "results",
+                   placeholder: "Search for a model"
+                 )
+          turbo_frame_tag("results", src: databasium.sidebar_schemas_path) do
+            p(class: "mt-2 animate-pulse") { "Loading models..." }
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/search_results/migrations.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class SearchResults::Migrations < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include Phlex::Rails::Helpers::TurboFrameTag
+
+      def initialize(migrations:, pending_migrations:, pagy:)
+        @migrations = migrations
+        @pending_migrations = pending_migrations
+        @pagy = pagy
+      end
+
+      def view_template
+        turbo_frame_tag("results") do
+          @migrations.each do |m|
+            status = @pending_migrations.include?(m.version) ? "pending" : "applied"
+            link_to(
+              databasium.migration_path(m.version),
+              data: {
+                turbo_stream: true
+              },
+              class:
+                "text-main-text hover:text-hover hover:cursor-pointer flex items-center gap-2 p-1 border-b
+                  border-border flex items-center justify-between"
+            ) do
+              p(class: "max-w-fit overflow-x-auto me-2 scrollbar-thin p-1") { "#{m.name}" }
+              render Migrations::MigrationStatus.new(status: status, version: m.version)
+            end
+          end
+          div(class: "mt-4 flex justify-start") { raw @pagy.series_nav.html_safe } if @pagy
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/search_results/models.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class SearchResults::Models < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include Phlex::Rails::Helpers::TurboFrameTag
+
+      def initialize(models:, pagy:)
+        @models = models
+        @pagy = pagy
+      end
+
+      def view_template
+        turbo_frame_tag("results") do
+          @models&.each do |model|
+            link_to(
+              databasium.model_path(model),
+              data: {
+                turbo_frame: "main"
+              },
+              class:
+                "text-main-text hover:text-hover hover:cursor-pointer flex items-center gap-2 p-1 border-b
+                  border-border flex items-center justify-between"
+            ) do
+              p(class: "max-w-fit overflow-x-auto me-2 scrollbar-thin p-1") do
+                "#{model.upcase_first}"
+              end
+            end
+          end
+          div(class: "mt-4 flex justify-start") { raw @pagy.series_nav.html_safe } if @pagy
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/search_results/schema_models.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class SearchResults::SchemaModels < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include Phlex::Rails::Helpers::TurboFrameTag
+
+      def initialize(models:, pagy:)
+        @models = models
+        @pagy = pagy
+      end
+
+      def view_template
+        turbo_frame_tag("results") do
+          @models&.each do |model|
+            link_to(
+              databasium.schemas_path(model: model.upcase_first, layers: 0),
+              data: {
+                turbo_frame: "main"
+              },
+              class:
+                "text-main-text hover:text-hover hover:cursor-pointer flex items-center gap-2 p-1 border-b
+                  border-border justify-between"
+            ) do
+              p(class: "max-w-fit overflow-x-auto me-2 scrollbar-thin p-1") do
+                "#{model.upcase_first}"
+              end
+            end
+          end
+          p(class: "text-main-text text-center p-4") { "No models found" } if @models.empty?
+          div(class: "mt-4 flex justify-start") { raw @pagy.series_nav.html_safe } if @pagy
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/search_results/tables.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class SearchResults::Tables < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include Phlex::Rails::Helpers::TurboFrameTag
+
+      def initialize(tables:, pagy:)
+        @tables = tables
+        @pagy = pagy
+      end
+
+      def view_template
+        turbo_frame_tag("results") do
+          @tables&.each do |table|
+            div(class: "border-b-2 border-b-border py-2 px-3") do
+              link_to "#{table}",
+                      databasium.records_records_path(table: table, refresh: true),
+                      data: {
+                        turbo_frame: "_top",
+                        turbo_stream: true
+                      }
+            end
+          end
+          div(class: "mt-4 flex justify-start") { raw @pagy.series_nav.html_safe } if @pagy
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/type_select.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class TypeSelect < Components::Base
+      def initialize(name: nil, value: nil)
+        @name = name
+        @value = value
+      end
+
+      def view_template
+        select(
+          name: @name,
+          class:
+            "border-2 rounded-xl px-2 py-1 border-border h-full bg-background focus:outline-none"
+        ) do
+          [
+            %w[text Text],
+            %w[string String],
+            %w[integer Integer],
+            %w[float Float],
+            %w[decimal Decimal],
+            %w[time Time],
+            %w[date Date],
+            %w[datetime Datetime],
+            %w[timestamp Timestamp],
+            %w[binary Binary],
+            %w[boolean Boolean],
+            %w[references Reference]
+          ].each { |value, label| option(value: value, selected: @value == value) { label } }
+        end
+      end
+    end
+  end
+end

data/app/controllers/databasium/application_controller.rb

@@ -0,0 +1,68 @@
+module Databasium
+  class ApplicationController < ActionController::Base
+    helper ::Databasium::HeroiconHelper
+
+    layout -> { Views::Layouts::Databasium::Application.new }
+    before_action :check_development_environment
+
+    rescue_from Exception, with: :render_error_flash if Rails.env.development?
+
+    private
+
+    def check_development_environment
+      render Views::Databasium::Errors::NonDevelopment.new if Rails.env.production?
+    end
+
+    def render_error_flash(error)
+      Rails.logger.error("[Databasium] #{error.class}: #{error.message}")
+      Rails.logger.error(error.backtrace.join("\n")) if error.backtrace
+
+      return if performed?
+
+      message, details = error_message_parts(error)
+
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: [
+                   turbo_stream.replace(
+                     "flash",
+                     Components::Databasium::Global::Flash.new(
+                       success: flash[:success],
+                       error: flash[:error]
+                     )
+                   ),
+                   turbo_stream.replace(
+                     "error",
+                     Components::Databasium::Global::Error.new(
+                       message: message,
+                       details: details,
+                       type: error.class.name
+                     )
+                   )
+                 ],
+                 status: :internal_server_error
+        end
+        format.any do
+          render Components::Databasium::Global::Error.new(
+                   message: message,
+                   details: details,
+                   type: error.class.name
+                 ),
+                 status: :internal_server_error
+        end
+      end
+    end
+
+    def error_message_parts(error)
+      lines = strip_ansi(error.message.to_s).lines.map(&:chomp)
+      message = lines.shift.presence || "Something went wrong"
+      details = lines.join("\n")
+
+      [ message, details.presence || strip_ansi(error.backtrace&.join("\n").to_s).presence ]
+    end
+
+    def strip_ansi(text)
+      text.gsub(/\e\[[0-9;]*m/, "")
+    end
+  end
+end

data/app/controllers/databasium/homepage_controller.rb

@@ -0,0 +1,5 @@
+class Databasium::HomepageController < Databasium::ApplicationController
+  def index
+    render Views::Databasium::Homepage::Index.new
+  end
+end

data/app/controllers/databasium/migrations_controller.rb

@@ -0,0 +1,186 @@
+class Databasium::MigrationsController < Databasium::ApplicationController
+  before_action :set_migration_service, except: [ :index ]
+  after_action -> { Databasium::Schema.new.sync! },
+               only: %i[run_migration rollback_migration run_pending_migrations]
+  include Pagy::Method
+
+  def index
+    render Views::Databasium::Migrations::Index.new
+  end
+
+  def show
+    @migration = @migration_service.find_migration!(params[:id])
+    @content = File.read(@migration.filename)
+
+    respond_to do |format|
+      format.html do
+        render Components::Databasium::Migrations::File.new(
+                 migration: @migration,
+                 content: @content
+               )
+      end
+      format.turbo_stream do
+        render Components::Databasium::Migrations::ShowTurboStream.new(
+                 migration: @migration,
+                 content: @content
+               ),
+               layout: false
+      end
+    end
+  end
+
+  def new
+    @tables = Databasium::Schema.new.tables
+    render Views::Databasium::Migrations::New.new(tables: @tables)
+  end
+
+  def create
+    require "rails/generators"
+    Rails.application.load_generators
+    require "rails/generators/active_record/migration/migration_generator"
+
+    if params[:add_migration] == "Save"
+      success = @migration_service.save_migration(migration_params)
+    else
+      content = @migration_service.generate_migration(migration_params)
+    end
+
+    if success
+      flash[:success] = "Migration for table #{migration_params[:table_name]} saved successfully."
+      redirect_to migrations_path, status: :see_other
+    elsif content
+      render turbo_stream:
+               turbo_stream.replace(
+                 "migration_preview",
+                 Components::Databasium::Migrations::Preview.new(content: content)
+               )
+    else
+      head :unprocessable_entity
+    end
+  end
+
+  def sidebar
+    pagy, migrations =
+      pagy(@migration_service.get_migrations(params[:search]), limit: 5, root_key: "migrations")
+    pending_migrations = @migration_service.pending_migrations
+
+    render Components::Databasium::SearchResults::Migrations.new(
+             migrations: migrations,
+             pending_migrations: pending_migrations,
+             pagy: pagy
+           )
+  end
+
+  def run_pending_migrations
+    versions = @migration_service.run_pending_migrations
+    message =
+      if versions.any?
+        "Pending migrations(#{versions.count}) run successfully"
+      else
+        "No pending migrations to run"
+      end
+
+    respond_to do |format|
+      format.html { redirect_to migrations_path, notice: message }
+      format.turbo_stream do
+        streams = [
+          turbo_stream.replace("error", Components::Databasium::Global::Error.new),
+          turbo_stream.replace(
+            "flash",
+            Components::Databasium::Global::Flash.new(success: message, error: nil)
+          )
+        ]
+
+        streams +=
+          versions.map do |version|
+            turbo_stream.replace(
+              "migration_#{version}_status",
+              Components::Databasium::Migrations::MigrationStatus.new(
+                status: "applied",
+                version: version
+              )
+            )
+          end
+
+        render turbo_stream: streams
+      end
+    end
+  end
+
+  def rollback_migration
+    version = rollback_migration_params[:version]
+    success =
+      @migration_service.rollback_migration(
+        version,
+        rollback_migration_params[:rollback_steps],
+        rollback_migration_params[:till_this_migration]
+      )
+    message = "Migration rolled back successfully"
+    if rollback_migration_params[:till_this_migration] == "true" ||
+         rollback_migration_params[:rollback_steps].present?
+      set_action_flash(message, nil)
+      redirect_to migrations_path(version: version)
+    else
+      response_to_action(message, nil, version, success ? "pending" : nil)
+    end
+  end
+
+  def run_migration
+    version = run_migration_params[:version]
+    @migration_service.run_migration(version)
+    response_to_action("Migration run successfully", nil, version, "applied")
+  end
+
+  private
+
+  def set_migration_service
+    @migration_service = Databasium::Migration.new
+  end
+
+  def migration_params
+    params.permit(
+      :add_migration,
+      :migration_action,
+      :table_name,
+      :table_name_from,
+      :table_name_to,
+      :add_model,
+      columns: %i[column_name column_type],
+      validation: %i[column_name type]
+    )
+  end
+
+  def run_migration_params
+    params.permit(:version)
+  end
+
+  def rollback_migration_params
+    params.permit(:version, :till_this_migration, :rollback_steps)
+  end
+
+  def new_action_response(success, error, migration_version, status)
+    Components::Databasium::Migrations::Action.new(
+      success: success,
+      error: error,
+      migration_version: migration_version,
+      status: status
+    )
+  end
+
+  def response_to_action(success, error, migration_version, status)
+    respond_to do |format|
+      format.turbo_stream do
+        render new_action_response(success, error, migration_version, status), layout: false
+      end
+      format.html do
+        set_action_flash(success, error)
+        redirect_to migrations_path(version: migration_version)
+      end
+    end
+  end
+
+  def set_action_flash(success, error)
+    flash[:success] = success if success.present?
+    flash[:error] = error if error.present?
+  end
+end

data/app/controllers/databasium/models_controller.rb

@@ -0,0 +1,105 @@
+class Databasium::ModelsController < Databasium::ApplicationController
+  include Pagy::Method
+  before_action :create_model_service
+  MODEL_TEMPLATE_PATH = Databasium::Engine.root.join("lib/databasium/templates/model.rb.tt")
+
+  def new
+    models = @model_service.get_all_models_from_db(search: params[:search])
+
+    render Views::Databasium::Models::New.new(content: nil, models: models)
+  end
+
+  def show
+    model = params[:id]
+    content = @model_service.read_model_file(model)
+    attributes = @model_service.get_model_data_from_file(model)
+    models = @model_service.get_all_models_from_db(search: params[:search])
+
+    respond_to do |format|
+      format.html do
+        render Views::Databasium::Models::New.new(
+                 content: content,
+                 model: model,
+                 attributes: attributes,
+                 models: models
+               )
+      end
+      format.turbo_stream do
+        render turbo_stream:
+                 turbo_stream.replace(
+                   "model_preview",
+                   Components::Databasium::Models::ModelPreview.new(content: content)
+                 )
+      end
+    end
+  end
+
+  def sidebar
+    models = @model_service.get_all_models_from_db(search: params[:search])
+    pagy, models = pagy(models, limit: 7, root_key: "models")
+
+    render Components::Databasium::SearchResults::Models.new(models: models, pagy: pagy)
+  end
+
+  def create
+    content = generate_model_content
+    if params[:commit] == "Create model file"
+      if write_file(content)
+        render turbo_stream:
+                 turbo_stream.replace(
+                   "flash",
+                   Components::Databasium::Global::Flash.new(
+                     success:
+                       "Model file created successfully, be sure to create a migration for this model if you haven't already"
+                   )
+                 )
+      end
+    else
+      respond_to do |format|
+        format.html
+        format.turbo_stream do
+          render turbo_stream:
+                   turbo_stream.replace(
+                     "model_preview",
+                     Components::Databasium::Models::ModelPreview.new(content: content)
+                   )
+        end
+      end
+    end
+  end
+
+  private
+
+  def create_model_service
+    @model_service = Databasium::Model.new
+  end
+
+  def generate_model_content
+    renderer = ERB.new(File.read(MODEL_TEMPLATE_PATH), trim_mode: "-")
+
+    context =
+      @model_service.create_model_data(
+        model_name: model_params[:model_name],
+        attributes: model_params[:attributes],
+        relations: model_params[:relations],
+        unknown: model_params[:unknown]
+      )
+
+    renderer.result(context.get_binding)
+  end
+
+  def write_file(content)
+    model_name = model_params[:model_name].underscore
+    destination_path = Rails.root.join("app/models/#{model_name}.rb")
+    File.open(destination_path, "w") { |file| file.write(content) }
+  end
+
+  def model_params
+    params.require(:model).permit(
+      :model_name,
+      attributes: [ :name, :type, validations: %i[name type value] ],
+      relations: %i[type table_name],
+      unknown: []
+    )
+  end
+end