@spree/docs 0.1.85 → 0.1.86

package/dist/developer/tutorial/introduction.md

@@ -1,36 +1,44 @@
 ---
 title: Tutorial
 sidebarTitle: Introduction
-description: Learn how to build a custom feature from scratch, covering models, Admin dashboard and API.
+description: Build a complete custom feature — model, admin UI, Store API, and TypeScript storefront integration — the Spree way.
 ---
 
-This tutorial walks you through creating a complete Spree feature from scratch, covering models, Admin dashboard, Store API, and TypeScript SDK integration. 
-You will also learn how to extend core Spree features to connect them with your new feature.
-By the end, you'll understand how to add new manageable features to the Spree platform.
+This tutorial walks you through creating a complete Spree feature from scratch: a "Brands" feature that lets admins manage [Product](../core-concepts/products.md) brands, exposes them through the Store API, and consumes them from TypeScript.
 
-## Overview
+It's written for **both backend and frontend developers**. The Ruby you'll write is minimal and mostly generated — Spree's generators produce convention-correct models, admin UIs, and API endpoints, and the TypeScript SDK gives you typed access from your storefront. You don't need to be a Rails expert to follow along.
 
-To fully implement a new feature, you will typically create the following components:
+## Before you start
 
-* Database model
-* Admin Dashboard controllers and views
-* Store API endpoints and serializers
-* TypeScript SDK integration
-* Automated tests
+You need a running Spree app. The fastest path is [create-spree-app](../create-spree-app/quickstart.md) — a Docker-based project with the [Spree CLI](../cli/quickstart.md), no local Ruby required:
 
-## Tutorial Sections
+```bash
+npx create-spree-app@latest my-store
+```
+
+An existing app with Spree gems works just as well. **Every command in this tutorial is shown in two forms** — **Spree CLI** (runs inside Docker) and **Without Spree CLI** (runs directly on your machine) — pick the tab that matches your setup and ignore the other.
+
+> **NOTE:** **create-spree-app projects:** run `spree eject` once before starting. Fresh projects use a prebuilt Docker image; ejecting switches to the dev setup that mounts `backend/` into the container, so the files the generators create land in your project (and reload live as you edit them).
 
+> **TIP:** Using an AI coding agent? Install the [Spree agent skills](../agentic/agent-skills.md) (`npx skills add spree/agent-skills`) and connect the [docs MCP server](../agentic/mcp.md) before starting — your agent will know the conventions this tutorial teaches and can follow along with you. See [Agentic Development](../agentic/overview.md).
 
-  - [1. Model](model.md) — Create the Brand model with migrations, validations, and associations
-  - [2. Admin Dashboard](admin.md) — Build admin interface for managing brands
-  - [3. Rich Text](rich-text.md) — Add rich text descriptions using Action Text
-  - [4. File Uploads](file-uploads.md) — Add logo images with Active Storage
-  - [5. Extending Core Models](extending-models.md) — Connect Brands to Products using associations
-  - [6. Store API](store-api.md) — Expose Brands through the Store API with serializers, controllers, and routes
-  - [7. SDK](sdk.md) — Consume Brand endpoints from TypeScript using the SDK
-  - [8. Testing](testing.md) — Write automated tests for your feature
+## What you'll build
 
+* A `Brand` model with a rich text description and an uploadable logo — one generator command
+* An admin UI for managing brands — one generator command, then customized
+* A `brand` association on Products, surfaced in the product admin form
+* Store API endpoints (`GET /api/v3/store/brands`) with serializers and prefixed IDs
+* Typed TypeScript access to brands from your storefront via `@spree/sdk`
+* Event subscribers and webhooks connecting the store to external systems
+* Automated tests for all of it
+
+## Tutorial Sections
 
-## Example: Building a Brands Feature
 
-In this guide we will create a complete "Brands" feature that allows admins to manage [Product](../core-concepts/products.md) brands.
+  - [1. Model](model.md) — Generate the Brand model — columns, rich text description, and logo upload in one command
+  - [2. Admin Dashboard](admin.md) — Scaffold the admin UI, then add the description editor, logo upload, and table columns
+  - [3. Extending Core Models](extending-models.md) — Connect Brands to Products using a decorator and an association
+  - [4. API](api.md) — Expose Brands through the Store and Admin APIs — generated in one command, or hand-built to learn the pieces
+  - [5. Events & Webhooks](events.md) — React to store activity and connect external systems — OMS, warehouse, ERP
+  - [6. SDK](sdk.md) — Consume Brand endpoints from TypeScript using the SDK
+  - [7. Testing](testing.md) — Write automated tests for your feature

package/dist/developer/tutorial/model.md

@@ -1,41 +1,102 @@
 ---
 title: Model
-description: Learn how to create a database model for the Brands feature
+description: Create the Brand model — columns, rich text description, and logo upload — with a single generator command
 ---
 
-## Step 1: Create the Model and Database Migration
+In this step we'll create the `Spree::Brand` model with everything it needs: a `name` column, a rich text `description`, and an uploadable `logo`.
 
-To create a new model and database migration file, run the following command:
+## Step 1: Generate the Model
 
-```bash
-bin/rails g spree:model Spree::Brand name:string:index
+Spree ships a `spree:model` generator that produces a model and migration following all Spree conventions — `Spree::` namespacing, prefixed IDs, presence validations, and API filtering allowlists. It understands Rails attribute types including the virtual ones, so rich text and file attachments are part of the same command:
+
+
+```bash Spree CLI (Docker)
+spree generate model Brand name:string:index description:rich_text logo:attachment
+```
+
+```bash Without Spree CLI
+bin/rails g spree:model Brand name:string:index description:rich_text logo:attachment
 ```
 
-This will create a couple of files:
-- `app/models/spree/brand.rb` - the model file
-- `db/migrate/XXXXXXXXXXXXXX_create_spree_brands.rb` - the database migration file
 
-Now run the migration:
+> **INFO:** Throughout this tutorial every command is shown in two forms. **Spree CLI** is for projects created with [create-spree-app](../create-spree-app/quickstart.md), where the app runs in Docker and `spree <command>` routes into the container. **Without Spree CLI** is for apps running Spree backend directly on your machine.
+
+This creates two files:
+
+- `app/models/spree/brand.rb` — the model
+- `db/migrate/XXXXXXXXXXXXXX_create_spree_brands.rb` — the migration
+
+Now apply the migration:
+
 
-```bash
+```bash Spree CLI (Docker)
+spree migrate
+```
+
+```bash Without Spree CLI
 bin/rails db:migrate
 ```
 
-This will create the table `spree_brands` with the column `name` in the database. The `name` column is indexed for faster lookups. Also the model file `app/models/spree/brand.rb` is created.
 
-## Step 2: Extend the Model file
+This creates the `spree_brands` table with an indexed `name` column. The `description` and `logo` attributes don't add columns — rich text lives in Action Text's `action_text_rich_texts` table, and uploads live in Active Storage's tables.
 
-Now that the model file is created, let's add some additional functionality to it, starting with validations:
+## Step 2: Understand the Generated Model
 
-```ruby app/models/spree/brand.rb {3-4}
+Open `app/models/spree/brand.rb`:
+
+```ruby app/models/spree/brand.rb
 module Spree
-  class Brand < Spree::Base
-    # Validations
+  class Brand < Spree.base_class
+    has_prefix_id :brand
+
+    has_rich_text :description
+    has_one_attached :logo
+
     validates :name, presence: true
+
+    self.whitelisted_ransackable_attributes = %w[name]
+    self.whitelisted_ransackable_associations = %w[]
+    self.whitelisted_ransackable_scopes = %w[]
   end
 end
 ```
 
-This is a standard [Ruby on Rails ActiveRecord model](https://guides.rubyonrails.org/active_record_basics.html). Let's break down each part:
-- Inherits from `Spree::Base` to automatically inherit all Spree functionality. Also the model itself is namespaced under `Spree::` module, so it's available as `Spree::Brand` in the application.
-- `validates :name, presence: true` - using ActiveRecord validations to ensure that the name is present.
+Line by line:
+
+- **`Spree.base_class`** — inherits all Spree model functionality (multi-store scoping helpers, preferences, and more). The class is namespaced under `Spree::`, so it's available as `Spree::Brand`.
+- **`has_prefix_id :brand`** — records get Stripe-style public IDs like `brand_k5nR8xLq`. APIs never expose raw database IDs.
+- **`has_rich_text :description`** — formatted content via [Action Text](https://guides.rubyonrails.org/action_text_overview.html).
+- **`has_one_attached :logo`** — file uploads via [Active Storage](https://guides.rubyonrails.org/active_storage_overview.html), with image processing and direct-to-storage uploads.
+- **`validates :name, presence: true`** — generated automatically for required columns.
+- **`whitelisted_ransackable_attributes`** — controls which attributes API clients may filter and sort by. Only allowlisted attributes are queryable, so adding `name` here is what later makes `?q[name_cont]=nike` work.
+
+## Step 3: Try It in the Console
+
+
+```bash Spree CLI (Docker)
+spree console
+```
+
+```bash Without Spree CLI
+bin/rails console
+```
+
+
+```ruby
+brand = Spree::Brand.create!(name: "Wilson")
+brand.prefixed_id           # => "brand_k5nR8xLq"
+
+brand.update!(description: "<h1>Hello</h1><p>World</p>")
+brand.description.to_s             # => rendered rich text HTML
+brand.description.to_plain_text    # => "Hello World"
+
+Spree::Brand.find_by_prefix_id!("brand_k5nR8xLq")  # lookup by public ID
+```
+
+We'll upload the logo through the admin UI in the next step — the model side is already done.
+
+> **TIP:** The generator accepts more attribute types and options — references with auto-resolved class names (`user:belongs_to`), unique indexes (`slug:string:uniq`), soft delete (`--paranoid`), and custom fields support (`--metafields`). Run it with `--help` to see everything.
+
+## Next Step
+
+The model is complete. Now let's give admins a UI to manage brands: [Admin Dashboard](admin.md).

package/dist/developer/tutorial/sdk.md

@@ -3,9 +3,9 @@ title: SDK
 description: Use the TypeScript SDK to consume your custom Brand endpoints and extended Product data
 ---
 
-In this tutorial, we'll use the `@spree/sdk` TypeScript SDK to consume the Brand API endpoints we created in the [Store API tutorial](store-api.md), and work with the extended Product data that now includes brand information.
+In this tutorial, we'll use the `@spree/sdk` TypeScript SDK to consume the Brand API endpoints we created in the [API tutorial](api.md), and work with the extended Product data that now includes brand information.
 
-> **INFO:** This guide assumes you've completed the [Store API](store-api.md) tutorial and have the Brand endpoints running.
+> **INFO:** This guide assumes you've completed the [API](api.md) tutorial and have the Brand endpoints running.
 
 ## What We're Building
 
@@ -115,7 +115,7 @@ const full = await client.products.get(
 
 ### Filtering Products by Brand
 
-Ransack predicates work on whitelisted attributes and associations. The [Store API tutorial](store-api.md) shows how to register `brand_id` and `brand` via `Spree.ransack` — once that's done, you can filter:
+Ransack predicates work on whitelisted attributes and associations. The [API tutorial](api.md) shows how to register `brand_id` and `brand` via `Spree.ransack` — once that's done, you can filter:
 
 ```typescript
 // Products from a specific brand
@@ -164,6 +164,7 @@ products.data.forEach(p => {
 
 ## Related Documentation
 
-- [Store API Tutorial](store-api.md) - Creating the Brand API endpoints
+- [API Tutorial](api.md) - Creating the Brand API endpoints
 - [SDK Overview](/sdk) - Full SDK documentation
 - [Search & Filtering](../core-concepts/search-filtering.md) - Ransack predicates and sorting
+- [Agentic Development](../agentic/overview.md) - Agent skills and the docs MCP server cover the SDK patterns used here

package/dist/developer/tutorial/testing.md

@@ -7,30 +7,35 @@ Automated testing is a crucial part of the development process. It helps you ens
 Spree uses [RSpec](https://rspec.info), [Factory Bot](https://github.com/thoughtbot/factory_bot_rails), and [Capybara](https://github.com/teamcapybara/capybara) for testing.
 We also provide the `spree_dev_tools` gem that helps you write Spree-specific tests.
 
-> **INFO:** This guide assumes you've completed all previous tutorials through [Store API](store-api.md). You should have a complete `Spree::Brand` model with admin features and API endpoints.
+> **INFO:** This guide assumes you've completed all previous tutorials through [API](api.md). You should have a complete `Spree::Brand` model with admin features and API endpoints.
 
 ## Setup
 
-### Step 1: Set RSpec as the Test Framework
+**If your app came from [create-spree-app](../create-spree-app/quickstart.md) or [spree-starter](https://github.com/spree/spree-starter), the test environment is already set up** — RSpec, Factory Bot, Capybara, DatabaseCleaner, and the `spree_dev_tools` helpers (`stub_authorization!`, the `'API v3 Store'` shared context, Spree factories) ship preconfigured in `spec/support/`. Skip to creating the fixtures file below.
 
-```bash
-bin/rails g rspec:install
-```
+<details>
+<summary>Setting up an app that doesn't have RSpec yet</summary>
 
-### Step 2: Run the spree\_dev\_tools Generator
+For an existing Rails app without test setup, install RSpec and the Spree test helpers:
 
-```bash
+
+```bash Spree CLI (Docker)
+spree generate rspec:install
+spree generate spree_dev_tools:install
+```
+
+```bash Without Spree CLI
+bin/rails g rspec:install
 bin/rails g spree_dev_tools:install
 ```
 
-This adds Spree-specific test helpers to your `spec/support/` directory, including:
 
-* Authorization helpers (`stub_authorization!`)
-* Factory Bot configuration
-* Capybara setup for feature tests
-* and more…
+The `spree_dev_tools` generator adds the Spree-specific helpers to `spec/support/`: authorization helpers (`stub_authorization!`), Factory Bot configuration, Capybara setup for feature tests, and more.
+
+</details>
 
-### Step 3: Create the Fixtures Directory and File
+
+### Create the Fixtures Directory and File
 
 When writing tests that involve file attachments (like images, PDFs, etc.), you need fixture files that your factories can use. Here's how to set them up.
 
@@ -38,13 +43,11 @@ When writing tests that involve file attachments (like images, PDFs, etc.), you
 mkdir -p spec/fixtures/files && printf '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18\xd8N\x00\x00\x00\x00IEND\xaeB`\x82' > spec/fixtures/files/logo.png
 ```
 
-### Step 4: Generate Test Files
+### What the generators already created
 
-```bash
-bin/rails g rspec:model Spree::Brand
-```
+If you used `spree generate api_resource` in the [API step](api.md), you already have controller specs (`spec/controllers/spree/api/v3/store/brands_controller_spec.rb` and `…/admin/brands_controller_spec.rb`) and a factory (`spec/factories/spree/brand_factory.rb`). The sections below build the same things by hand — compare as you go, and keep whichever you prefer.
 
-This creates `spec/models/spree/brand_spec.rb`.
+For the model spec, create `spec/models/spree/brand_spec.rb` — we'll fill it in below.
 
 ## Writing Factories
 
@@ -213,10 +216,11 @@ Controller tests verify that your endpoints respond correctly and perform the ex
 
 ### Store API Controller Tests
 
-Test the API endpoints we created in the [Store API tutorial](store-api.md). Store API tests use the `'API v3 Store'` shared context which sets up a store, publishable API key, and JWT tokens.
+Test the API endpoints we created in the [API tutorial](api.md). Store API tests use the `'API v3 Store'` shared context which sets up a store, publishable API key, and JWT tokens — it ships in the `spree_api` gem, so require `spree/api/testing_support/v3/base` at the top of the spec.
 
 ```ruby spec/controllers/spree/api/v3/store/brands_controller_spec.rb
 require 'rails_helper'
+require 'spree/api/testing_support/v3/base'
 
 RSpec.describe Spree::Api::V3::Store::BrandsController, type: :controller do
   render_views
@@ -320,6 +324,7 @@ Test that the custom Product serializer includes brand data:
 
 ```ruby spec/controllers/spree/api/v3/store/products_brand_spec.rb
 require 'rails_helper'
+require 'spree/api/testing_support/v3/base'
 
 RSpec.describe Spree::Api::V3::Store::ProductsController, type: :controller do
   render_views
@@ -582,23 +587,35 @@ expect(page).to have_content('Success!')
 
 ## Running Tests
 
-```bash
-# Run all tests
-bundle exec rspec
+In the Docker flow the container's `DATABASE_URL` points at the development database, so tests need two overrides: a dedicated test database, and DatabaseCleaner's opt-in for non-localhost database hosts (its safeguard against cleaning a database it doesn't own). One-time test database setup:
 
-# Run specific test file
-bundle exec rspec spec/models/spree/brand_spec.rb
+```bash Spree CLI (Docker) — one-time setup
+spree exec env RAILS_ENV=test DATABASE_URL=postgres://postgres@postgres:5432/spree_test bin/rails db:prepare
+```
 
-# Run specific test
-bundle exec rspec spec/models/spree/brand_spec.rb:15
+Then run tests:
 
-# Run with documentation format
-bundle exec rspec --format documentation
 
-# Run only feature tests
-bundle exec rspec spec/features/
+```bash Spree CLI (Docker)
+# Define once per shell (or add as an alias):
+alias spree-rspec='spree exec env RAILS_ENV=test DATABASE_URL=postgres://postgres@postgres:5432/spree_test DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL=true bundle exec rspec'
+
+spree-rspec                                      # all tests
+spree-rspec spec/models/spree/brand_spec.rb      # specific file
+spree-rspec spec/models/spree/brand_spec.rb:15   # specific test
+spree-rspec --format documentation               # documentation format
+spree-rspec spec/features/                       # only feature tests
+```
+
+```bash Without Spree CLI
+bundle exec rspec                                      # all tests
+bundle exec rspec spec/models/spree/brand_spec.rb      # specific file
+bundle exec rspec spec/models/spree/brand_spec.rb:15   # specific test
+bundle exec rspec --format documentation               # documentation format
+bundle exec rspec spec/features/                       # only feature tests
 ```
 
+
 ## Best Practices
 
 
@@ -659,7 +676,7 @@ spec/
 * [Model Tutorial](model.md) - Creating the Brand model
 * [Admin Tutorial](admin.md) - Building the admin interface
 * [Extending Core Models](extending-models.md) - Connecting Brands to Products
-* [Store API Tutorial](store-api.md) - Creating Brand API endpoints
+* [API Tutorial](api.md) - Creating Brand API endpoints
 * [RSpec Documentation](https://rspec.info/documentation/) - Official RSpec docs
 * [Factory Bot Documentation](https://github.com/thoughtbot/factory_bot/blob/main/GETTING_STARTED.md) - Factory Bot guide
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spree/docs",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "Spree Commerce developer documentation for AI agents and local reference",
   "type": "module",
   "license": "CC-BY-4.0",

package/dist/developer/tutorial/file-uploads.md

@@ -1,121 +0,0 @@
----
-title: File Uploads
-description: Learn how to add file uploads to the Brands feature
----
-
-> **INFO:** This guide assumes you've completed the [Model](model.md), [Admin](admin.md), and [Rich Text](rich-text.md) tutorials.
-
-In this tutorial, we'll add a logo image upload to our Brand model. Spree uses [Rails Active Storage](https://guides.rubyonrails.org/active_storage_overview.html) for handling file attachments, image processing, and storage.
-
-## Step 1: Add Attachment to the Model
-
-First, let's add a logo attachment to the Brand model:
-
-```ruby app/models/spree/brand.rb {3}
-module Spree
-  class Brand < Spree::Base
-    has_one_attached :logo
-
-    # ... existing code ...
-  end
-end
-```
-
-## Step 2: Permit the Attachment Attribute
-
-For the admin form to accept the file upload, we need to permit the `logo` attribute in the controller.
-
-Update your brands controller:
-
-```ruby app/controllers/spree/admin/brands_controller.rb {10}
-module Spree
-  module Admin
-    class BrandsController < ResourceController
-      private
-
-      def permitted_resource_params
-        params.require(:brand).permit(
-          :name,
-          :description,
-          :logo
-        )
-      end
-    end
-  end
-end
-```
-
-## Step 3: Add File Upload Field to the Admin Form
-
-Now let's add the file upload field to the brand form. Spree provides a `spree_file_field` helper that handles everything including:
-
-- Drag and drop upload
-- Image preview
-- Direct upload to storage
-- Optional image cropping
-
-Update your brand form partial:
-
-```erb app/views/spree/admin/brands/_form.html.erb {11-19}
-<div class="card mb-6">
-  <div class="card-header">
-    <h5 class="card-title"><%= Spree.t(:general_settings) %></h5>
-  </div>
-  <div class="card-body">
-    <%= f.spree_text_field :name, required: true %>
-    <%= f.spree_rich_text_area :description %>
-  </div>
-</div>
-
-<div class="card mb-6">
-  <div class="card-header">
-    <h5 class="card-title"><%= Spree.t(:logo) %></h5>
-  </div>
-  <div class="card-body">
-    <%= f.spree_file_field :logo, width: 300, height: 300 %>
-  </div>
-</div>
-```
-
-### Add cropping functionality
-
-To enable cropping functionality, add the `crop: true` option to the `spree_file_field` helper.
-
-## Step 4: Display the Logo in the Index Table
-
-Let's show a thumbnail of the brand logo in the admin index view.
-
-Update the table header partial:
-
-```erb app/views/spree/admin/brands/_table_header.html.erb {2}
-<tr>
-  <th><%= Spree.t(:logo) %></th>
-  <th><%= Spree.t(:name) %></th>
-  <th></th>
-</tr>
-```
-
-Update the table row partial to display the logo:
-
-```erb app/views/spree/admin/brands/_table_row.html.erb {3-12}
-<tr id="<%= spree_dom_id brand %>" class="cursor-pointer" data-controller="row-link">
-  <td data-action="click->row-link#openLink" class="w-70">
-    <div class="d-flex align-items-center gap-2">
-      <% if brand.logo.attached? %>
-        <%= spree_image_tag brand.logo, width: 48, height: 48, class: 'rounded' %>
-      <% else %>
-        <div class="bg-light rounded d-flex align-items-center justify-content-center" style="width: 48px; height: 48px;">
-          <%= icon('photo-off', class: 'text-muted') %>
-        </div>
-      <% end %>
-      <span class="font-weight-bold"><%= brand.name %></span>
-    </div>
-  </td>
-  <td data-action="click->row-link#openLink" class="w-20">
-    <%= spree_date(brand.created_at) %>
-  </td>
-  <td class="actions w-10">
-    <%= link_to_edit(brand, data: { row_link_target: :link, turbo_frame: '_top' }) if can? :edit, brand %>
-  </td>
-</tr>
-```

package/dist/developer/tutorial/rich-text.md

@@ -1,73 +0,0 @@
----
-title: Rich Text
-description: Learn how to add rich text content to the Brands feature using Action Text
----
-
-> **INFO:** This guide assumes you've completed the [Model](model.md) and [Admin](admin.md) tutorials.
-
-Our Brand model has a `name` attribute to store the brand name. However it's missing a description. That's because we're going to use [Action Text](https://guides.rubyonrails.org/action_text_overview.html) to handle the rich text content.
-
-## Step 1: Add Action Text to the Model
-
-```ruby app/models/spree/brand.rb {4-5}
-module Spree
-  class Brand < Spree::Base
-    # Action text for rich text content
-    has_rich_text :description
-
-    # ... other code ...
-  end
-end
-```
-
-You don't need to run any migrations, as we won't be adding any new columns to the `spree_brands` table. That's because [Action Text](https://guides.rubyonrails.org/action_text_overview.html) stores all the rich text content in a separate table called `action_text_rich_texts`.
-
-You can access the description content in code like this:
-
-```ruby
-brand.description.to_s
-# => "<h1>Hello</h1><p>World</p>"
-```
-
-Or if you prefer plain text:
-
-```ruby
-brand.description.to_plain_text
-# => "Hello World"
-```
-
-## Step 2: Add a WYSIWYG editor to the Admin Dashboard
-
-In the Admin dashboard we want to use a WYSIWYG editor to add formatted text to the brand description. To do this, edit the `app/views/spree/admin/brands/_form.html.erb` file and add the following code:
-
-```erb app/views/spree/admin/brands/_form.html.erb {4}
-<div class="card mb-6">
-  <div class="card-body">
-    <%= f.spree_text_field :name %>
-    <%= f.spree_rich_text_area :description %>
-  </div>
-</div>
-```
-
-This will render a WYSIWYG editor to the brand description field in the Admin dashboard.
-
-## Step 3: Update permitted parameters in controller
-
-To permit the `description` attribute to be saved, we need to update the permitted parameters in the controller file and add the following code:
-
-```ruby app/controllers/spree/admin/brands_controller.rb {9}
-module Spree
-  module Admin
-    class BrandsController < ResourceController
-      private
-
-      def permitted_resource_params
-        params.require(:brand).permit(
-          :name,
-          :description
-        )
-      end
-    end
-  end
-end
-```