terrazzo 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6030a4b97c39b154729b26996275571d8a6ffba864d84a0bff348257c308ce16
-  data.tar.gz: 82edfaa39bd26353f4c56a2e96b22739620033d527d3c3fb57f6fcde45ec4b7c
+  metadata.gz: 0012b6331bb196e5dc5f21adf05701413e64d09464b0179e770351ca57d9fa4d
+  data.tar.gz: 2654d7e0cbb96d374b7b01eb9062608551a0f816d3eba202037eb03a383979e4
 SHA512:
-  metadata.gz: cdc8552e4cf480b5dee699776ef5d1337eb7e1d92d387328d379b634165bf941774f4263ef0f0f8159ba8ae5fccb7d827b00425fed500b173f03325efddd908f
-  data.tar.gz: c7ff22f7872258e527a0558ef9a54df140a481aa76f8fc906250b16fd7b1210dc7f1a8293a6677398888461e26dd5b82ad967c6463eefd44df3e3d312591c9e6
+  metadata.gz: 1c24716124c7d4aba7330a704feef1b978990a89b0c8f890145f1276453907bb52a22999e5776fce9f698df183e7d8bb820e90183da0cb9ff208b8700d0c2d75
+  data.tar.gz: 0ef677cdb49be947a26b5e97bdcd694474277b7e7f86d5328cef68312299bda1a44b7d0b49b7d0e3d8213c354906e0cf1464cf4fd2df6e0d147ffe56158b5312

data/README.md

@@ -0,0 +1,101 @@
+# Terrazzo
+
+A drop-in admin panel for Rails apps. Uses the [Administrate](https://github.com/thoughtbot/administrate) dashboard DSL with a React SPA frontend powered by [Superglue](https://github.com/thoughtbot/superglue).
+
+- **Familiar DSL** — same `ATTRIBUTE_TYPES`, `COLLECTION_ATTRIBUTES`, `FORM_ATTRIBUTES` you already know
+- **React SPA** — search, sort, and paginate without full page reloads, no separate API needed
+- **shadcn/ui + Tailwind** — polished defaults with supported ejection when you want app-owned source
+- **19 field types** — string, text, number, money, boolean, date/time, email, URL, password, select, rich text, hstore, asset, belongs_to, has_many, has_one, polymorphic, and more
+
+## Quick start
+
+```bash
+# Add the gem
+bundle add terrazzo
+
+# Install Superglue (if not already set up)
+rails g superglue:install
+
+# Install Vite Rails for the default Vite setup.
+bundle add vite_rails
+bundle exec vite install
+# Resolve any package-manager errors from Vite before continuing.
+
+# Add the npm package and frontend dependencies
+npm install terrazzo
+npm install @radix-ui/react-avatar @radix-ui/react-dialog @radix-ui/react-dropdown-menu \
+  @radix-ui/react-label @radix-ui/react-popover @radix-ui/react-select \
+  @radix-ui/react-separator @radix-ui/react-slot @radix-ui/react-tooltip \
+  class-variance-authority lucide-react tailwindcss@latest
+npm install --save-dev @tailwindcss/cli@latest # if your app does not already compile Tailwind
+
+# Install Terrazzo — generates admin namespace, app barrels,
+# shadcn metadata/path aliases, and dashboards.
+# Uses Vite by default and requires vite_rails.
+# For Rails esbuild pass --bundler=esbuild.
+rails g terrazzo:install
+
+# Make sure app/assets/stylesheets/admin.css is compiled by Tailwind.
+# The installer adds build:admin:css when @tailwindcss/cli 4+ is installed,
+# adds a package build script when one is missing, or warns with the setup
+# command if no script or tailwindcss-rails setup compiles the Rails-linked
+# admin stylesheet.
+
+# Start Rails and Vite
+bin/dev
+```
+
+Visit `http://localhost:3000/admin` to see your admin panel.
+
+## Documentation
+
+Full docs at **[gohypelab.github.io/terrazzo](https://gohypelab.github.io/terrazzo/)** — covers dashboards, fields, controllers, views, generators, and customization.
+
+## Requirements
+
+- Ruby 3.1+
+- Rails 7.1+
+- Node.js 18+
+- A JS bundler (Vite recommended, esbuild also supported)
+
+## Customizing Per-Row Actions
+
+Terrazzo generates Show, Edit, and Destroy action buttons for each row on index pages and has_many tables on show pages.
+
+Override `collection_item_actions` in the resource dashboard to add or replace actions per resource type. Use `super` when you want to keep the default Show/Edit/Destroy actions:
+
+```ruby
+class OrderDashboard < Terrazzo::BaseDashboard
+  # ...
+
+  def collection_item_actions(resource, view)
+    super + [
+      { label: "Invoice", url: view.invoice_admin_order_path(resource) },
+    ]
+  end
+end
+```
+
+Return a new array instead when you want to fully replace the default actions.
+
+The `view` argument gives access to route helpers. Each action hash supports `label` (String), `url` (String), `method` (optional, e.g. `"delete"`), `confirm` (optional confirmation message for non-GET form actions), and `sg_visit` (set to `false` to bypass SPA navigation).
+
+## Bulk Collection Actions
+
+Override `collection_bulk_actions` to add actions for selected rows on an index page:
+
+```ruby
+class OrderDashboard < Terrazzo::BaseDashboard
+  def collection_bulk_actions(view)
+    [
+      { label: "Mark shipped", url: view.bulk_ship_admin_orders_path, method: "post" },
+    ]
+  end
+end
+```
+
+Bulk action forms submit selected row IDs as `params[:ids]`. Define the matching collection route and controller action in your app.
+
+## License
+
+MIT

data/Rakefile

@@ -5,6 +5,7 @@ begin
   RSpec::Core::RakeTask.new(:spec) do |t|
     t.pattern = "spec/lib/**/*_spec.rb"
   end
+  task check: [:spec, :build]
   task default: :spec
 rescue LoadError
   # rspec not available

data/app/controllers/terrazzo/application_controller.rb

@@ -3,6 +3,7 @@ require "superglue"
 module Terrazzo
   class ApplicationController < ::ActionController::Base
     include Superglue::Controller
+    include Terrazzo::ResourcePathsHelper
 
     prepend_view_path(
       Superglue::Resolver.new(Terrazzo::Engine.root.join("app/views"))
@@ -16,26 +17,29 @@ module Terrazzo
 
     prepend Terrazzo::UsesSuperglue::TemplateLookupOverride
 
-    helper_method :namespace, :dashboard, :resource_name, :resource_class, :application_title, :terrazzo_page_identifier, :route_exists?
+    helper_method :namespace, :dashboard, :resource_name, :resource_class, :application_title, :terrazzo_page_identifier, :route_exists?, :authorized_action?
     helper Terrazzo::CollectionActionsHelper
+    helper Terrazzo::ResourcePathsHelper
 
     def index
-      search = Terrazzo::Search.new(scoped_resource, dashboard, params[:search])
-      resources = search.run
+      resources, order = index_resources_and_order
 
-      filter = Terrazzo::Filter.new(resources, dashboard, params[:filter], params[:filter_value])
-      resources = filter.run
+      if request.format.csv?
+        return head :not_acceptable unless dashboard.csv_export_enabled?
 
-      order = Terrazzo::Order.new(
-        attribute: params[:order] || default_sorting_attribute,
-        direction: params[:direction] || (params[:order] ? nil : default_sorting_direction)
-      )
-      resources = order.apply(resources, dashboard)
+        includes = dashboard.includes_for_attributes(dashboard.csv_attributes)
+        resources = resources.includes(*includes) if includes.any?
+
+        send_data Terrazzo::CsvExport.new(dashboard, resources).to_csv,
+          filename: dashboard.csv_filename,
+          type: "text/csv; charset=utf-8"
+        return
+      end
 
       includes = dashboard.collection_includes
       resources = resources.includes(*includes) if includes.any?
 
-      @resources = resources.page(params[:_page]).per(params[:per_page] || 25)
+      @resources = resources.page(params[:_page]).per(index_per_page)
       @page = Terrazzo::Page::Collection.new(dashboard, resource_class, order: order)
       @search_term = params[:search]
       @active_filter = params[:filter]
@@ -44,6 +48,7 @@ module Terrazzo
 
     def show
       @resource = find_resource(params[:id])
+      authorize_action!(@resource, :show)
       @page = Terrazzo::Page::Show.new(
         dashboard, @resource,
         has_many_params: Terrazzo::HasManyPagination.extract(params, dashboard.has_many_attributes)
@@ -52,16 +57,20 @@ module Terrazzo
 
     def new
       @resource = resource_class.new
+      authorize_action!(@resource, :new)
       @page = Terrazzo::Page::Form.new(dashboard, @resource)
     end
 
     def edit
       @resource = find_resource(params[:id])
+      authorize_action!(@resource, :edit)
       @page = Terrazzo::Page::Form.new(dashboard, @resource)
     end
 
     def create
-      @resource = resource_class.new(resource_params("create"))
+      @resource = resource_class.new
+      authorize_action!(@resource, :create)
+      @resource.assign_attributes(resource_params("create"))
       assign_has_one_associations(@resource)
 
       if @resource.save
@@ -76,6 +85,7 @@ module Terrazzo
 
     def update
       @resource = find_resource(params[:id])
+      authorize_action!(@resource, :update)
 
       rp = resource_params("update")
       assign_has_one_associations(@resource)
@@ -92,6 +102,7 @@ module Terrazzo
 
     def destroy
       @resource = find_resource(params[:id])
+      authorize_action!(@resource, :destroy)
       @resource.destroy
 
       redirect_to after_resource_destroyed_path,
@@ -113,12 +124,28 @@ module Terrazzo
       :asc
     end
 
+    def default_per_page
+      25
+    end
+
+    def max_per_page
+      100
+    end
+
+    def index_per_page
+      requested = params[:per_page].presence || default_per_page
+      requested = requested.to_i
+      requested = default_per_page if requested <= 0
+
+      [requested, max_per_page].min
+    end
+
     def after_resource_created_path(resource)
-      [namespace, resource]
+      terrazzo_resource_member_path(resource) || after_resource_destroyed_path
     end
 
     def after_resource_updated_path(resource)
-      [namespace, resource]
+      terrazzo_resource_member_path(resource) || after_resource_destroyed_path
     end
 
     def after_resource_destroyed_path
@@ -131,6 +158,22 @@ module Terrazzo
       resource_class.all
     end
 
+    def index_resources_and_order
+      search = Terrazzo::Search.new(scoped_resource, dashboard, params[:search])
+      resources = search.run
+
+      filter = Terrazzo::Filter.new(resources, dashboard, params[:filter], params[:filter_value])
+      resources = filter.run
+
+      order = Terrazzo::Order.new(
+        attribute: params[:order] || default_sorting_attribute,
+        direction: params[:direction] || (params[:order] ? nil : default_sorting_direction)
+      )
+      resources = order.apply(resources, dashboard)
+
+      [resources, order]
+    end
+
     def find_resource(id)
       @_find_resource ||= scoped_resource.find(id)
     end
@@ -178,6 +221,12 @@ module Terrazzo
       true
     end
 
+    def authorize_action!(resource, action)
+      return if authorized_action?(resource, action)
+
+      raise Terrazzo::NotAuthorizedError
+    end
+
     def namespace
       @_namespace ||= resolver.namespace
     end

data/app/helpers/terrazzo/collection_actions_helper.rb

@@ -2,20 +2,32 @@ module Terrazzo
   module CollectionActionsHelper
     def collection_item_actions(resource)
       resource_dashboard = "#{resource.class.name}Dashboard".safe_constantize&.new
-      if resource_dashboard&.respond_to?(:collection_item_actions)
-        resource_dashboard.collection_item_actions(resource, self)
-      else
-        default_collection_item_actions(resource)
-      end
+      dashboard = resource_dashboard if resource_dashboard&.respond_to?(:collection_item_actions)
+      dashboard ||= Terrazzo::BaseDashboard.new
+      dashboard.collection_item_actions(resource, self)
+    end
+
+    def collection_action_path(resource, action = :show)
+      return nil unless collection_action_route?(resource, action)
+      return nil unless collection_action_authorized?(resource, action)
+
+      terrazzo_resource_member_path(resource, action: action)
     end
 
     def has_many_pagination_paths(field, resource)
       param_key = Terrazzo::HasManyPagination.param_key(field.attribute)
-      base = request.query_parameters.merge(
+      legacy_param_key = Terrazzo::HasManyPagination.legacy_param_key(field.attribute)
+      query_parameters = request.query_parameters.except(
+        param_key,
+        param_key.to_sym,
+        legacy_param_key,
+        legacy_param_key.to_sym
+      )
+      base = query_parameters.merge(
         only_path: true,
         controller: controller_path,
         action: :show,
-        id: resource.to_param,
+        id: terrazzo_resource_param(resource),
         format: nil,
         props_at: "data.attributes.#{field.attribute}"
       )
@@ -27,12 +39,25 @@ module Terrazzo
 
     private
 
-    def default_collection_item_actions(resource)
-      actions = []
-      actions << { label: "Show", url: polymorphic_path([namespace, resource]) } rescue nil
-      actions << { label: "Edit", url: edit_polymorphic_path([namespace, resource]) } rescue nil
-      actions << { label: "Destroy", url: polymorphic_path([namespace, resource]), method: "delete", confirm: "Are you sure?" } rescue nil
-      actions.compact
+    def collection_action_route?(resource, action)
+      path = terrazzo_resource_member_path(resource, action: action)
+      return false unless path
+
+      recognized = Rails.application.routes.recognize_path(path, method: collection_action_http_method(action))
+      recognized[:controller] == terrazzo_resource_controller_path(resource) &&
+        recognized[:action] == action.to_s
+    rescue ActionController::RoutingError, ActionController::UrlGenerationError, NoMethodError
+      false
+    end
+
+    def collection_action_http_method(action)
+      action == :destroy ? :delete : :get
+    end
+
+    def collection_action_authorized?(resource, action)
+      return true unless respond_to?(:authorized_action?, true)
+
+      authorized_action?(resource, action)
     end
   end
 end

data/app/helpers/terrazzo/resource_paths_helper.rb

@@ -0,0 +1,55 @@
+module Terrazzo
+  module ResourcePathsHelper
+    def terrazzo_resource_collection_path(resource_or_class = resource_class)
+      url_for(
+        controller: terrazzo_resource_controller_path(resource_or_class),
+        action: :index,
+        only_path: true,
+        format: nil
+      )
+    rescue ActionController::UrlGenerationError
+      nil
+    end
+
+    def terrazzo_resource_new_path(resource_or_class = resource_class)
+      url_for(
+        controller: terrazzo_resource_controller_path(resource_or_class),
+        action: :new,
+        only_path: true,
+        format: nil
+      )
+    rescue ActionController::UrlGenerationError
+      nil
+    end
+
+    def terrazzo_resource_member_path(resource, action: :show)
+      return nil unless resource.respond_to?(:id) && resource.id.present?
+
+      route_action = action.to_sym == :destroy ? :show : action
+      url_for(
+        controller: terrazzo_resource_controller_path(resource),
+        action: route_action,
+        id: terrazzo_resource_param(resource),
+        only_path: true,
+        format: nil
+      )
+    rescue ActionController::UrlGenerationError
+      nil
+    end
+
+    # The URL parameter used to identify a member resource. Defaults to the
+    # record id. Override in a host app (e.g. to `resource.to_param`) to route
+    # members by slug or another identifier; the matching lookup belongs in the
+    # controller's #find_resource.
+    def terrazzo_resource_param(resource)
+      resource.id
+    end
+
+    def terrazzo_resource_controller_path(resource_or_class)
+      klass = resource_or_class.is_a?(Class) ? resource_or_class : resource_or_class.class
+      route_path = klass.model_name.name.underscore.pluralize
+
+      [namespace, route_path].compact.join("/")
+    end
+  end
+end

data/app/views/terrazzo/application/_edit_base.json.props

@@ -4,7 +4,7 @@ json.pageTitle t("terrazzo.actions.edit", resource_name: resource_name)
 
 json.form do
   json.props({
-    action: polymorphic_path([namespace, @resource]),
+    action: terrazzo_resource_member_path(@resource),
     method: "post",
     encType: "multipart/form-data"
   })
@@ -26,7 +26,8 @@ json.form do
   json.fields do
     json.array! @page.attributes("update") do |field|
       json.attribute field.attribute.to_s
-      json.label field.attribute.to_s.humanize
+      json.label dashboard.attribute_label(field.attribute, :form)
+      json.hint dashboard.attribute_hint(field.attribute, :form)
       json.fieldType field.field_type
       json.value field.serialize_value(:form)
       json.options field.serializable_options(:form)
@@ -40,7 +41,8 @@ json.form do
       json.fields do
         json.array! group[:fields] do |field|
           json.attribute field.attribute.to_s
-          json.label field.attribute.to_s.humanize
+          json.label dashboard.attribute_label(field.attribute, :form)
+          json.hint dashboard.attribute_hint(field.attribute, :form)
           json.fieldType field.field_type
           json.value field.serialize_value(:form)
           json.options field.serializable_options(:form)
@@ -54,7 +56,8 @@ end
 
 json.errors @resource.errors.full_messages
 
-json.showPath polymorphic_path([namespace, @resource])
+json.layoutActions Array(dashboard.layout_actions(:edit, self, resource: @resource))
+json.showPath route_exists?(:show) && authorized_action?(@resource, :show) ? terrazzo_resource_member_path(@resource) : nil
 json.indexPath begin
   url_for(controller: controller_path, action: :index, only_path: true)
 rescue ActionController::UrlGenerationError

data/app/views/terrazzo/application/_index_base.json.props

@@ -1,27 +1,99 @@
+per_page = @resources.limit_value
+
+filter_url_for = ->(filter_name = nil) do
+  query = request.query_parameters.except("_page", "filter", "filter_value")
+  query["per_page"] = per_page
+  query["filter"] = filter_name if filter_name.present?
+  url_for(query.merge(only_path: true))
+end
+
+header_options_for = ->(attribute) do
+  options = (dashboard.collection_header_options(attribute) || {}).to_h
+  class_name = options.delete(:class_name) ||
+    options.delete("class_name") ||
+    options.delete(:className) ||
+    options.delete("className")
+
+  {
+    className: class_name,
+    meta: options.presence,
+  }.compact
+end
+
+cell_options_for = ->(attribute, resource) do
+  options = (dashboard.collection_cell_options(attribute, resource) || {}).to_h
+  class_name = options.delete(:class_name) ||
+    options.delete("class_name") ||
+    options.delete(:className) ||
+    options.delete("className")
+
+  {
+    className: class_name,
+    meta: options.presence,
+  }.compact
+end
+
+row_options_for = ->(resource) do
+  options = (dashboard.collection_row_options(resource) || {}).to_h
+  class_name = options.delete(:class_name) ||
+    options.delete("class_name") ||
+    options.delete(:className) ||
+    options.delete("className")
+
+  {
+    className: class_name,
+    meta: options.presence,
+  }.compact
+end
+
 json.searchBar do
   json.searchTerm @search_term
   json.searchPath request.path
+  json.perPage per_page
+end
+
+json.layoutActions Array(dashboard.layout_actions(:index, self))
+json.toolbarActions Array(dashboard.collection_toolbar_actions(self))
+json.bulkActions Array(dashboard.collection_bulk_actions(self))
+
+json.emptyState do
+  json.title "No #{resource_name.pluralize.downcase} found"
+  json.description dashboard.empty_collection_message
 end
 
 json.filters do
   json.available dashboard.collection_filters.keys.map(&:to_s)
   json.active @active_filter
   json.value @filter_value
+  json.allUrl filter_url_for.call
+  json.options do
+    json.array! dashboard.collection_filter_options(self) do |option|
+      value = (option[:value] || option["value"]).to_s
+      label = option[:label] || option["label"]
+      json.label label
+      json.value value
+      json.active @active_filter.to_s == value
+      json.url filter_url_for.call(value)
+    end
+  end
 end
 
 json.table do
   json.headers do
     json.array! @page.attribute_names do |attr|
       field_class = dashboard.attribute_type_for(attr)
-      json.label attr.to_s.humanize
+      header_options = header_options_for.call(attr)
+      json.label dashboard.attribute_label(attr, :index)
       json.attribute attr.to_s
       json.sortable field_class.sortable?
       json.sortDirection @page.sort_direction_for(attr)
+      json.headerOptions header_options if header_options.present?
       json.sortUrl url_for(
         @page.order_params_for(attr).merge(
           search: @search_term,
           filter: @active_filter,
           filter_value: @filter_value,
+          per_page: per_page,
           _page: 1,
           only_path: true
         )
@@ -31,20 +103,24 @@ json.table do
 
   json.rows do
     json.array! @resources do |resource|
+      row_options = row_options_for.call(resource)
       json.id resource.id
-      json.showPath polymorphic_path([namespace, resource]) rescue nil
+      json.showPath collection_action_path(resource, :show)
       json.collectionItemActions collection_item_actions(resource)
+      json.rowOptions row_options if row_options.present?
 
       json.cells do
         json.array! @page.attribute_names do |attr|
           field = dashboard.attribute_type_for(attr).new(attr, nil, :index, resource: resource)
+          cell_options = cell_options_for.call(attr, resource)
           json.attribute attr.to_s
           json.fieldType field.field_type
           json.value field.serialize_value(:index)
           json.options field.serializable_options
+          json.cellOptions cell_options if cell_options.present?
 
           if field.class.associative? && field.data.present?
-            json.showPath polymorphic_path([namespace, field.data]) rescue nil
+            json.showPath collection_action_path(field.data, :show)
           end
         end
       end
@@ -56,11 +132,11 @@ json.pagination do
   json.currentPage @resources.current_page
   json.totalPages @resources.total_pages
   json.totalCount @resources.total_count
-  json.perPage @resources.limit_value
+  json.perPage per_page
   if @resources.next_page
     json.nextPagePath url_for(
       _page: @resources.next_page,
-      per_page: params[:per_page],
+      per_page: per_page,
       search: @search_term,
       order: params[:order],
       direction: params[:direction],
@@ -74,7 +150,7 @@ json.pagination do
   if @resources.prev_page
     json.prevPagePath url_for(
       _page: @resources.prev_page,
-      per_page: params[:per_page],
+      per_page: per_page,
       search: @search_term,
       order: params[:order],
       direction: params[:direction],
@@ -89,4 +165,4 @@ end
 
 json.resourceName resource_name.pluralize
 json.singularResourceName resource_name
-json.newResourcePath route_exists?(:new) ? (new_polymorphic_path([namespace, resource_class]) rescue nil) : nil
+json.newResourcePath route_exists?(:new) && authorized_action?(resource_class.new, :new) ? terrazzo_resource_new_path(resource_class) : nil

data/app/views/terrazzo/application/_navigation.json.props

@@ -1,10 +1,13 @@
-resources = Terrazzo::Namespace.new(namespace).resources_with_index_route
+resources = Terrazzo::Namespace.new(namespace).navigation_resources
+navigation_groups = resources.group_by(&:navigation_group).map do |label, items|
+  { label: label, items: items }
+end
 
-json.array! [{ label: "Resources", resources: resources }] do |group|
+json.array! navigation_groups do |group|
   json.label group[:label]
   json.items do
-    json.array! group[:resources] do |r|
-      json.label r.resource_name.humanize.pluralize
+    json.array! group[:items] do |r|
+      json.label r.navigation_label
       json.path url_for(controller: "/#{r.controller_path}", action: :index, only_path: true)
       json.active r.controller_path == controller_path
     end

data/app/views/terrazzo/application/_new_base.json.props

@@ -5,7 +5,7 @@ json.pageTitle t("terrazzo.actions.new", resource_name: resource_name)
 
 json.form do
   json.props({
-    action: polymorphic_path([namespace, resource_class]),
+    action: terrazzo_resource_collection_path(resource_class),
     method: "post",
     encType: "multipart/form-data"
   })
@@ -22,7 +22,8 @@ json.form do
   json.fields do
     json.array! @page.attributes(action) do |field|
       json.attribute field.attribute.to_s
-      json.label field.attribute.to_s.humanize
+      json.label dashboard.attribute_label(field.attribute, :form)
+      json.hint dashboard.attribute_hint(field.attribute, :form)
       json.fieldType field.field_type
       json.value field.serialize_value(:form)
       json.options field.serializable_options(:form)
@@ -36,7 +37,8 @@ json.form do
       json.fields do
         json.array! group[:fields] do |field|
           json.attribute field.attribute.to_s
-          json.label field.attribute.to_s.humanize
+          json.label dashboard.attribute_label(field.attribute, :form)
+          json.hint dashboard.attribute_hint(field.attribute, :form)
           json.fieldType field.field_type
           json.value field.serialize_value(:form)
           json.options field.serializable_options(:form)
@@ -50,6 +52,7 @@ end
 
 json.errors @resource.errors.full_messages
 
+json.layoutActions Array(dashboard.layout_actions(:new, self, resource: @resource))
 json.indexPath begin
   url_for(controller: controller_path, action: :index, only_path: true)
 rescue ActionController::UrlGenerationError