@spree/docs 0.1.0

package/dist/developer/create-spree-app/quickstart.md

@@ -0,0 +1,158 @@
+---
+title: "create-spree-app"
+sidebarTitle: Overview
+description: "Scaffold a new Spree Commerce project with a single command. Includes a full Rails backend app for customization."
+---
+
+## Quick Start
+
+```bash
+npx create-spree-app@latest my-store
+```
+
+The CLI walks you through an interactive setup:
+
+1. Include **Next.js Storefront** (default: yes)
+2. Optionally load **sample data** (products, categories, images)
+3. Optionally **start Docker services** immediately
+
+Once complete, your store is running at [http://localhost:3000](http://localhost:3000).
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) 20 or later
+- [Docker](https://docs.docker.com/get-docker/) (for running the Spree backend, PostgreSQL, and Redis)
+
+## CLI Flags
+
+All prompts can be skipped with flags for non-interactive (CI/CD) usage:
+
+```bash
+npx create-spree-app@latest my-store --no-storefront --no-sample-data --no-start
+```
+
+| Flag | Description |
+|------|-------------|
+| `--no-storefront` | Skip Next.js storefront setup |
+| `--no-sample-data` | Skip loading sample products and categories |
+| `--no-start` | Don't start Docker services after scaffolding |
+| `--port <number>` | Port for the Spree backend (default: `3000`) |
+| `--use-npm` | Use npm as package manager |
+| `--use-yarn` | Use yarn as package manager |
+| `--use-pnpm` | Use pnpm as package manager |
+
+> **TIP:** The package manager is auto-detected from how you run the command. If you use `pnpm dlx create-spree-app`, pnpm will be used automatically.
+
+> **TIP:** If the default port is already in use, the CLI will automatically find a free port and let you know.
+
+## Generated Project Structure
+
+```text
+my-store/
+├── docker-compose.yml        # Spree backend (prebuilt image) + Postgres + Redis
+├── docker-compose.dev.yml    # Alternative: build from local backend/
+├── .env                      # SECRET_KEY_BASE, SPREE_PORT
+├── .gitignore
+├── package.json              # Convenience scripts
+├── README.md
+├── backend/                  # Full Rails app (from spree/spree-starter)
+│   ├── Gemfile
+│   ├── Dockerfile
+│   ├── config/
+│   ├── app/
+│   └── ...
+└── apps/
+    └── storefront/           # Next.js storefront (unless --no-storefront)
+        ├── .env.local        # API URL + API key
+        └── ...
+```
+
+### What's in docker-compose.yml
+
+- **Spree** — runs the `ghcr.io/spree/spree:latest` image on the configured port (default `3000`)
+- **PostgreSQL 18** — database with persistent volume
+- **Redis 7** — caching, background jobs, and Action Cable
+- **Mailpit** — local email inbox at [http://localhost:8025](http://localhost:8025)
+- Health checks on all services
+
+## Customizing the Backend
+
+The `backend/` directory contains a full Rails application with Spree installed (cloned from [spree-starter](https://github.com/spree/spree-starter)). By default, the project uses a prebuilt Docker image. To switch to building from your local backend:
+
+```bash
+npx spree eject
+```
+
+This replaces `docker-compose.yml` with a version that builds from `backend/`, rebuilds the image, and restarts services. You can then:
+
+- **Add gems** to `backend/Gemfile`
+- **Override models** with decorators in `backend/app/models/`
+- **Add controllers** in `backend/app/controllers/`
+- **Configure Spree** in `backend/config/initializers/spree.rb`
+- **Add migrations** with `cd backend && bin/rails generate migration`
+
+See the [Customization Guide](/developer/customization) for more details.
+
+### Spree CLI Commands
+
+The project includes [@spree/cli](/developer/cli/quickstart) for managing your Spree backend:
+
+| Command | Description |
+|---------|-------------|
+| `spree dev` | Start backend services and stream logs |
+| `spree stop` | Stop backend services |
+| `spree update` | Pull latest Spree image and restart (runs migrations automatically) |
+| `spree eject` | Switch from prebuilt image to building from `backend/` |
+| `spree logs` | View backend logs |
+| `spree logs worker` | View background jobs logs |
+| `spree console` | Rails console |
+
+## After Setup
+
+### Admin Dashboard
+
+Open [http://localhost:3000/admin](http://localhost:3000/admin) and log in with:
+
+| | |
+|---|---|
+| **Email** | `spree@example.com` |
+| **Password** | `spree123` |
+
+### Store API
+
+The REST API is available at [http://localhost:3000/api/v3/store](http://localhost:3000/api/v3/store). See the [API Reference](/api-reference) for details.
+
+### Storefront
+
+If you included the storefront, start it in a separate terminal:
+
+```bash
+cd my-store/apps/storefront
+npm run dev
+```
+
+Open [http://localhost:3001](http://localhost:3001) to see your store.
+
+## Updating Spree
+
+To update to the latest Spree version:
+
+```bash
+spree update
+```
+
+This pulls the latest Docker image and recreates the containers. The entrypoint automatically runs database migrations.
+
+To pin a specific version, edit `SPREE_VERSION_TAG` in `.env`:
+
+```
+SPREE_VERSION_TAG=5.4
+```
+
+## Next Steps
+
+
+  - [Next.js Storefront](/developer/storefront/nextjs/quickstart) — Customize and extend the Storefront
+  - [Spree SDK](/developer/sdk/quickstart) — TypeScript SDK for the Store and Admin APIs
+  - [API Reference](/api-reference) — Explore the REST API endpoints
+  - [Core Concepts](/developer/core-concepts/architecture) — Learn about Spree's architecture

package/dist/developer/customization/api.md

@@ -0,0 +1,93 @@
+---
+title: API
+description: >-
+  This page covers adding new Spree API endpoints and customization of
+  existing ones
+---
+
+Before you start customizing Spree API endpoints, make sure you reviewed all existing API endpoints in the [Spree API docs](/api-reference).
+
+## Customizing JSON response
+
+Spree uses a library called [JSON API serializers](https://github.com/jsonapi-serializer/jsonapi-serializer) to represent data returned by API endpoints.
+
+You can easily replace existing Spree serializers with your own thanks to [Spree Dependencies](dependencies). Here's a list of all serializers that you can override:
+
+| Key                                      | Value                                               |
+|------------------------------------------|-----------------------------------------------------|
+| `storefront_address_serializer`            | [Spree::V2::Storefront::AddressSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/address_serializer.rb)          |
+| `storefront_cart_serializer`               | [Spree::V2::Storefront::CartSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/cart_serializer.rb)             |
+| `storefront_credit_card_serializer`        | [Spree::V2::Storefront::CreditCardSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/credit_card_serializer.rb)       |
+| `storefront_country_serializer`            | [Spree::V2::Storefront::CountrySerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/country_serializer.rb)          |
+| `storefront_user_serializer`               | [Spree::V2::Storefront::UserSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/user_serializer.rb)             |
+| `storefront_shipment_serializer`           | [Spree::V2::Storefront::ShipmentSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/shipment_serializer.rb)         |
+| `storefront_taxon_serializer`              | [Spree::V2::Storefront::TaxonSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/taxon_serializer.rb)            |
+| `storefront_payment_method_serializer`     | [Spree::V2::Storefront::PaymentMethodSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/payment_method_serializer.rb)    |
+| `storefront_payment_serializer`            | [Spree::V2::Storefront::PaymentSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/payment_serializer.rb)          |
+| `storefront_product_serializer`            | [Spree::V2::Storefront::ProductSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/product_serializer.rb)          |
+| `storefront_estimated_shipment_serializer` | [Spree::V2::Storefront::EstimatedShippingRateSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/estimated_shipping_rate_serializer.rb) |
+| `storefront_store_serializer`              | [Spree::V2::Storefront::StoreSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/store_serializer.rb)            |
+| `storefront_order_serializer`              | [Spree::V2::Storefront::OrderSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/order_serializer.rb)            |
+| `storefront_variant_serializer`            | [Spree::V2::Storefront::VariantSerializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/variant_serializer.rb)          |
+
+### Adding custom attributes
+
+> **NOTE:** As a rule of thumb it's recommended to use [Properties](/developer/core-concepts/products#product-properties) and [OptionTypes/Option Values](/developer/core-concepts/products#option-types-and-option-values) for custom attributes and not to modify the Spree database schema
+
+Let's say you want to customize the Storefront API's [Product serializer](https://github.com/spree/spree/blob/main/api/app/serializers/spree/v2/storefront/product_serializer.rb) to include you custom database column `my_newcustom_attribute` that you've added to the `spree_products` database table.
+
+Let's start with creating a new serializer file:
+
+```bash
+mkdir -p app/serializers && touch app/serializers/my_product_serializer.rb
+```
+
+Place the following code in your new serializer file:
+
+```ruby
+class MyProductSerializer < Spree::V2::Storefront::ProductSerializer
+  attribute :my_new_custom_attribute
+end
+```
+
+> **INFO:** This serializer will inherit from the `Spree::V2::Storefront::ProductSerializer` serializer, so you don't need to rewrite the whole serializer.
+
+Now let's tell Spree to use this new serializer, in `config/initializers/spree.rb` please set:
+
+```ruby
+Spree::Api::Dependencies.storefront_product_serializer = 'MyProductSerializer'
+```
+
+Restart the webserver and hit the [Products API](/api-reference/storefront/products/list-all-products) to notice that the payload now includes your new attribute.
+
+### Adding a new association
+
+Let's say you've created a new model called `Video` that belongs to `Product` (_Product has multiple Videos_).
+
+Let's create a new serializer `app/serializers/video_serializer.rb`:
+
+```ruby
+class VideoSerializer < Spree::Api::V2::BaseSerializer
+  set_type: :video
+  
+  attributes :url
+end
+```
+
+Now in your `app/serializers/my_product_serializer.rb`
+
+```ruby
+class MyProductSerializer < Spree::V2::Storefront::ProductSerializer
+  attribute :my_new_custom_attribute
+  
+  has_many :videos, serializer: :video
+end
+```
+
+Hitting the Products API you will notice that in the [relationships](https://jsonapi.org/format/#document-resource-object-relationships) key there will be a new key called `videos`
+
+To include Video response in the Product API add `?includes=videos` in the API URL, eg.
+
+```http
+GET https://localhost:3000/api/v2/storefront/products?include=videos
+```

package/dist/developer/customization/authentication.md

@@ -0,0 +1,88 @@
+---
+title: Authentication
+description: Learn how to use a custom authentication setup with Spree
+version: v5
+---
+
+If you installed Spree following the [Quickstart guide](/developer/quickstart), you can completely skip this step - you are all set and integrated with the [Devise](https://github.com/plataformatec/devise) gem.
+
+However if you're adding Spree to an existing application that has its own authentication system, you will need to follow these steps.
+
+## Using Devise
+
+If you're currently using [Devise](https://github.com/plataformatec/devise) for authentication, you can follow the steps below to integrate Spree with your existing authentication system.
+
+Firstly set your `User` class as `Spree.user_class` in your `config/initializers/spree.rb` file:
+
+```ruby
+Spree.user_class = 'User'
+```
+
+Now, run the generator to setup Spree integration with Devise:
+
+```bash
+bin/rails g spree:authentication:devise
+```
+
+This will create the a new file in `lib/spree/authentication_helpers.rb` that serves as a bridge between Spree and your existing authentication system routes. You can then use this file to customize the routes to your liking. It should automatically pick up standard Devise routes.
+
+Secondly, this generator will add necessary modules to your `User` model.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  # ... your existing code ...
+
+  include Spree::UserAddress
+  include Spree::UserMethods
+  include Spree::UserPaymentSource
+end
+```
+
+This will ensure that your `User` model can be used as a Spree user.
+
+This generator will also add 2 new lines to your Spree initializer file:
+
+```ruby
+Devise.parent_controller = "Spree::BaseController"
+Devise.parent_mailer = "Spree::BaseMailer"
+```
+
+This ensures that Devise will use Spree storefront layout for login/signup/etc and use Spree mailer layout for sending emails so they'll match your Storefront branding.
+
+If you have more complex setup, you can remove these lines and customize the routes and mailer in your own initializer file.
+
+## Using Custom Authentication
+
+If you're using a custom authentication system, you can follow the steps below to integrate Spree with your existing authentication system.
+
+Firstly set your `User` class as `Spree.user_class` in your `config/initializers/spree.rb` file:
+
+```ruby
+Spree.user_class = 'User'
+```
+
+Now, run the generator to setup Spree integration with your custom authentication system:
+
+```bash
+bin/rails g spree:authentication:custom
+```
+
+This will create the a new file in `lib/spree/authentication_helpers.rb` that serves as a bridge between Spree and your existing authentication system routes. You will need to customize this file to fit your needs.
+
+Secondly, this generator will add necessary modules to your `User` model.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  # ... your existing code ...
+
+  include Spree::UserAddress
+  include Spree::UserMethods
+  include Spree::UserPaymentSource
+end
+```
+
+## Admin Panel authentication
+
+Please refer to the [Admin Panel Authentication](/developer/admin/authentication) page for more details.

package/dist/developer/customization/checkout.md

@@ -0,0 +1,204 @@
+---
+title: Checkout Flow
+description: Learn how to customize the checkout process in Spree.
+version: v5
+---
+
+## Overview
+
+The Spree checkout process has been designed for maximum flexibility. It's been redesigned several times now, each iteration has benefited from the feedback of real-world deployment experience. It is relatively simple to customize the checkout process to suit your needs. Secure transmission of customer information is possible via SSL and credit card information is never stored in the database.
+
+## The Checkout Flow DSL
+
+Spree comes with a new checkout DSL that allows you succinctly define the different steps of your checkout. This new DSL allows you to customize _just_ the checkout flow, while maintaining the unrelated admin states, such as "canceled" and "resumed", that an order can transition to. Ultimately, it provides a shorter syntax compared with overriding the entire state machine for the `Spree::Order` class.
+
+The default checkout flow for Spree is defined like this, adequately demonstrating the abilities of this new system:
+
+```ruby
+checkout_flow do
+  go_to_state :address
+  go_to_state :delivery
+  go_to_state :payment, if: ->(order) {
+    order.update_totals
+    order.payment_required?
+  }
+  go_to_state :confirm, if: ->(order) { order.confirmation_required? }
+  go_to_state :complete
+  remove_transition from: :delivery, to: :confirm
+```
+
+we can pass a block on each checkout step definition and work some logic to figure if the step is required dynamically. e.g. the confirm step might only be necessary for payment gateways that support payment profiles.
+
+These conditional states present a situation where an order could transition from delivery to one of payment, confirm or complete. In the default checkout, we never want to transition from delivery to confirm, and therefore have removed it using the `remove_transition` method of the Checkout DSL. The resulting transitions between states look like the image below:
+
+These two helper methods are provided on `Spree::Order` instances for your convenience:
+
+* `checkout_steps` - returns a list of all the potential states of the checkout.
+* `has_step?` - Used to check if the current order fulfills the requirements for a specific state.
+
+If you want a list of all the currently available states for the checkout, use the `checkout_steps` method, which will return the steps in an array.
+
+## Default Checkout Steps
+
+The Spree checkout process consists of the following steps. With the exception of the Registration step, each of these steps corresponds to a state of the [Order object](/developer/core-concepts/orders):
+
+* Shipping Address and Contact Information
+* Delivery Options Shipping Method
+* Payment and Billing Information
+* Confirmation (optional)
+
+The following sections will provide a walk-through of checkout from a user's perspective, and offer some information on how to configure the default behavior of the various steps.
+
+### Shipping Address and Contact Information
+
+This step allows the customer to add shipping information and contact information. Customers have also option to sign in or create an account. For payment methods such as Stripe customers can use quick checkout option via payment wallets such as Apple Pay, Google Pay, etc and skip the rest of the checkout process.
+
+The address fields include a select box for choosing state/province. If there are no states configured for a particular country, the select box will be replaced by a text field instead.
+
+The list of countries that appear in the country select box can also be configured. Spree will list all countries by default, but you can configure exactly which countries you would like to appear. The list can be limited to a specific set of countries by [setting the Store's checkout zone](/developer/core-concepts/stores#checkout-configuration).
+
+### Delivery Options
+
+During this step, the user may choose a delivery method. Spree assumes the list of shipping methods to be dependent on the shipping address. If there are multiple shipments eg. different Stock Locations or Vendors, the user will be asked to select shipping method for each shipment.
+
+### Payment
+
+This step is where the customer provides payment and billing information. Spree does not store any payment information in the database. For payment methods such as Stripe, we use Stripe JavaScript SDKs to render their payment form inside the checkout page, fully compliant with PCI DSS standards.
+
+Besides Credit Card, Wallets and other 3rd party payment methods, Spree also supports Store Credit and Gift Cards (Spree 5.1+ only) which can be used to pay for the entire order or part of the order.
+
+For more information about payments, please see the [Payments guide](/developer/core-concepts/payments).
+
+### Confirmation
+
+This is the final opportunity for the customer to review their order before submitting it to be processed. Users have the opportunity to return to any step in the process using either the back button or by clicking on the appropriate step in the "progress breadcrumb."
+
+This step is disabled by default, but can be enabled by two ways:
+
+1. globally for all orders by setting a preference in `config/initializers/spree.rb`:
+
+    ```ruby config/initializers/spree.rb
+    Spree::Config[:always_include_confirm_step] = true
+    ```
+
+2. conditionally for specific orders by overriding the `confirmation_required?` method in `Spree::Order` with a [decorator](/developer/customization/decorators), eg.
+
+    ```ruby app/models/spree/order_decorator.rb
+    module Spree
+      module OrderDecorator
+        # require confirmation for orders with a US billing address
+        def confirmation_required?
+          billing_address&.country_iso == 'US'
+        end
+      end
+    end
+    ```
+
+## Adding Logic Before or After a Particular Step
+
+There are two approaches for adding logic around checkout state transitions:
+
+### Approach 1: Events Subscribers (Recommended for side effects)
+
+For actions that should happen **after** a checkout step completes (syncing with external services, sending notifications, logging, etc.), use [Events subscribers](/developer/core-concepts/events). This is the recommended approach because it keeps your code decoupled from Spree internals.
+
+```ruby app/subscribers/my_app/order_completed_subscriber.rb
+module MyApp
+  class OrderCompletedSubscriber < Spree::Subscriber
+    subscribes_to 'order.completed'
+
+    def handle(event)
+      order = Spree::Order.find_by(id: event.payload['id'])
+      return unless order
+
+      # Sync to fulfillment system, notify warehouse, etc.
+      FulfillmentService.notify(order)
+      AnalyticsService.track_purchase(order)
+    end
+  end
+end
+```
+
+> **INFO:** Events are fired automatically when orders change state. See [Events documentation](/developer/core-concepts/events#order-events) for all available order events.
+
+### Approach 2: State Machine Callbacks (For validation/blocking logic)
+
+The [state_machines](https://github.com/state-machines/state_machines) gem allows you to implement callbacks that can **block** transitions. Use this approach only when you need to prevent a transition based on validation logic.
+
+For example, if you wanted to verify that the user provides a valid zip code before transitioning to the delivery step:
+
+```ruby app/models/spree/order_decorator.rb
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.state_machine.before_transition to: :delivery, do: :valid_zip_code?
+    end
+
+    def valid_zip_code?
+      # Return false to prevent the transition
+      ship_address&.zipcode&.match?(/^\d{5}(-\d{4})?$/)
+    end
+  end
+
+  Order.prepend(OrderDecorator)
+end
+```
+
+This callback would prevent transitioning to the `delivery` step if `valid_zip_code?` returns false.
+
+> **WARNING:** Avoid using state machine callbacks for side effects like API calls or notifications. These can slow down checkout and may fail silently. Use [Events subscribers](/developer/core-concepts/events) instead.
+
+## Modifying the checkout flow
+
+To add or remove steps to the checkout flow, you can use the 
+[insert_checkout_step](https://github.com/spree/spree/blob/a39ed2b69f1f2b2f413b7f46090bd0deeb439d61/core/app/models/spree/order/checkout.rb#L138) and [remove_checkout_step](https://github.com/spree/spree/blob/a39ed2b69f1f2b2f413b7f46090bd0deeb439d61/core/app/models/spree/order/checkout.rb#L157) helpers respectively.
+
+The `insert_checkout_step` method takes a `before` or `after` option to determine where to insert the step:
+
+```ruby app/models/spree/order_decorator.rb
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.insert_checkout_step :new_step, before: :address
+      # or
+      # base.insert_checkout_step :new_step, after: :address
+    end
+  end
+
+  Order.prepend(OrderDecorator)
+end
+```
+
+The `remove_checkout_step` will remove just one checkout step at a time:
+
+```ruby app/models/spree/order_decorator.rb
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.remove_checkout_step :address
+      base.remove_checkout_step :delivery
+    end
+  end
+
+  Order.prepend(OrderDecorator)
+end
+```
+
+What will happen here is that when a user goes to checkout, they will be asked to potentially fill in their payment details and then potentially confirm the order. This is the default behavior of the payment and the confirm steps within the checkout. If they are not required to provide payment or confirmation for this order then checking out this order will result in its immediate completion.
+
+To completely re-define the flow of the checkout, use the `checkout_flow` helper:
+
+```ruby app/models/spree/order_decorator.rb
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.checkout_flow do
+        go_to_state :payment
+        go_to_state :complete
+      end
+    end
+  end
+
+  Order.prepend(OrderDecorator)
+end
+```

package/dist/developer/customization/configuration.md

@@ -0,0 +1,55 @@
+---
+title: "Configuration"
+---
+
+Here is a list of all the configuration options that are available in Spree.
+
+ | Configuration Key                  | Description                                                                                           | Default Value       |
+      |------------------------------------|-------------------------------------------------------------------------------------------------------|---------------------|
+      | `allow_checkout_on_gateway_error`  | Continues the checkout process even if the payment gateway error failed.                             | `false`             |
+      | `address_requires_phone`            | Determines whether a phone number is required for Addresses. | `false`              |
+      | `alternative_shipping_phone`       | Determines if an alternative phone number should be present for the shipping address on the checkout page. | `false`         |
+      | `always_include_confirm_step`      | Determines if the confirmation step is always included in the checkout process, regardless of the payment method. | `false`             |
+      | `auto_capture`                     | Depending on whether or not Spree is configured to "auto capture" the credit card, either a purchase or an authorize operation will be performed on the card (via the current credit card gateway). | `true` |
+      | `auto_capture_on_dispatch`         | Captures payment for each shipment in Shipment#after_ship callback, and makes Shipment.ready when payment authorized. | `false` |
+      | `company`                          | Determines whether or not a field for "Company" displays on the address form. | `false`            |
+      | `credit_to_new_allocation`         | Determines if a new allocation is created anytime store credit is added. If not set, it will update the store credit's amount in place. | `false`             |
+      | `disable_sku_validation`             | Determines if the built-in SKU uniqueness validation is disabled. | `false`             |
+      | `disable_store_presence_validation` | Determines if Store presence validation for Products and Payment Methods is disabled. | `false`             |
+      | `expedited_exchanges`               | Determines if an exchange shipment is kicked off upon return authorization save. Requires payment profiles to be supported on your gateway and a configured delayed job handler. | `false`             |
+      | `expedited_exchanges_days_window`   | The number of days the customer has to return their item after the expedited exchange is shipped to avoid being charged. | `14`                |
+      | `restock_inventory`                 | Determines if inventory should be restocked when an order is canceled or returned                              | `true`              |
+      | `return_eligibility_number_of_days` | The number of days after purchase within which a return can be initiated. | `365` |
+      | `show_products_without_price`      | Determines if products without a price are shown in the storefront and Storefront API | `false`             |
+      | `tax_using_ship_address`           | Determines if tax information should be based on shipping address, rather than the billing address.  | `true`              |
+      | `track_inventory_levels`           | Determines if inventory levels should be tracked when products are purchased at checkout. This option causes new `InventoryUnit` objects to be created when a product is bought. | `true` |
+
+## Spree Initializer
+
+To change values for these preferences, you need to edit your `config/initializers/spree.rb` file.
+
+For example, to disable the `expedited_exchanges` feature, you would add the following line:
+
+```ruby
+Spree.config do |config|
+  config.expedited_exchanges = false
+end
+```
+
+> **NOTE:** Remember to restart your Rails server after making changes to the `config/initializers/spree.rb` file.
+
+## Accessing Configuration
+
+To access these preferences in your application, you can use the `Spree::Config` module. For example, to access the `expedited_exchanges` preference, you can do the following:
+
+```ruby
+Spree::Config.expedited_exchanges
+```
+
+This will return the current value of the `expedited_exchanges` preference. You can also set the value of a preference using the `Spree::Config` module. For example, to set the `expedited_exchanges` preference to `true`, you can do the following:
+
+```ruby
+Spree::Config.expedited_exchanges = true
+```
+
+This will set the `expedited_exchanges` preference to `true` for the current process. After restarting the Rails server, the preference will return to the default value or the one set in the initializer.