oversee 0.1.1 → 0.3.0

data/app/components/oversee/resources/table.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class Oversee::Resources::Table < Oversee::Base
+  include Phlex::Rails::Helpers::TurboFrameTag
+
+  def initialize(resources:, resource_class:, params:, **options)
+    @resources = resources
+    @resource_class = resource_class || resources.first.class
+    @params = params
+    @options = options
+
+    @oversee_resource = Oversee::Resource.new(resource_class: @resource_class)
+  end
+
+  def view_template
+    turbo_frame_tag dom_id(@resource_class, :table), target: "_top" do
+      render Oversee::Table.new do |table|
+        table.head do |head|
+          head.row do
+            th(scope: "col", class: "px-4 py-3 text-left text-xs text-gray-900 uppercase")
+            # Attributes
+            @resource_class.columns_hash.each do |key, metadata|
+              next if @oversee_resource.foreign_keys.include?(key.to_s)
+              th(scope: "col", class: "text-left text-xs text-gray-900 uppercase whitespace-nowrap hover:bg-gray-50 transition relative") do
+                a(
+                  href:
+                    (
+                      helpers.resources_path(
+                        resource: @params[:resource],
+                        sort_attribute: key,
+                        sort_direction:
+                          @params[:sort_direction] == "asc" ? :desc : :asc
+                      )
+                    ),
+                  target: "_top",
+                  class: "px-4 py-3 flex items-center justify-between gap-2 w-full h-full hover:text-gray-900 transition-colors"
+                ) do
+                  render Oversee::Field::Label.new(key: key, datatype: metadata.sql_type_metadata.type)
+                  render Phlex::Icons::Iconoir::ArrowSeparateVertical.new(class: "size-3 text-gray-500", stroke_width: 2.5)
+                end
+              end
+            end
+
+            # Associations
+            resource_associations.each do |association|
+              th(scope: "col", class: "text-left text-xs text-gray-900 uppercase whitespace-nowrap hover:bg-gray-50 transition relative") do
+                span(
+                  class: "px-4 py-3 flex items-center justify-between gap-2 w-full h-full hover:text-gray-900 transition-colors"
+                ) do
+                  render Oversee::Field::Label.new(key: association.name, datatype: nil)
+                end
+              end
+            end
+          end
+        end
+
+        table.body do |body|
+          @resources.each do |resource|
+
+            body.row do |row|
+              td do
+                div(class: "flex space-x-2 mx-4") do
+                  a(
+                    href:
+                      (
+                        helpers.resource_path(
+                          resource.id,
+                          resource_class_name: @params[:resource_class_name]
+                        )
+                      ),
+                    data: { turbo_stream: true },
+                    class: "size-6 bg-gray-100 inline-flex items-center justify-center hover:bg-gray-200 group"
+                  ) { render Phlex::Icons::Iconoir::Eye.new(class: "size-4 text-gray-500") }
+                end
+              end
+
+              @resource_class.columns_hash.each do |key, metadata|
+                next if @oversee_resource.foreign_keys.include?(key.to_s)
+                row.data do
+                  div(class: "max-w-96") do
+                    render Oversee::Field::Value.new(datatype: metadata.sql_type_metadata.type, value: resource.send(key), key: key)
+                  end
+                end
+              end
+
+              resource_associations.each do |association|
+                foreign_id = resource.send(association.foreign_key)
+                resource_class_name = association.class_name
+
+                path = !!foreign_id ? helpers.resource_path(id: foreign_id, resource_class_name:) : helpers.resources_path(resource_class_name: resource_class_name)
+
+                row.data do
+                  div(class: "max-w-96") do
+                    a(
+                      href: path,
+                      class:"px-2 py-1 bg-gray-100 text-gray-500 text-sm flex items-center justify-between gap-2 hover:bg-gray-200 hover:text-gray-900 min-w-20") do
+                      span { foreign_id.presence || "N/A" }
+                      render Phlex::Icons::Iconoir::ArrowRight.new(class: "size-3")
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def resource_associations
+    @resource_class.reflect_on_all_associations.select { |association| association.macro == :belongs_to }
+  end
+end

data/app/components/oversee/table/body.rb

@@ -0,0 +1,13 @@
+class Oversee::Table::Body < Phlex::HTML
+  def view_template(&)
+    tbody(class: "divide-y divide-gray-200", &)
+  end
+
+  def row(&)
+    render Oversee::Table::Row.new(&)
+  end
+
+  def data(&)
+    render Oversee::Table::Data.new(&)
+  end
+end

data/app/components/oversee/table/data.rb

@@ -0,0 +1,5 @@
+class Oversee::Table::Data < Phlex::HTML
+  def view_template(&)
+    td(class: "whitespace-nowrap p-4 text-sm text-gray-500", &)
+  end
+end

data/app/components/oversee/table/head.rb

@@ -0,0 +1,9 @@
+class Oversee::Table::Head < Phlex::HTML
+  def view_template(&)
+    thead(class: "bg-white", &)
+  end
+
+  def row(&)
+    render Oversee::Table::Row.new(&)
+  end
+end

data/app/components/oversee/table/row.rb

@@ -0,0 +1,9 @@
+class Oversee::Table::Row < Phlex::HTML
+  def view_template(&)
+    tr(class: "divide-x divide-gray-200") { yield }
+  end
+
+  def data(&)
+    render Oversee::Table::Data.new(&)
+  end
+end

data/app/components/oversee/table.rb

@@ -0,0 +1,21 @@
+class Oversee::Table < Phlex::HTML
+  def view_template(&)
+    div(class: "overflow-x-hidden") do
+      div(class: "-mx-4 overflow-x-auto sm:-mx-6 lg:-mx-8") do
+        div(class: "inline-block min-w-full align-middle sm:px-6 lg:px-8") do
+          table(class: "min-w-full divide-y divide-gray-200") do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  def head(&)
+    render Oversee::Table::Head.new(&)
+  end
+
+  def body(&)
+    render Oversee::Table::Body.new(&)
+  end
+end

data/app/controllers/oversee/dashboard_controller.rb

@@ -1,5 +1,9 @@
 module Oversee
   class DashboardController < BaseController
+    def index
+      render Oversee::Dashboard::Index.new, layout: false
+    end
+
     def show
       fetch_metrics
 

data/app/controllers/oversee/resources/fields_controller.rb

@@ -1,44 +1,28 @@
-module Oversee
-  module Resources
-    class FieldsController < BaseController
-      before_action :set_resource_class
+class Oversee::Resources::FieldsController < Oversee::ResourcesController
+  # Renders the display field for a resource
+  def show
+  end
 
-      def update
-        @resource_class = params[:resource_class].constantize
-        @resource = @resource_class.find(params[:id])
-        # @datatype = @resource_class.columns_hash[@key.to_s].type
+  # Renders the input field for a resource
+  def input
+    set_resource
 
-        respond_to do |format|
-          if @resource.update(resource_params)
-            format.html { redirect_to resource_path(@resource, resource: @resource_class) }
-            format.turbo_stream
-          else
-          end
-        end
-      end
-      
-      # Non-standard actions
-      def edit
-        @resource = @resource_class.find(params[:id])
-        @key = params[:key].to_sym
-        @value = @resource.send(@key)
-        @datatype = @resource.class.columns_hash[@key.to_s].type
-        puts "---"
-        puts "key: #{@key}"
-        puts "value: #{@value}"
-        puts "datatype: #{@datatype}"
-        puts "---"
+    key = params[:key].to_sym
+    value = params[:value] || @resource.send(key)
+    datatype = params[:datatype] || @resource.class.columns_hash[key.to_s].type
 
-      end
+    # puts "---" * 30
+    # puts "key: #{key}"
+    # puts "value: #{value}"
+    # puts "datatype: #{datatype}"
+    # puts "---" * 30
 
-      private
-
-      def set_resource_class
-        @resource_class = params[:resource_class].constantize
-      end
+    field_dom_id = dom_id(@resource, key)
+    field = Oversee::Field::Form.new(resource: @resource, datatype:, key:, value:)
 
-      def resource_params
-        params.require(:resource).permit!
+    respond_to do |format|
+      format.turbo_stream do
+        render turbo_stream: turbo_stream.replace(field_dom_id, field)
       end
     end
   end

data/app/controllers/oversee/resources_controller.rb

@@ -2,51 +2,67 @@ module Oversee
   class ResourcesController < BaseController
     include ActionView::RecordIdentifier
 
-    before_action :set_resource_class, except: [:create, :update]
-    before_action :set_resource, only: %i[show edit destroy]
+    before_action :set_resource_class
+    before_action :set_resource, only: %i[show edit update destroy]
+    before_action :set_resources, only: %i[index]
 
     def index
-      set_sorting_rules
-
-      @resources = @resource_class.order(@sort_attribute.to_sym => sort_direction)
-      @pagy, @resources = pagy(@resources)
+      @pagy, @resources = pagy(@resources, limit: params[:per_page] || Oversee.configuration.per_page)
+
+      render Oversee::Resources::Index.new(
+        resources: @resources,
+        resource_class: @resource_class,
+        pagy: @pagy,
+        params: params
+      ), layout: false
     end
 
     def new
       @resource = @resource_class.new
+      render Oversee::Resources::New.new(
+        resource: @resource,
+        resource_class: @resource_class,
+        params: params
+      ), layout: false
     end
 
     def create
-      @resource_class = params[:resource_class].constantize
       @resource = @resource_class.new(resource_params)
 
       respond_to do |format|
         if @resource.update(resource_params)
-          format.html { redirect_to resource_path(@resource.id, resource: @resource_class) }
-          format.turbo_stream
+          format.html { redirect_to resource_path(@resource.id, resource_class_name: @resource_class) }
+          format.turbo_stream { redirect_to resource_path(@resource.id, resource_class_name: @resource_class), status: :see_other }
         else
+          format.html { render :new }
+          format.turbo_stream { render turbo_stream: turbo_stream.replace(dom_id(@resource), Oversee::Resources::Form.new(resource: @resource)) }
         end
       end
     end
 
     def show
-      resource_associations
+      render Oversee::Resources::Show.new(
+        resource: @resource,
+        resource_class: @resource_class,
+        resource_associations: resource_associations,
+        params: params
+      ), layout: false
     end
 
     def edit
     end
 
     def update
-      @resource_class = params[:resource_class].constantize
-      set_resource
-
-      @key = params[:resource][:oversee_key]
-      @datatype = params[:resource][:oversee_datatype]
+      key = params[:oversee_key]
+      datatype = params[:oversee_datatype]
 
       respond_to do |format|
         if @resource.update(resource_params)
           format.html { redirect_to resource_path(@resource.id, resource: @resource_class) }
-          format.turbo_stream
+          format.turbo_stream do
+            component = Oversee::Field::Display.new(resource: @resource, datatype:, key:, value: @resource.send(key))
+            render turbo_stream: turbo_stream.replace(dom_id(@resource, key), component)
+          end
         else
         end
       end
@@ -57,19 +73,34 @@ module Oversee
       redirect_to resources_path(resource: @resource_class)
     end
 
-    # Non-standard actions
-    def input_field
-      set_resource
+    def association
+      @resources = @resource_class.find(params[:id]).send(params[:association_name])
+      @pagy, @resources = pagy(@resources, limit: params[:per_page] || Oversee.configuration.per_page)
+
+      render Oversee::Resources::Index.new(
+        resources: @resources,
+        resource_class: @resource_class,
+        pagy: @pagy,
+        params: params
+      )
+    end
 
-      @key = params[:key].to_sym
-      @value = @resource.send(@key)
-      @datatype = @resource.class.columns_hash[@key.to_s].type
+    def table
+      if params[:association_name].present?
+        @resources = @resource_class.find(params[:id]).send(params[:association_name])
+      else
+        set_resources
+      end
+
+      component_id = dom_id(@resource_class, :table)
+      component = Oversee::Resources::Table.new(resource_class: @resource_class, resources: @resources, params: params)
 
       respond_to do |format|
         format.turbo_stream do
-          render turbo_stream: [
-            turbo_stream.replace(dom_id(@resource, @key), partial: "oversee/resources/input_field", locals: { datatype: @datatype, key: @key, value: @value })
-          ]
+          render turbo_stream: turbo_stream.replace(component_id, component)
+        end
+        format.html do
+          render component, layout: false
         end
       end
     end
@@ -77,13 +108,21 @@ module Oversee
     private
 
     def set_resource_class
-      @resource_class = params[:resource].constantize
+      @resource_class = params[:resource_class_name].constantize
     end
 
     def set_resource
       @resource = @resource_class.find(params[:id])
     end
 
+    def set_resources
+      set_sorting_rules
+
+      @resources = @resource_class.order(@sort_attribute.to_sym => sort_direction)
+      @resources = Oversee::Filter.new(collection: @resources, params:).apply
+      @resources = Oversee::Search.new(collection: @resources, resource_class: @resource_class, query: params[:query]).call
+    end
+
     def resource_associations
       @resource_associations ||= @resource_class.reflect_on_all_associations
     end

data/app/javascript/oversee/application.js

@@ -0,0 +1,3 @@
+import "trix";
+import "@rails/actiontext";
+import "controllers";

data/app/javascript/oversee/controllers/index.js

@@ -0,0 +1,8 @@
+import { Application } from "@hotwired/stimulus";
+const application = Application.start();
+
+application.debug = false;
+window.Stimulus = application;
+
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading";
+eagerLoadControllersFrom("controllers", application);

data/app/javascript/oversee/controllers/reveal_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  connect() {
+    console.log("Hello from reveal_controller.js");
+  }
+}

data/app/javascript/oversee/controllers/sidebar/state_controller.js

@@ -0,0 +1,21 @@
+import { Controller } from "@hotwired/stimulus";
+
+const KEY_BASE = "oversee-sidebar";
+
+export default class extends Controller {
+  initialize() {
+    this.key = `${KEY_BASE}--${this.element.id}`;
+    this.expanded = localStorage.getItem(this.key) === "true";
+    this.element.open = this.expanded;
+  }
+
+  toggle() {
+    this.expanded = !this.expanded;
+    this.element.open = this.expanded;
+  }
+
+  persist(event) {
+    this.expanded = event.newState === "open";
+    localStorage.setItem(this.key, this.expanded);
+  }
+}

data/app/models/oversee/resource.rb

@@ -0,0 +1,62 @@
+class Oversee::Resource
+  attr_reader :resource_class
+  attr_reader :resource_class_name
+  attr_reader :instance
+  attr_reader :rich_text_associations
+
+  attr_accessor :associations
+
+  def initialize(resource_class:, instance: nil)
+    @resource_class = resource_class
+    @resource_class_name = resource_class.to_s
+    @instance = instance
+  end
+
+  # Route helpers
+  def resources_path
+
+  end
+
+  def resource_path
+  end
+
+  # Columns
+  def columns_for_create
+    excluded_columns = [resource_class.primary_key, "created_at", "updated_at"]
+    resource_class.columns_hash.except(*excluded_columns)
+  end
+
+  def columns_for_show
+
+  end
+
+  # Associations
+  # Structured by association macro
+  def associations
+    @associations ||= begin
+      map = Hash.new { |hash, key| hash[key] = [] }
+
+      @resource_class.reflect_on_all_associations.each do |association|
+        map[association.macro] << {
+          name: association.name,
+          class_name: association.class_name,
+          foreign_key: association.foreign_key,
+          optional: association.macro == :belongs_to ? !!association.options[:optional] : true,
+          through: association.options[:through],
+          rich_text: association.name.to_s.start_with?("rich_text_"),
+        }
+      end
+      map
+    end
+  end
+
+  def foreign_keys
+    resource_class.reflections.map do |name, reflection|
+      reflection.foreign_key if reflection.belongs_to?
+    end.compact
+  end
+
+  def rich_text_associations
+    @rich_text_associations ||= associations[:has_one].select { |association| association[:rich_text] }
+  end
+end

data/app/service/oversee/filter.rb

@@ -0,0 +1,39 @@
+class Oversee::Filter
+  ALLOWED_OPERATORS = %w[eq in gt gte lt lte].freeze
+
+  def initialize(collection:, params: nil)
+    @collection = collection
+    @params = params
+  end
+
+
+  def apply
+    return @collection if filters.blank?
+
+    filters.each do |key, constraint|
+      operator = constraint.keys.first
+      next unless ALLOWED_OPERATORS.include?(operator)
+
+      value = constraint[operator]
+      chain(key:, operator:, value:)
+    end
+    return @collection
+  end
+
+  private
+
+  # Example params hash:
+  # filters[kind][eq][]=get => {"kind"=>{"is"=>["get"]}}
+  def filters
+    @filters ||= @params[:filters]
+  end
+
+  def chain(key:, operator:, value:)
+    @collection = case operator
+    when "eq"
+      @collection.then { _1.where(key => value) }
+    when "in"
+      @collection.then { _1.where(key => value) }
+    end
+  end
+end

data/app/service/oversee/search.rb

@@ -0,0 +1,34 @@
+class Oversee::Search
+  DEFAULT_SEARCHABLE_ATTRIBUTES = %w[name title email email_address]
+
+  def initialize(collection:, resource_class:, query: nil)
+    @collection = collection
+    @resource_class = resource_class
+    @query = query
+  end
+
+  def call
+    return @collection if @query.blank? || @resource_class.blank?
+    default_searchable_by
+  end
+
+  def default_searchable_attribute
+    DEFAULT_SEARCHABLE_ATTRIBUTES.each do |attr|
+      return attr if @resource_class.column_names.include?(attr)
+    end
+
+    return @resource_class.primary_key
+  end
+
+  private
+
+  def default_searchable_by
+    return @collection.where(default_searchable_attribute => @query) if @resource_class.primary_key == default_searchable_attribute
+
+    @collection
+      .where(@resource_class.arel_table[default_searchable_attribute]
+      .matches("%#{@query}%"))
+  end
+
+
+end

data/app/views/oversee/base.rb

@@ -0,0 +1,5 @@
+class Oversee::Views::Base < Phlex::HTML
+  def around_template
+    render Oversee::Layout::Application.new { super }
+  end
+end

data/config/importmap.rb

@@ -0,0 +1,14 @@
+# Application
+pin "application", to: "oversee/application.js", preload: true
+
+# Rich text editor
+pin "trix", to: "https://unpkg.com/trix@2.1.8"
+pin "@rails/actiontext", to: "https://unpkg.com/@rails/actiontext@8.0.0"
+
+# Turbo
+pin "@hotwired/turbo-rails", to: "https://unpkg.com/@hotwired/turbo-rails"
+
+# Stimulus
+pin "@hotwired/stimulus", to: "https://unpkg.com/@hotwired/stimulus/dist/stimulus.js"
+pin "@hotwired/stimulus-loading", to: "stimulus-loading.js", preload: true
+pin_all_from Oversee::Engine.root.join("app/javascript/oversee/controllers"), under: "controllers", to: "oversee/controllers"

data/config/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  pagy:
+    prev: "« Prev"
+    next: "Next »"

data/config/locales/oversee.en.yml

@@ -0,0 +1,4 @@
+en:
+  pagy:
+    prev: "« Prev"
+    next: "Next »"

data/config/routes.rb

@@ -1,16 +1,22 @@
 Oversee::Engine.routes.draw do
-
   # Resources
-  scope :resources, controller: "resources" do
-    get ":resource/", action: :index, as: :resources
-    get ":resource/new", action: :new, as: :new_resource
-    post ":resource_class/", action: :create, as: :create_resource
-    get ":resource/:id", action: :show, as: :resource
-    get ":resource/:id/edit", action: :edit, as: :edit_resource
-    patch ":resource/:id", action: :update, as: :update_resource
-    delete ":resource/:id", action: :destroy, as: :destroy_resource
-    get ":resource/:id/input_field", action: :input_field, as: :input_field
+  scope ":resource_class_name", controller: "resources" do
+    get "/", action: :index, as: :resources
+    post "/", action: :create, as: :create_resource
+    get "/new", action: :new, as: :new_resource
+    get "/:id", action: :show, as: :resource
+    get "/:id/edit", action: :edit, as: :edit_resource
+    patch "/:id", action: :update, as: :update_resource
+    delete "/:id", action: :destroy, as: :destroy_resource
+    get "/table", action: :table, as: :resources_table
+
+    get "/:id/input_field", action: :input_field, as: :resource_input_field
+    get "/:id/association", action: :association, as: :resource_association
+
+
+    # To reach this route using Rails' route helpers, use resource_input_path(:resource_class_name, :id)
+    get "/:id/input", controller: "resources/fields", action: :input, as: :resource_input
   end
 
-  root to: "dashboard#show"
+  root to: "dashboard#index"
 end

data/lib/generators/oversee/install_generator.rb

@@ -0,0 +1,7 @@
+class Oversee::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+
+  def add_routes
+    route 'mount Oversee::Engine => "/oversee"'
+  end
+end