databasium 0.1.0

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

@@ -0,0 +1,31 @@
+module Components
+  module Databasium
+    class Models::ModelPreview < Components::Base
+      def initialize(content:)
+        @content = content
+      end
+
+      def view_template
+        div(id: "model_preview") do
+          div(class: "bg-panel border-1 border-border rounded-xl p-4 min-h-full flex-1") do
+            if @content
+              h1(class: "text-xl font-semibold mb-3 border-b-2 border-border pb-3") do
+                "Preview for Model"
+              end
+              pre(class: "bg-panel border-1 border-border rounded-xl p-4") { @content }
+              button(
+                type: "submit",
+                form: "model_form",
+                name: "commit",
+                value: "Create model file",
+                class: "bg-accent shadow-accent rounded-xl p-1 px-4 py-2 mt-2"
+              ) { "Create model file" }
+            else
+              h1(class: "text-xl font-semibold") { "Please fill out the form to see the preview" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class Models::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_models_path,
+                   turbo_frame: "results",
+                   placeholder: "Search for a model"
+                 )
+          turbo_frame_tag("results", src: databasium.sidebar_models_path) do
+            p(class: "mt-2 animate-pulse") { "Loading models..." }
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/models/templates/attribute.rb

@@ -0,0 +1,99 @@
+module Components
+  module Databasium
+    class Models::Templates::Attribute < Models::Templates::Base
+      def initialize(name: nil, params: nil)
+        @name = name
+        @params = params
+      end
+
+      def view_template
+        div(data: { controller: "attribute" }) { render_attribute_fields }
+      end
+
+      private
+
+      def render_attribute_fields
+        render_collapsable(
+          name: @name || "Attribute",
+          form: nil,
+          name_params: {
+            data: {
+              attribute_target: "name"
+            }
+          },
+          class_name: ""
+        ) do
+          div(class: "flex flex-col gap-2 bg-background p-3") do
+            div(class: "flex items-center gap-2") do
+              input(
+                type: "text",
+                name: "model[attributes][][name]",
+                value: @name,
+                data: {
+                  action: "input->attribute#updateName",
+                  attribute_target: "nameInput"
+                },
+                placeholder: "Attribute Name (e.g. email)",
+                class:
+                  "border-2 rounded-xl px-2 py-1 border-border w-full h-full bg-background focus:outline-none"
+              )
+              render Components::Databasium::TypeSelect.new(
+                       name: "model[attributes][][type]",
+                       value: @params&.fetch(:type, nil)
+                     )
+            end
+            attr_validations = @params&.fetch(:validations, nil)
+            render_validations(validations: attr_validations)
+            render_remove_button
+          end
+        end
+      end
+
+      def render_remove_button
+        button(
+          type: "button",
+          class: "text-red-500",
+          data: {
+            action: "click->attribute#remove"
+          }
+        ) { span { "Remove" } }
+      end
+
+      def render_validations(validations: nil)
+        render_collapsable(
+          name: "Validations",
+          form: nil,
+          data_targets: {
+            data: {
+              attribute_target: "validations"
+            }
+          },
+          class_name: "border-collapse border-1 border-border py-2 rounded-xl"
+        ) do
+          div(class: "flex items-center gap-2 py-1 px-3") do
+            span(class: "font-semibold") { "Add new Validation" }
+            button(
+              data: {
+                action: "click->model#add click->attribute#updateValidationName",
+                model_target_param: "validation",
+                model_container_param: "validationsContainer"
+              },
+              type: "button",
+              class: "text-blue-500"
+            ) { heroicon "plus-circle", variant: :outline, options: { class: "w-8 h-8" } }
+          end
+          div(
+            class: "flex flex-col gap-2 divide-y divide-border",
+            data: {
+              model_target: "validationsContainer"
+            }
+          ) do
+            validations&.each do |validation|
+              render Models::Templates::Validation.new(validation: validation, name: @name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/models/templates/base.rb

@@ -0,0 +1,6 @@
+module Components
+  module Databasium
+    class Models::Templates::Base < Components::Base
+    end
+  end
+end

data/app/components/databasium/models/templates/relation.rb

@@ -0,0 +1,56 @@
+# </template>
+
+module Components
+  module Databasium
+    class Models::Templates::Relation < Models::Templates::Base
+      def initialize(relation: nil, models: nil)
+        @relation = relation
+        @models = models
+      end
+
+      def view_template
+        selected_relation = @relation&.fetch(:name, nil)
+        selected_model = @relation&.fetch(:type, nil)&.classify
+        div(class: "flex gap-2") do
+          select(
+            name: "model[relations][][type]",
+            class: "border-2 rounded-xl p-1 border-border w-full bg-background focus:outline-none"
+          ) do
+            [
+              [ "belongs_to", "Belongs To" ],
+              [ "has_many", "Has Many" ],
+              [ "has_one", "Has One" ],
+              [ "has_and_belongs_to_many", "Has And Belongs To Many" ]
+            ].each do |value, label|
+              option(value: value, selected: selected_relation == value) { label }
+            end
+          end
+          input(
+            type: "search",
+            name: "model[relations][][table_name]",
+            placeholder: "Search or select model",
+            class: "border-2 rounded-xl p-1 border-border w-full bg-background focus:outline-none",
+            value: selected_model,
+            list: "models_datalist"
+          ) { }
+          button(
+            type: "button",
+            class: "text-red-500",
+            data: {
+              action: "click->relation#removeRelation"
+            }
+          ) { heroicon "x-mark", variant: :solid, options: { class: "w-8 h-8" } }
+        end
+        render_models_datalist
+      end
+
+      private
+
+      def render_models_datalist
+        datalist(id: "models_datalist") do
+          @models&.each { |model| option(value: model.classify) { model } }
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/models/templates/validation.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class Models::Templates::Validation < Models::Templates::Base
+      TYPES = {
+        presence: "Presence",
+        uniqueness: "Uniqueness",
+        inclusion: "Inclusion",
+        exclusion: "Exclusion",
+        validates_associated: "Validates Associated",
+        numericality: "Numericality",
+        length: "Length",
+        acceptance: "Acceptance",
+        absence: "Absence",
+        confirmation: "Confirmation",
+        comparison: "Comparison",
+        format: "Format"
+      }.freeze
+
+      def initialize(validation: nil, name: nil)
+        @validation = validation
+        @name = name
+        @selected_validation = @validation&.fetch(:type, nil)
+        @validation_value = @validation&.fetch(:value, nil)
+      end
+
+      def view_template
+        div(
+          class: "p-2",
+          data: {
+            controller: "validation",
+            validation_selected_type_value: @selected_validation
+          }
+        ) do
+          div(class: "flex gap-2") do
+            render_validation_name_input
+            div(class: "relative") do
+              render_validation_type_select
+              div(
+                class: "absolute -top-1.5 -right-[0.5rem]",
+                data: {
+                  action:
+                    "mouseenter->validation#showBasicInfo mouseleave->validation#hideBasicInfo"
+                }
+              ) do
+                heroicon "information-circle", variant: :solid, options: { class: "w-5 h-5" }
+                render_basic_info
+              end
+            end
+            render_acceptance_suggestions
+            render_length_suggestions
+            render_uniqueness_suggestions
+            render_absence_suggestions
+            render_confirmation_suggestions
+            render_comparison_suggestions
+            render_format_suggestions
+            render_inclusion_suggestions
+            render_exclusion_suggestions
+            render_numericality_suggestions
+            render_validates_associated_suggestions
+            render_presence_suggestions
+            render_validation_value_input
+            render_x_button(action: "click->validation#remove")
+          end
+        end
+      end
+
+      private
+
+      def render_basic_info
+        div(
+          data: {
+            validation_target: "basicInfo"
+          },
+          class:
+            "hidden absolute z-20 w-64 p-4 mt-2 text-sm text-text bg-background border border-border rounded-xl shadow-xl bottom-full left-1/2 -translate-x-1/2"
+        ) do
+          div(class: "relative") do
+            p(class: "font-semibold") { "Basic use case" }
+            p(class: "text-text", data: { validation_target: "basicInfoText" }) { "" }
+            div(
+              class:
+                "absolute -bottom-5.5 left-1/2 -translate-x-1/2 w-3 h-3 bg-background border-b border-r border-border rotate-45"
+            )
+          end
+        end
+      end
+
+      def render_validation_value_input
+        div(class: "flex gap-2 px-2 mt-1 relative w-full") do
+          input(
+            type: "search",
+            list: "acceptance-options",
+            name: "model[attributes][][validations][][value]",
+            class: "border-1 p-1 border-border w-full bg-background focus:outline-none",
+            placeholder: "Value (e.g. true)",
+            value: @validation_value,
+            data: {
+              validation_target: "valueInput"
+            }
+          )
+          div(class: "absolute -top-4 right-0 flex gap-1") do
+            render_add_additional_options_button(action: "allowNil", text: "Allow nil")
+            render_add_additional_options_button(action: "allowBlank", text: "Allow blank")
+            render_add_additional_options_button(action: "onAction", text: "On Action")
+          end
+        end
+      end
+
+      def render_validation_type_select
+        select(
+          name: "model[attributes][][validations][][type]",
+          class: "border-2 rounded-xl p-1 border-border w-fill bg-background focus:outline-none",
+          data: {
+            action: "change->validation#updateType"
+          }
+        ) do
+          TYPES.each do |value, label|
+            option(value: value.to_s, selected: @selected_validation == value.to_s) { label }
+          end
+        end
+      end
+
+      def render_validation_name_input
+        input(
+          type: "text",
+          name: "model[attributes][][validations][][name]",
+          value: @name,
+          data: {
+            attribute_target: "nameValidationInput"
+          },
+          class: "hidden"
+        )
+      end
+
+      def render_absence_suggestions
+        datalist(id: "absence-options") { render_base_boolean_values }
+      end
+
+      def render_acceptance_suggestions
+        datalist(id: "acceptance-options") do
+          render_base_boolean_values
+          option(value: '{ message: "must be agreed to" }') { "With message" }
+          option(value: '{ accept: "yes" }') { "Accept" }
+        end
+      end
+
+      def render_confirmation_suggestions
+        datalist(id: "confirmation-options") do
+          render_base_boolean_values
+          option(value: "{ case_sensitive: false }") { "Case insensitive" }
+        end
+      end
+
+      def render_comparison_suggestions
+        datalist(id: "comparison-options") do
+          option(value: "{ greater_than: 10 }") { "Greater than" }
+          option(value: "{ greater_than_or_equal_to: 10 }") { "Greater than or equal to" }
+          option(value: "{ equal_to: 10 }") { "Equal to" }
+          option(value: "{ less_than: 10 }") { "Less than" }
+          option(value: "{ less_than_or_equal_to: 10 }") { "Less than or equal to" }
+          option(value: "{ other_than: 10 }") { "Other than" }
+        end
+      end
+
+      def render_format_suggestions
+        datalist(id: "format-options") do
+          option(value: "{ with: /[A-Z]/ }") { "With" }
+          option(value: "{ without: /[A-Z]/ }") { "Without" }
+          option(value: "{ with: /[A-Z]/, message: 'must be uppercase' }") { "With and message" }
+          option(value: "{ without: /[A-Z]/, message: 'must be lowercase' }") do
+            "Without and message"
+          end
+        end
+      end
+
+      def render_inclusion_suggestions
+        datalist(id: "inclusion-options") do
+          option(value: "{ in: %w[a b c] }") { "Inclusion" }
+          option(value: "{ in: ->(i) { i.method } }") { "Inclusion with proc" }
+          option(value: "{ in: %w[a b c], message: 'must be a, b, or c' }") do
+            "Inclusion and message"
+          end
+        end
+      end
+
+      def render_exclusion_suggestions
+        datalist(id: "exclusion-options") do
+          option(value: "{ in: %w[a b c] }") { "Exclusion" }
+          option(value: "{ in: ->(i) { i.method } }") { "Exclusion with proc" }
+          option(value: "{ in: %w[a b c], message: 'must be a, b, or c' }") do
+            "Exclusion and message"
+          end
+        end
+      end
+
+      def render_length_suggestions
+        datalist(id: "length-options") do
+          option(value: "{ minimum: 2 }") { "Minimum" }
+          option(value: "{ maximum: 10 }") { "Maximum" }
+          option(value: "{ in: 2..10 }") { "Minimum and maximum" }
+          option(value: "{ is: 10 }") { "Exact length" }
+          option(value: "{ in: 2..10, too_short: 'is too short', too_long: 'is too long' }") do
+            "Minimum and maximum with messages"
+          end
+          option(value: "{ in: 2..10, wrong_length: 'is the wrong length' }") do
+            "Minimum and maximum with generic message"
+          end
+        end
+      end
+
+      def render_numericality_suggestions
+        datalist(id: "numericality-options") do
+          render_base_boolean_values
+          option(value: "{ only_integer: true }") { "Only integer" }
+          option(value: "{ greater_than: 10 }") { "Greater than" }
+          option(value: "{ greater_than_or_equal_to: 10 }") { "Greater than or equal to" }
+          option(value: "{ equal_to: 10 }") { "Equal to" }
+          option(value: "{ less_than: 10 }") { "Less than" }
+          option(value: "{ less_than_or_equal_to: 10 }") { "Less than or equal to" }
+          option(value: "{ other_than: 10 }") { "Other than" }
+          option(value: "{ in: 1..10 }") { "In range" }
+          option(value: "{ odd: true }") { "Odd" }
+          option(value: "{ even: true }") { "Even" }
+        end
+      end
+
+      def render_presence_suggestions
+        datalist(id: "presence-options") { render_base_boolean_values }
+      end
+
+      def render_uniqueness_suggestions
+        datalist(id: "uniqueness-options") do
+          render_base_boolean_values
+          option(value: "{ scope: :column_name }") { "Scope" }
+          option(value: "{ scope: :column_name, message: 'must be unique' }") do
+            "Scope and with message"
+          end
+          option(value: "{ case_sensitive: false }") { "Case insensitive" }
+          option(value: '{ conditions: -> { where(column: "value") } }') { "Conditions" }
+        end
+      end
+
+      def render_validates_associated_suggestions
+        datalist(id: "validates_associated-options") do
+          option(value: ":model_name") { "Validates associated" }
+        end
+      end
+
+      def render_base_boolean_values
+        option(value: "true") { "If you woud like to true" }
+        option(value: "false") { "False" }
+      end
+
+      def render_add_additional_options_button(action: nil, text: nil)
+        button(
+          type: "button",
+          class:
+            "text-text text-xs p-0.5 px-2 border-1 border-border rounded-xl bg-panel hover:bg-panel-hover cursor-pointer",
+          data: {
+            action: "validation##{action}"
+          }
+        ) { text }
+      end
+
+      def render_string_value_suggestions
+        datalist(id: "string-options") do
+          option(value: "true") { "If you woud like to true" }
+          option(value: "false") { "False" }
+        end
+      end
+
+      def render_button_suggestion(value: nil, type: nil)
+        button(
+          type: "button",
+          class: "text-text",
+          data: {
+            validation_target: "#{value}#{type&.upcase}"
+          }
+        ) { value }
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/base_icon.rb

@@ -0,0 +1,32 @@
+module Components
+  module Databasium
+    class Navigation::BaseIcon < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+      include ::Databasium::HeroiconHelper
+
+      attr_reader :element
+
+      def initialize(element:)
+        @element = element
+      end
+
+      protected
+
+      def icon_classes
+        class_names(
+          "flex justify-between items-center gap-2
+          border-1 border-border p-1 px-3 rounded-xl cursor-pointer hover:border-hover",
+          "bg-accent shadow-accent" => element[:active]
+        )
+      end
+
+      def render_icon(icon)
+        heroicon icon, variant: :outline, options: { class: "w-6 h-6" }
+      end
+
+      def render_text(text)
+        p(class: "text-main-text text-base text-nowrap") { text }
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/frontend_icon.rb

@@ -0,0 +1,17 @@
+module Components
+  module Databasium
+    class Navigation::FrontendIcon < Navigation::BaseIcon
+      def initialize(element:, data_params: {})
+        super(element: element)
+        @data_params = data_params
+      end
+
+      def view_template
+        div(class: icon_classes, data: @data_params) do
+          render_icon(element[:icon])
+          render_text(element[:text])
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/get_icon.rb

@@ -0,0 +1,26 @@
+module Components
+  module Databasium
+    class Navigation::GetIcon < Navigation::BaseIcon
+      include Phlex::Rails::Helpers::LinkTo
+
+      def initialize(element:, turbo_frame: nil)
+        super(element: element)
+        @turbo_frame = turbo_frame
+      end
+
+      def view_template
+        link_to(
+          element[:path],
+          class: icon_classes,
+          data: {
+            turbo_method: :get,
+            turbo_stream: true
+          }
+        ) do
+          render_icon(element[:icon])
+          render_text(element[:text])
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/icon.rb

@@ -0,0 +1,28 @@
+module Components
+  module Databasium
+    class Navigation::Icon < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+
+      attr_reader :element
+
+      def initialize(element:)
+        @element = element
+      end
+
+      def view_template
+        case element[:method]
+        when :frontend
+          render Navigation::FrontendIcon.new(element: element, data_params: element[:data_params])
+        when :get
+          render Navigation::GetIcon.new(element: element, turbo_frame: element[:turbo_frame])
+        when :post
+          render Navigation::PostIcon.new(element: element)
+        when :put
+          render Navigation::PutIcon.new(element: element)
+        else
+          p { "Please provide method to icon component" }
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/icon_panel.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Components
+  module Databasium
+    class Navigation::IconPanel < Components::Base
+      include Phlex::Rails::Helpers::LinkTo
+
+      # element format: { icon: "icon-name", text: "text", path: "path", method: :get | :post | frontend, turbo_frame: "frame_id" }
+      def initialize(icons_with_text: [])
+        @icons_with_text = icons_with_text
+      end
+
+      def view_template(&block)
+        form(&block)
+      end
+
+      private
+
+      def form(&block)
+        div(class: "align-items-center justify-items-center flex gap-2") do
+          @icons_with_text.each { |element| render Navigation::Icon.new(element: element) }
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/post_icon.rb

@@ -0,0 +1,25 @@
+module Components
+  module Databasium
+    class Navigation::PostIcon < Navigation::BaseIcon
+      include Phlex::Rails::Helpers::LinkTo
+
+      def initialize(element:)
+        super(element: element)
+      end
+
+      def view_template
+        link_to(
+          element[:path],
+          class: icon_classes,
+          data: {
+            turbo_method: :post,
+            turbo_frame: "_top"
+          }
+        ) do
+          render_icon(element[:icon])
+          render_text(element[:text])
+        end
+      end
+    end
+  end
+end

data/app/components/databasium/navigation/put_icon.rb

@@ -0,0 +1,18 @@
+module Components
+  module Databasium
+    class Navigation::PutIcon < Navigation::BaseIcon
+      include Phlex::Rails::Helpers::LinkTo
+
+      def initialize(element:)
+        super(element: element)
+      end
+
+      def view_template
+        link_to(element[:path], class: icon_classes, data: { turbo_method: :put }) do
+          render_icon(element[:icon])
+          render_text(element[:text])
+        end
+      end
+    end
+  end
+end