solidus_admin 0.0.0 → 0.0.1

data/lib/generators/solidus_admin/install/templates/config/initializers/solidus_admin.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+SolidusAdmin::Config.configure do |config|
+  # Path to the logo used in the admin interface.
+  #
+  # It needs to be a path to an image file accessible by Sprockets.
+  # config.logo_path = "my_own_logo.svg"
+
+  # Add custom paths for TailwindCSS to scan for styles. By default, it already
+  # includes the following paths:
+  # - public/solidus_admin/*.html
+  # - app/helpers/solidus_admin/**/*.rb
+  # - app/assets/javascripts/solidus_admin/**/*.js
+  # - app/views/solidus_admin/**/*.{erb,haml,html,slim}
+  # - app/components/solidus_admin/**/*.{rb,erb,haml,html,slim,js}
+  #
+  # config.tailwind_content << Rails.root.join("app/my/custom/path/**.rb")
+
+  # Append custom stylesheets to be compiled by TailwindCSS.
+  # config.tailwind_stylesheets << Rails.root.join("app/my/custom/path/style.css")
+
+  # Add custom folder paths to watch for changes to trigger a cache sweep forcing a
+  # regeneration of the importmap.
+  # config.importmap_cache_sweepers << Rails.root.join("app/javascript/my_admin_components")
+
+  # Add custom paths to importmap files to be loaded.
+  # config.importmap_paths << Rails.root.join("config/solidus_admin_importmap.rb")
+  #
+  # Configure the main navigation.
+  # See SolidusAdmin::MainNavItem for more details.
+  # config.menu_items << {
+  #   key: :my_custom_link,
+  #   route: :my_custom_link_path,
+  #   icon: "solidus_admin/price-tag-3-line.svg",
+  #   position: 80,
+  #   children: [
+  #     {
+  #       key: :my_custom_child_link,
+  #       route: :my_custom_child_link_path,
+  #       position: 10
+  #     }
+  #   ]
+  # }
+end

data/lib/solidus_admin/configuration.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'spree/preferences/configuration'
+
+module SolidusAdmin
+  # Configuration for the admin interface.
+  #
+  # Ensure requiring this file after the Rails application has been created,
+  # as some defaults depend on the application context.
+  class Configuration < Spree::Preferences::Configuration
+    ComponentNotFoundError = Class.new(NameError)
+    ENGINE_ROOT = File.expand_path("#{__dir__}/../..")
+
+    # Path to the logo used in the admin interface.
+    #
+    # It needs to be a path to an image file accessible by Sprockets.
+    # The default value is the Solidus logo that lives in the solidus_core gem.
+    preference :logo_path, :string, default: "logo/solidus.svg"
+
+    # The list of paths were Tailwind CSS classes are used.
+    #
+    # You can modify this list to include your own paths:
+    #
+    #    SolidusAdmin::Config.tailwind_content << Rails.root.join("app/my/custom/path")
+    #
+    # Recompile with `bin/rails solidus_admin:tailwindcss:build` after changing this list.
+    #
+    # @see https://tailwindcss.com/docs/configuration#content
+    preference :tailwind_content, :array, default: [
+      "#{ENGINE_ROOT}/app/helpers/**/*.rb",
+      "#{ENGINE_ROOT}/app/assets/javascripts/**/*.js",
+      "#{ENGINE_ROOT}/app/views/**/*.erb",
+      "#{ENGINE_ROOT}/app/components/**/*.{rb,erb,js}",
+      "#{ENGINE_ROOT}/spec/components/previews/**/*.{erb,rb}",
+
+      Rails.root&.join("public/solidus_admin/*.html"),
+      Rails.root&.join("app/helpers/solidus_admin/**/*.rb"),
+      Rails.root&.join("app/assets/javascripts/solidus_admin/**/*.js"),
+      Rails.root&.join("app/views/solidus_admin/**/*.{erb,haml,html,slim}"),
+      Rails.root&.join("app/components/solidus_admin/**/*.{rb,erb,haml,html,slim,js}")
+    ].compact
+
+    # List of Tailwind CSS files to be combined into the final stylesheet.
+    #
+    # You can modify this list to include your own files:
+    #
+    #   SolidusAdmin::Config.tailwind_stylesheets << Rails.root.join("app/assets/stylesheets/solidus_admin/application.tailwind.css")
+    #
+    # Recompile with `bin/rails solidus_admin:tailwindcss:build` after changing this list.
+    preference :tailwind_stylesheets, :array, default: []
+
+    # List of paths to watch for changes to trigger a cache sweep forcing a regeneration of the importmap.
+    #
+    # @see https://github.com/rails/importmap-rails#sweeping-the-cache-in-development-and-test
+    preference :importmap_cache_sweepers, :array, default: [
+      "#{ENGINE_ROOT}/app/assets/javascripts",
+      "#{ENGINE_ROOT}/app/javascript",
+      "#{ENGINE_ROOT}/app/components",
+    ]
+
+    # List of paths to importmap files to be loaded.
+    #
+    # @see https://github.com/rails/importmap-rails#composing-import-maps
+    preference :importmap_paths, :array, default: [
+      "#{ENGINE_ROOT}/config/importmap.rb",
+    ]
+
+    # @!attribute [rw] orders_per_page
+    #   @return [Integer] The number of orders to display per page in the admin interface.
+    #                     This preference determines the pagination limit for the order listing.
+    #                     The default value is fetched from the Spree core configuration and currently set to 15.
+    preference :orders_per_page, :integer, default: Spree::Config[:orders_per_page]
+
+    # @!attribute [rw] order_search_key
+    #   The key that specifies the attributes for searching orders within the admin interface.
+    #   This preference controls which attributes of an order are used in search queries.
+    #   By default, it is set to
+    #   'number_shipments_number_or_bill_address_name_or_email_order_promotions_promotion_code_value_cont',
+    #   enabling a search across order number, shipment number, billing address name, email, and promotion code value.
+    #   @return [String] The search key used to determine order attributes for search.
+    preference :order_search_key, :string, default: :number_or_shipments_number_or_bill_address_name_or_email_or_order_promotions_promotion_code_value_cont
+
+    # @!attribute [rw] products_per_page
+    #   @return [Integer] The number of products to display per page in the admin interface.
+    #                     This preference determines the pagination limit for the product listing.
+    #                     The default value is fetched from the Spree core configuration and currently set to 10.
+    preference :products_per_page, :integer, default: Spree::Config[:admin_products_per_page]
+
+    # @!attribute [rw] product_search_key
+    #   @return [String] The key to use when searching for products in the admin interface.
+    #                    This preference determines the product attribute to use for search.
+    #                    By default, it is set to 'name_or_variants_including_master_sku_cont',
+    #                    meaning it will search by product name or product variants sku.
+    preference :product_search_key, :string, default: :name_or_variants_including_master_sku_cont
+
+    preference :storefront_product_path_proc, :proc, default: ->(_version) {
+      ->(product) { "/products/#{product.slug}" }
+    }
+
+    def storefront_product_path(product)
+      storefront_product_path_proc.call(product)
+    end
+
+    # Gives access to the main navigation configuration
+    #
+    # @example
+    #  SolidusAdmin::Config.menu_items << {
+    #    key: :my_custom_link,
+    #    route: :products_path,
+    #    icon: "solidus_admin/price-tag-3-line.svg",
+    #    position: 80
+    #  }
+    #
+    # @api public
+    # @return [Array<Hash>]
+    def menu_items
+      @menu_items ||= [
+        {
+          key: "orders",
+          route: -> { spree.admin_orders_path },
+          icon: "inbox-line",
+          position: 10
+        },
+        {
+          key: "products",
+          route: :products_path,
+          icon: "price-tag-3-line",
+          position: 20,
+          children: [
+            {
+              key: "products",
+              route: -> { solidus_admin.products_path },
+              match_path: -> { _1.start_with?("/admin/products/") },
+              position: 0
+            },
+            {
+              key: "option_types",
+              route: -> { spree.admin_option_types_path },
+              position: 10
+            },
+            {
+              key: "property_types",
+              route: -> { spree.admin_properties_path },
+              position: 20
+            },
+            {
+              key: "taxonomies",
+              route: -> { spree.admin_taxonomies_path },
+              position: 30
+            },
+            {
+              key: "taxons",
+              route: -> { spree.admin_taxons_path },
+              position: 40
+            }
+          ]
+        },
+
+        {
+          key: "promotions",
+          route: -> { spree.admin_promotions_path },
+          icon: "megaphone-line",
+          position: 30,
+        },
+
+        {
+          key: "stock",
+          route: -> { spree.admin_stock_items_path },
+          icon: "stack-line",
+          position: 40
+        },
+
+        {
+          key: "users",
+          route: -> { spree.admin_users_path },
+          icon: "user-line",
+          position: 50
+        },
+
+        {
+          key: "settings",
+          route: -> { spree.admin_stores_path },
+          icon: "settings-line",
+          position: 60,
+        }
+      ]
+    end
+
+    def components
+      @components ||= Hash.new do |_h, k|
+        "solidus_admin/#{k}/component".classify.constantize
+      rescue NameError
+        prefix = "#{ENGINE_ROOT}/app/components/solidus_admin/"
+        suffix = "/component.rb"
+        dictionary = Dir["#{prefix}**#{suffix}"].map { _1.delete_prefix(prefix).delete_suffix(suffix) }
+        corrections = DidYouMean::SpellChecker.new(dictionary: dictionary).correct(k.to_s)
+
+        raise ComponentNotFoundError, "Unknown component #{k}#{DidYouMean.formatter.message_for(corrections)}"
+      end
+    end
+
+    # The method used to authenticate the user in the admin interface, it's expected to redirect the user to the login method
+    # in case the authentication fails.
+    preference :authentication_method, :string, default: :authenticate_solidus_backend_user!
+
+    # The method used to retrieve the current user in the admin interface.
+    preference :current_user_method, :string, default: :spree_current_user
+
+    # The path used to logout the user in the admin interface.
+    preference :logout_link_path, :string, default: '/admin/logout'
+
+    # The HTTP method used to logout the user in the admin interface.
+    preference :logout_link_method, :string, default: :delete
+  end
+end
+
+SolidusAdmin::Config = SolidusAdmin::Configuration.new

data/lib/solidus_admin/engine.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "stimulus-rails"
+require "turbo-rails"
+require "view_component"
+
+module SolidusAdmin
+  class Engine < ::Rails::Engine
+    isolate_namespace SolidusAdmin
+
+    config.before_initialize do
+      require "solidus_admin/configuration"
+    end
+
+    config.autoload_paths << SolidusAdmin::Engine.root.join("spec/components/previews")
+
+    initializer "solidus_admin.view_component" do |app|
+      app.config.view_component.preview_paths << SolidusAdmin::Engine.root.join("spec/components/previews").to_s
+
+      app.config.to_prepare do
+        preview_controller_class = app.config.view_component.preview_controller.constantize
+
+        # This is needed to make the preview controller have access to the same
+        # set of helpers that are available to the Preview class.
+        preview_controller_class.include SolidusAdmin::Preview::ControllerHelper
+      end
+    end
+
+    initializer "solidus_admin.inflections" do
+      # Support for UI as an acronym
+      ActiveSupport::Inflector.inflections { |inflect| inflect.acronym 'UI' }
+    end
+
+    initializer "solidus_admin.importmap" do
+      SolidusAdmin::Config.importmap_paths.each { |path| SolidusAdmin.importmap.draw(path) }
+    end
+
+    initializer "solidus_admin.importmap.reloader" do |app|
+      Importmap::Reloader.new.tap do |reloader|
+        reloader.execute
+        app.reloaders << reloader
+        app.reloader.to_run { reloader.execute }
+      end
+    end
+
+    initializer "solidus_admin.assets" do |app|
+      app.config.assets.precompile += %w[solidus_admin_manifest.js]
+    end
+
+    initializer "solidus_admin.importmap.cache_sweeper" do |app|
+      if app.config.importmap.sweep_cache
+        SolidusAdmin.importmap.cache_sweeper(watches: SolidusAdmin::Config.importmap_cache_sweepers)
+
+        ActiveSupport.on_load(:action_controller_base) do
+          before_action { SolidusAdmin.importmap.cache_sweeper.execute_if_updated }
+        end
+      end
+    end
+
+    initializer "solidus_admin.importmap.assets" do |app|
+      app.config.assets.paths += [
+        SolidusAdmin::Engine.root.join("app/javascript"),
+        SolidusAdmin::Engine.root.join("app/components"),
+      ]
+    end
+  end
+end

data/lib/solidus_admin/importmap.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'importmap-rails'
+
+module SolidusAdmin::Importmap
+  class Reloader
+    delegate :execute_if_updated, :execute, :updated?, to: :updater
+
+    def reload!
+      importmap_paths.each { |path| SolidusAdmin.importmap.draw(path) }
+    end
+
+    private
+
+    def importmap_paths
+      SolidusAdmin::Config.importmap_paths
+    end
+
+    def updater
+      @updater ||= Rails.application.config.file_watcher.new(importmap_paths) { reload! }
+    end
+  end
+end
+
+SolidusAdmin.singleton_class.attr_accessor :importmap
+SolidusAdmin.importmap = Importmap::Map.new

data/lib/solidus_admin/main_nav_item.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  # Encapsulates the data for a main navigation item.
+  class MainNavItem
+    # @!attribute [r] key
+    #  @return [String] a unique identifier for this item
+    attr_reader :key
+
+    # @!attribute [r] icon
+    #  @return [String] icon from RemixIcon to use for this item
+    attr_reader :icon
+
+    # @!attribute [r] position
+    #  @return [Integer] the position of this item relative to its parent
+    attr_reader :position
+
+    # @!attribute [r] route
+    # @return [Symbol, Proc] the route to use for this item. When a symbol is
+    #   given, it will be called on the solidus_admin url helpers. When a proc is
+    #   given, it will be evaluated in a context that has access to the
+    #   solidus url helpers.
+    # @see #path
+    attr_reader :route
+
+    # @api private
+    attr_reader :children, :top_level
+
+    def initialize(
+      key:,
+      position:,
+      route:,
+      match_path: nil,
+      icon: nil,
+      children: [],
+      top_level: true
+    )
+      @key = key
+      @icon = icon
+      @position = position
+      @children = children
+      @top_level = top_level
+      @route = route
+      @match_path = match_path
+    end
+
+    def name
+      I18n.t("solidus_admin.main_nav.#{key}", default: key.to_s.humanize)
+    end
+
+    # @return [Boolean] whether this item has any children
+    def children?
+      @children.any?
+    end
+
+    # @param url_helpers [#solidus_admin, #spree] context object giving access
+    #   to url helpers
+    # @return [String] the path for this item
+    def path(url_helpers)
+      case @route
+      when Symbol
+        url_helpers.solidus_admin.public_send(@route)
+      when Proc
+        url_helpers.instance_exec(&@route)
+      end
+    end
+
+    # Returns whether the item should be marked as current
+    #
+    # An item is considered the current one if its base path (that is, the path
+    # without any query parameters) matches the given full path.
+    #
+    # @param url_helpers [#solidus_admin, #spree] context object giving access
+    #  to url helpers
+    # @param fullpath [String] the full path of the current request
+    # @return [Boolean]
+    def current?(url_helpers, fullpath)
+      path(url_helpers) == fullpath.gsub(/\?.*$/, '')
+    end
+
+    # Returns whether the item should be marked as active
+    #
+    # An item is considered active when it is the current item or any of its
+    # children is active.
+    #
+    # @param url_helpers [#solidus_admin, #spree] context object giving access
+    #   to url helpers
+    # @param fullpath [String] the full path of the current request
+    # @return [Boolean]
+    # @see #current?
+    def active?(url_helpers, fullpath)
+      current?(url_helpers, fullpath) ||
+        @match_path&.call(fullpath) ||
+        children.any? { |child| child.active?(url_helpers, fullpath) }
+    end
+  end
+end

data/lib/solidus_admin/preview.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# This module will add all the necessary harness to a ViewComponent::Preview
+# to be able to render Solidus components.
+#
+# Adds a `current_component` helper method that will return the the component class
+# based on the preview class name. The component class name is inferred by removing
+# the `Preview` suffix from the preview class name.
+#
+# Adds a `helpers` method that will return the helpers module from SolidusAdmin::BaseController
+# making them available to the preview class (which is not a standard controller). All helpers
+# are available to the preview class via `method_missing`.
+#
+# @example
+#   class SolidusAdmin::UI::Badge::ComponentPreview < ViewComponent::Preview
+#     include SolidusAdmin::Preview
+#
+#     def default
+#       render current_component.new(name: time_ago_in_words(1.day.ago))
+#     end
+#   end
+#
+module SolidusAdmin::Preview
+  extend ActiveSupport::Concern
+
+  module ControllerHelper
+    extend ActiveSupport::Concern
+
+    included do
+      include SolidusAdmin::ControllerHelpers::Authentication
+      helper ActionView::Helpers
+      helper SolidusAdmin::ComponentsHelper
+      helper_method :current_component
+    end
+
+    private
+
+    def spree_current_user
+      Spree::LegacyUser.new(email: "admin@example.com")
+    end
+
+    def authenticate_solidus_backend_user!
+      # noop
+    end
+
+    def current_component
+      @current_component ||= begin
+        # Lookbook sets the @preview instance variable with a PreviewEntity instance, while ViewComponent uses the preview class.
+        # Lookbook's PreviewEntity has `#preview_class_name` as part of its public api.
+        # Since we want to support both ways or rendering components, we need to check.
+        preview_class_name = @preview.respond_to?(:preview_class_name) ? @preview.preview_class_name : @preview.name
+        preview_class_name.chomp("Preview").constantize
+      end
+    end
+  end
+
+  included do
+    layout "solidus_admin/preview"
+
+    delegate :helpers, to: SolidusAdmin::BaseController
+    private :helpers # hide it from preview "example" methods
+  end
+
+  def current_component
+    @current_component ||= self.class.name.chomp("Preview").constantize
+  end
+
+  private
+
+  def method_missing(name, ...)
+    if helpers.respond_to?(name)
+      helpers.send(name, ...)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    helpers.respond_to?(name) || super
+  end
+end

data/lib/solidus_admin/tailwindcss.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "tailwindcss-rails"
+require "fileutils"
+
+module SolidusAdmin
+  # @api private
+  module Tailwindcss
+    module_function
+
+    def run(args = "")
+      config_file_path = compile_to_tempfile(
+        [config_app_path, config_engine_path].find(&:exist?),
+        "tailwind.config.js"
+      )
+      stylesheet_file_path = compile_to_tempfile(
+        [stylesheet_app_path, stylesheet_engine_path].find(&:exist?),
+        "application.tailwind.css"
+      )
+
+      system "#{::Tailwindcss::Engine.root.join('exe/tailwindcss')} \
+         -i #{stylesheet_file_path} \
+         -o #{Rails.root.join('app/assets/builds/solidus_admin/tailwind.css')} \
+         -c #{config_file_path} \
+         #{args}"
+    end
+
+    def config_app_path
+      Rails.root.join("config/solidus_admin/tailwind.config.js.erb")
+    end
+
+    def config_engine_path
+      SolidusAdmin::Engine.root.join("config/solidus_admin/tailwind.config.js.erb")
+    end
+
+    def stylesheet_app_path
+      Rails.root.join("app/assets/stylesheets/solidus_admin/application.tailwind.css.erb")
+    end
+
+    def stylesheet_engine_path
+      SolidusAdmin::Engine.root.join("app/assets/stylesheets/solidus_admin/application.tailwind.css.erb")
+    end
+
+    def compile_to_tempfile(erb_path, name)
+      Rails.root.join("tmp/solidus_admin/#{name}").tap do |file|
+        content = ERB.new(File.read(erb_path)).result
+
+        file.dirname.mkpath
+        file.write(content)
+      end
+    end
+
+    def copy_file(src, dst)
+      FileUtils.mkdir_p(File.dirname(dst))
+      FileUtils.cp(src, dst)
+    end
+  end
+end

data/lib/solidus_admin/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  VERSION = "0.0.1"
+end

data/lib/solidus_admin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "solidus_core"
+require "solidus_backend"
+
+module SolidusAdmin
+  require "solidus_admin/version"
+  require "solidus_admin/importmap"
+  require "solidus_admin/main_nav_item"
+  require "solidus_admin/preview"
+  require "solidus_admin/tailwindcss"
+
+  require "solidus_admin/configuration"
+  require "solidus_admin/engine"
+end

data/lib/tasks/importmap.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :solidus_admin do
+  namespace :importmap do
+    desc "Render Solidus Admin's importmap JSON"
+    task json: :environment do
+      puts SolidusAdmin.importmap.to_json(resolver: ActionController::Base.helpers)
+    end
+  end
+end

data/lib/tasks/tailwindcss.rake

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+namespace :solidus_admin do
+  namespace :tailwindcss do
+    require "solidus_admin/tailwindcss"
+
+    desc "Build Solidus Admin's Tailwind's css"
+    task build: :environment do
+      SolidusAdmin::Tailwindcss.run
+    end
+
+    desc <<~DESC
+      Watch and build Solidus Admin's Tailwind css on file changes
+
+      It needs to be re-run whenever:
+
+      - `SolidusAdmin::Config.tailwind_content` is updated
+      - `SolidusAdmin::Config.tailwind_stylesheets` is updated
+      - `bin/rails solidus_admin:tailwindcss:override_config` is run
+      - `bin/rails solidus_admin:tailwindcss:override_stylesheet` is run
+      - The override files are updated
+    DESC
+    task watch: :environment do
+      SolidusAdmin::Tailwindcss.run("-w")
+    end
+
+    desc <<~DESC
+      Override Solidus Admin's Tailwindcss configuration
+
+      It copies the config file from the engine to the app, so it can be customized.
+    DESC
+    task override_config: :environment do
+      SolidusAdmin::Tailwindcss.copy_file(
+        SolidusAdmin::Tailwindcss.config_engine_path,
+        SolidusAdmin::Tailwindcss.config_app_path
+      )
+    end
+
+    desc <<~DESC
+      Override Solidus Admin's Tailwind's stylesheet
+
+      It copies the stylesheet file from the engine to the app, so it can be customized.
+    DESC
+    task override_stylesheet: :environment do
+      SolidusAdmin::Tailwindcss.copy_file(
+        SolidusAdmin::Tailwindcss.stylesheet_engine_path,
+        SolidusAdmin::Tailwindcss.stylesheet_app_path
+      )
+    end
+  end
+end
+
+if Rake::Task.task_defined?("assets:precompile")
+  Rake::Task["assets:precompile"].enhance(["solidus_admin:tailwindcss:build"])
+end