Skip to content

armgit / spree

Public Imported from GitHub
0

Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.

Admin Records List component (initial pass)

Damian Legawiec3a600db8abf6
diff --git a/admin/app/controllers/spree/admin/record_list_columns_controller.rb b/admin/app/controllers/spree/admin/record_list_columns_controller.rb
new file mode 100644
index 0000000000..37fa106b44
--- /dev/null
+++ b/admin/app/controllers/spree/admin/record_list_columns_controller.rb
@@ -0,0 +1,28 @@
+module Spree
+ module Admin
+ class RecordListColumnsController < Spree::Admin::BaseController
+ # POST /admin/record_list_columns
+ # Updates the selected columns for a record list in the session
+ def update
+ list_key = params[:list_key]
+ columns = params[:columns]
+
+ if list_key.present?
+ if columns.present?
+ # Filter to only include valid column keys
+ column_keys = Array(columns).map(&:to_sym)
+ session["record_list_columns_#{list_key}"] = column_keys.join(',')
+ else
+ # Clear selection to use defaults
+ session.delete("record_list_columns_#{list_key}")
+ end
+ end
+
+ respond_to do |format|
+ format.html { redirect_back fallback_location: spree.admin_path }
+ format.turbo_stream { redirect_back fallback_location: spree.admin_path }
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/controllers/spree/admin/tags_controller.rb b/admin/app/controllers/spree/admin/tags_controller.rb
new file mode 100644
index 0000000000..00807ce34e
--- /dev/null
+++ b/admin/app/controllers/spree/admin/tags_controller.rb
@@ -0,0 +1,32 @@
+module Spree
+ module Admin
+ class TagsController < Spree::Admin::BaseController
+ def select_options
+ tags = tags_scope
+
+ if params[:q].present?
+ tags = tags.where('LOWER(name) LIKE ?', "%#{params[:q].downcase}%")
+ end
+
+ render json: tags.limit(100).pluck(:id, :name).map { |id, name| { id: id, name: name } }
+ end
+
+ private
+
+ def tags_scope
+ context = params[:context].presence || 'tags'
+ taggable_type = params[:taggable_type].presence
+
+ scope = ActsAsTaggableOn::Tag.for_context(context)
+
+ if taggable_type.present?
+ scope = scope.joins(:taggings)
+ .where(ActsAsTaggableOn.taggings_table => { taggable_type: taggable_type })
+ .distinct
+ end
+
+ scope.order(:name)
+ end
+ end
+ end
+end
diff --git a/admin/app/helpers/spree/admin/record_list_helper.rb b/admin/app/helpers/spree/admin/record_list_helper.rb
new file mode 100644
index 0000000000..57cfc21e8b
--- /dev/null
+++ b/admin/app/helpers/spree/admin/record_list_helper.rb
@@ -0,0 +1,294 @@
+module Spree
+ module Admin
+ module RecordListHelper
+ # Main helper to render a record list
+ # @param collection [ActiveRecord::Relation] the collection to render
+ # @param list_key [Symbol] the record list registry key (e.g., :products)
+ # @param options [Hash] additional options
+ # @option options [Boolean] :bulk_operations enable bulk operations
+ # @option options [Boolean] :sortable enable drag-and-drop sorting
+ # @option options [String] :frame_name custom turbo frame name
+ # @return [String] rendered HTML
+ def render_record_list(collection, list_key, **options)
+ record_list = Spree.admin.record_lists.get(list_key)
+ selected_columns = session_selected_columns(list_key)
+
+ render 'spree/admin/record_lists/record_list',
+ collection: collection,
+ record_list: record_list,
+ list_key: list_key,
+ selected_columns: selected_columns,
+ **options
+ end
+
+ # Get selected column keys from session
+ # @param list_key [Symbol] record list key
+ # @return [Array<Symbol>, nil]
+ def session_selected_columns(list_key)
+ keys = session["record_list_columns_#{list_key}"]
+ return nil if keys.blank?
+
+ keys.split(',').map(&:to_sym)
+ end
+
+ # Save selected columns to session
+ # @param list_key [Symbol] record list key
+ # @param column_keys [Array<Symbol>] selected column keys
+ def save_selected_columns(list_key, column_keys)
+ session["record_list_columns_#{list_key}"] = column_keys.join(',')
+ end
+
+ # Render a single column value based on its type
+ # @param record [Object] the record
+ # @param column [Spree::Admin::RecordList::Column] the column definition
+ # @param record_list [Spree::Admin::RecordList] the record list
+ # @return [String] rendered HTML
+ def render_column_value(record, column, record_list)
+ value = column.resolve_value(record, self)
+
+ case column.type
+ when :currency
+ render_currency_column(value, column)
+ when :date
+ render_date_column(value, column)
+ when :datetime
+ render_datetime_column(value, column)
+ when :status
+ render_status_column(value, column)
+ when :boolean
+ render_boolean_column(value, column)
+ when :link
+ render_link_column(record, value, column)
+ when :image
+ render_image_column(record, value, column)
+ when :custom
+ render partial: column.partial, locals: { record: record, column: column, value: value }
+ when :association
+ render_association_column(value, column)
+ else
+ render_string_column(value, column)
+ end
+ end
+
+ # Render currency column
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_currency_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ if value.respond_to?(:display_amount)
+ value.display_amount
+ else
+ Spree::Money.new(value, currency: current_currency).to_html
+ end
+ end
+
+ # Render date column
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_date_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ if column.format.present? && respond_to?(column.format)
+ send(column.format, value)
+ else
+ l(value.to_date, format: :short)
+ end
+ end
+
+ # Render datetime column
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_datetime_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ if column.format.present? && respond_to?(column.format)
+ send(column.format, value)
+ else
+ local_time_ago(value)
+ end
+ end
+
+ # Render status column as badge
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_status_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ css_class = case value.to_s
+ when 'active', 'complete', 'completed', 'paid', 'shipped', 'available'
+ 'badge-active'
+ when 'draft', 'pending', 'processing', 'ready'
+ 'badge-warning'
+ when 'archived', 'canceled', 'cancelled', 'failed', 'void', 'inactive'
+ 'badge-inactive'
+ else
+ 'badge-secondary'
+ end
+
+ content_tag(:span, Spree.t(value, scope: column.key, default: value.to_s.humanize), class: "badge #{css_class}")
+ end
+
+ # Render boolean column
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_boolean_column(value, column)
+ active_badge(value)
+ end
+
+ # Render link column
+ # @param record [Object] the record
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_link_column(record, value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ h(value.to_s.truncate(100))
+ end
+
+ # Render image column
+ # @param record [Object] the record
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_image_column(record, value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ if value.respond_to?(:attached?) && value.attached?
+ image_tag url_for(value.variant(resize_to_limit: [50, 50])), class: 'rounded', loading: 'lazy'
+ elsif value.is_a?(String) && value.present?
+ image_tag value, class: 'rounded', style: 'max-width: 50px; max-height: 50px;', loading: 'lazy'
+ else
+ content_tag(:span, '-', class: 'text-gray-400')
+ end
+ end
+
+ # Render string column
+ # @param value [Object] the value
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_string_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ if column.format.present? && respond_to?(column.format)
+ send(column.format, value)
+ else
+ h(value.to_s.truncate(100))
+ end
+ end
+
+ # Render association column (e.g., taxons, tags)
+ # @param value [Object] the value (expected to be a string from method lambda)
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def render_association_column(value, column)
+ return content_tag(:span, '-', class: 'text-gray-400') if value.blank?
+
+ h(value.to_s.truncate(100))
+ end
+
+ # Render sort dropdown for sortable columns
+ # @param record_list [Spree::Admin::RecordList] the record list
+ # @param current_sort [String, nil] current sort value (e.g., "name asc")
+ # @return [String]
+ def record_list_sort_dropdown(record_list, current_sort)
+ sortable = record_list.sortable_columns
+ return '' if sortable.empty?
+
+ current_label = find_sort_label(sortable, current_sort)
+
+ dropdown(portal: false) do
+ toggle = dropdown_toggle(class: 'btn-light btn-sm flex items-center gap-1') do
+ safe_join([
+ icon('arrows-sort', class: 'w-4 h-4'),
+ content_tag(:span, current_label),
+ icon('chevron-down', class: 'w-3 h-3')
+ ])
+ end
+
+ menu = dropdown_menu(class: 'min-w-[200px]') do
+ items = sortable.flat_map do |column|
+ [
+ sort_dropdown_item(column, 'asc', current_sort),
+ sort_dropdown_item(column, 'desc', current_sort)
+ ]
+ end
+ safe_join(items)
+ end
+
+ safe_join([toggle, menu])
+ end
+ end
+
+ # Get column header CSS class
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def column_header_class(column)
+ classes = []
+ classes << "text-#{column.align}" if column.align != :left
+ classes << "w-#{column.width}" if column.width.present?
+ classes.join(' ')
+ end
+
+ # Get column cell CSS class
+ # @param column [Spree::Admin::RecordList::Column] column definition
+ # @return [String]
+ def column_cell_class(column)
+ classes = []
+ classes << "text-#{column.align}" if column.align != :left
+ classes.join(' ')
+ end
+
+ # Build query builder fields JSON for Stimulus controller
+ # @param record_list [Spree::Admin::RecordList] the record list
+ # @return [String] JSON string
+ def query_builder_fields_json(record_list)
+ query_builder = Spree::Admin::RecordList::QueryBuilder.new(record_list)
+ query_builder.available_fields.to_json
+ end
+
+ # Build available operators JSON for Stimulus controller
+ # @return [String] JSON string
+ def query_builder_operators_json
+ Spree::Admin::RecordList::Filter.operators_for_select.to_json
+ end
+
+ private
+
+ def find_sort_label(sortable, current_sort)
+ return Spree.t('admin.record_lists.sort_by') if current_sort.blank?
+
+ field, direction = current_sort.split(' ')
+ column = sortable.find { |c| c.ransack_attribute == field }
+
+ if column
+ dir_label = direction == 'asc' ? 'ASC' : 'DESC'
+ "#{column.resolve_label} (#{dir_label})"
+ else
+ Spree.t('admin.record_lists.sort_by')
+ end
+ end
+
+ def sort_dropdown_item(column, direction, current_sort)
+ sort_value = "#{column.ransack_attribute} #{direction}"
+ is_active = current_sort == sort_value
+ dir_label = direction == 'asc' ? 'ASC' : 'DESC'
+ label = "#{column.resolve_label} (#{dir_label})"
+
+ # Convert params[:q] to a regular hash to avoid unpermitted parameters error
+ current_q = params[:q].respond_to?(:to_unsafe_h) ? params[:q].to_unsafe_h : (params[:q] || {})
+
+ link_to label,
+ url_for(q: current_q.merge(s: sort_value)),
+ class: "dropdown-item #{'active' if is_active}",
+ data: { turbo_action: 'advance' }
+ end
+ end
+ end
+end
diff --git a/admin/app/javascript/spree/admin/application.js b/admin/app/javascript/spree/admin/application.js
index c3d4e6ede3..e34a30b349 100644
--- a/admin/app/javascript/spree/admin/application.js
+++ b/admin/app/javascript/spree/admin/application.js
@@ -52,6 +52,7 @@ import CalendarRangeController from 'spree/admin/controllers/calendar_range_cont
import Clipboard from 'spree/admin/controllers/clipboard_controller'
import CodeMirrorController from 'spree/admin/controllers/codemirror_controller'
import ColorPaletteController from 'spree/admin/controllers/color_palette_controller'
+import ColumnSelectorController from 'spree/admin/controllers/column_selector_controller'
import ColorPickerController from 'spree/admin/controllers/color_picker_controller'
import DropdownController from 'spree/admin/controllers/dropdown_controller'
import FiltersController from 'spree/admin/controllers/filters_controller'
@@ -65,7 +66,9 @@ import OrderBillingAddressController from 'spree/admin/controllers/order_billing
import PageBuilderController from 'spree/admin/controllers/page_builder_controller'
import PasswordToggle from 'spree/admin/controllers/password_toggle_controller'
import ProductFormController from 'spree/admin/controllers/product_form_controller'
+import QueryBuilderController from 'spree/admin/controllers/query_builder_controller'
import RangeInputController from 'spree/admin/controllers/range_input_controller'
+import RecordListController from 'spree/admin/controllers/record_list_controller'
import ReturnItemsController from 'spree/admin/controllers/return_items_controller'
import ReplaceController from 'spree/admin/controllers/replace_controller'
import RowLinkController from 'spree/admin/controllers/row_link_controller'
@@ -110,6 +113,7 @@ application.register('clipboard', Clipboard)
application.register('codemirror', CodeMirrorController)
application.register('color-palette', ColorPaletteController)
application.register('color-picker', ColorPickerController)
+application.register('column-selector', ColumnSelectorController)
application.register('dialog', Dialog)
application.register('drawer', Dialog)
application.register('disable-submit-button', DisableSubmitButtonController)
@@ -130,7 +134,9 @@ application.register('page-builder', PageBuilderController)
application.register('password-toggle', PasswordToggle)
application.register('password-visibility', PasswordVisibility)
application.register('product-form', ProductFormController)
+application.register('query-builder', QueryBuilderController)
application.register('range-input', RangeInputController)
+application.register('record-list', RecordListController)
application.register('replace', ReplaceController)
application.register('return-items', ReturnItemsController)
application.register('reveal', Reveal)
diff --git a/admin/app/javascript/spree/admin/controllers/column_selector_controller.js b/admin/app/javascript/spree/admin/controllers/column_selector_controller.js
new file mode 100644
index 0000000000..9c1ea45493
--- /dev/null
+++ b/admin/app/javascript/spree/admin/controllers/column_selector_controller.js
@@ -0,0 +1,35 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+ static targets = ["checkbox"]
+
+ connect() {
+ // Controller is ready
+ }
+
+ reset(event) {
+ event.preventDefault()
+
+ // Reset all checkboxes to their default state
+ this.checkboxTargets.forEach(checkbox => {
+ const isDefault = checkbox.dataset.default === "true"
+ checkbox.checked = isDefault
+ })
+ }
+
+ selectAll(event) {
+ event.preventDefault()
+
+ this.checkboxTargets.forEach(checkbox => {
+ checkbox.checked = true
+ })
+ }
+
+ deselectAll(event) {
+ event.preventDefault()
+
+ this.checkboxTargets.forEach(checkbox => {
+ checkbox.checked = false
+ })
+ }
+}
diff --git a/admin/app/javascript/spree/admin/controllers/query_builder_controller.js b/admin/app/javascript/spree/admin/controllers/query_builder_controller.js
new file mode 100644
index 0000000000..5bc6ecdb42
--- /dev/null
+++ b/admin/app/javascript/spree/admin/controllers/query_builder_controller.js
@@ -0,0 +1,563 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+ static targets = [
+ "container",
+ "filtersContainer",
+ "groupsContainer",
+ "hiddenInput",
+ "filterTemplate",
+ "groupTemplate",
+ "combinatorButton",
+ "combinatorLabel",
+ "form"
+ ]
+
+ static values = {
+ fields: Array,
+ operators: Array
+ }
+
+ connect() {
+ this.rootCombinator = "and"
+ this.loadState()
+ }
+
+ // Called before form submission to add ransack params
+ submitForm(event) {
+ const form = this.hasFormTarget ? this.formTarget : event.target.closest("form")
+ if (form) {
+ this.generateRansackInputs(form)
+ }
+ }
+
+ loadState() {
+ const stateJson = this.hiddenInputTarget.value
+ if (stateJson && stateJson !== "{}") {
+ try {
+ const state = JSON.parse(stateJson)
+ this.renderState(state)
+ } catch (e) {
+ console.error("Failed to parse query state:", e)
+ }
+ }
+ }
+
+ renderState(state) {
+ // Set root combinator
+ if (state.combinator) {
+ this.rootCombinator = state.combinator
+ this.updateCombinatorDisplay()
+ }
+
+ // Render filters
+ if (state.filters && state.filters.length > 0) {
+ state.filters.forEach(filter => {
+ this.addFilterWithData(filter, this.filtersContainerTarget)
+ })
+ }
+
+ // Render groups
+ if (state.groups && state.groups.length > 0) {
+ state.groups.forEach(group => {
+ this.addGroupWithData(group)
+ })
+ }
+ }
+
+ addFilter(event) {
+ event.preventDefault()
+ this.addFilterWithData({}, this.filtersContainerTarget)
+ this.updateHiddenInput()
+ }
+
+ addFilterToGroup(event) {
+ event.preventDefault()
+ const groupEl = event.target.closest("[data-group-id]")
+ const filtersContainer = groupEl.querySelector("[data-group-filters-container]")
+ this.addFilterWithData({}, filtersContainer)
+ this.updateHiddenInput()
+ }
+
+ addFilterWithData(filterData, container) {
+ const template = this.filterTemplateTarget.content.cloneNode(true)
+ const row = template.querySelector("[data-filter-id]")
+ row.dataset.filterId = filterData.id || this.generateId()
+
+ // Populate field options
+ const fieldSelect = row.querySelector("[data-field-select]")
+ this.fieldsValue.forEach(field => {
+ const option = document.createElement("option")
+ option.value = field.key
+ option.textContent = field.label
+ if (filterData.field === field.key) {
+ option.selected = true
+ }
+ fieldSelect.appendChild(option)
+ })
+
+ // If we have a field selected, update operators and value
+ if (filterData.field) {
+ const fieldConfig = this.fieldsValue.find(f => f.key === filterData.field)
+ if (fieldConfig) {
+ this.updateOperatorOptions(row, fieldConfig.operators, filterData.operator)
+ this.updateValueInput(row, fieldConfig, filterData.value)
+ }
+ }
+
+ container.appendChild(row)
+ }
+
+ addOrGroup(event) {
+ event.preventDefault()
+ this.addGroupWithData({ combinator: "or", filters: [], groups: [] })
+ this.updateHiddenInput()
+ }
+
+ addGroupWithData(groupData) {
+ const template = this.groupTemplateTarget.content.cloneNode(true)
+ const group = template.querySelector("[data-group-id]")
+ group.dataset.groupId = groupData.id || this.generateId()
+ group.dataset.combinator = groupData.combinator || "or"
+
+ // Update combinator label
+ const label = group.querySelector("[data-group-combinator-label]")
+ if (label) {
+ label.textContent = (groupData.combinator || "or").toUpperCase()
+ }
+
+ // Add existing filters to the group
+ if (groupData.filters && groupData.filters.length > 0) {
+ const filtersContainer = group.querySelector("[data-group-filters-container]")
+ groupData.filters.forEach(filter => {
+ this.addFilterWithData(filter, filtersContainer)
+ })
+ }
+
+ this.groupsContainerTarget.appendChild(group)
+ }
+
+ removeFilter(event) {
+ event.preventDefault()
+ const filterRow = event.target.closest("[data-filter-id]")
+ if (filterRow) {
+ filterRow.remove()
+ this.updateHiddenInput()
+ }
+ }
+
+ removeGroup(event) {
+ event.preventDefault()
+ const group = event.target.closest("[data-group-id]")
+ if (group) {
+ group.remove()
+ this.updateHiddenInput()
+ }
+ }
+
+ toggleCombinator(event) {
+ event.preventDefault()
+ this.rootCombinator = this.rootCombinator === "and" ? "or" : "and"
+ this.updateCombinatorDisplay()
+ this.updateHiddenInput()
+ }
+
+ toggleGroupCombinator(event) {
+ event.preventDefault()
+ const group = event.target.closest("[data-group-id]")
+ const currentCombinator = group.dataset.combinator
+ const newCombinator = currentCombinator === "and" ? "or" : "and"
+
+ group.dataset.combinator = newCombinator
+ const label = group.querySelector("[data-group-combinator-label]")
+ if (label) {
+ label.textContent = newCombinator.toUpperCase()
+ }
+
+ this.updateHiddenInput()
+ }
+
+ updateCombinatorDisplay() {
+ if (this.hasCombinatorLabelTarget) {
+ this.combinatorLabelTarget.textContent = this.rootCombinator.toUpperCase()
+ }
+ }
+
+ onFieldChange(event) {
+ const filterRow = event.target.closest("[data-filter-id]")
+ const field = event.target.value
+ const fieldConfig = this.fieldsValue.find(f => f.key === field)
+
+ if (fieldConfig) {
+ this.updateOperatorOptions(filterRow, fieldConfig.operators)
+ this.updateValueInput(filterRow, fieldConfig)
+ }
+
+ this.updateHiddenInput()
+ }
+
+ onOperatorChange(event) {
+ const filterRow = event.target.closest("[data-filter-id]")
+ const operator = event.target.value
+ const noValueOperators = ["null", "not_null"]
+
+ const valueContainer = filterRow.querySelector("[data-value-container]")
+ if (noValueOperators.includes(operator)) {
+ valueContainer.style.display = "none"
+ } else {
+ valueContainer.style.display = ""
+ }
+
+ this.updateHiddenInput()
+ }
+
+ onValueChange() {
+ this.updateHiddenInput()
+ }
+
+ updateOperatorOptions(filterRow, operators, selectedOperator = null) {
+ const operatorSelect = filterRow.querySelector("[data-operator-select]")
+ operatorSelect.innerHTML = ""
+
+ const operatorLabels = {
+ eq: "equals",
+ not_eq: "does not equal",
+ cont: "contains",
+ not_cont: "does not contain",
+ start: "starts with",
+ end: "ends with",
+ gt: "greater than",
+ gteq: "greater than or equal",
+ lt: "less than",
+ lteq: "less than or equal",
+ in: "is any of",
+ not_in: "is none of",
+ null: "is empty",
+ not_null: "is not empty"
+ }
+
+ operators.forEach(op => {
+ const option = document.createElement("option")
+ option.value = op
+ option.textContent = operatorLabels[op] || op
+ if (selectedOperator === op) {
+ option.selected = true
+ }
+ operatorSelect.appendChild(option)
+ })
+ }
+
+ updateValueInput(filterRow, fieldConfig, existingValue = null) {
+ const valueContainer = filterRow.querySelector("[data-value-container]")
+ valueContainer.innerHTML = ""
+
+ let input
+ switch (fieldConfig.type) {
+ case "date":
+ input = document.createElement("input")
+ input.type = "date"
+ input.className = "form-input text-sm"
+ break
+ case "datetime":
+ input = document.createElement("input")
+ input.type = "datetime-local"
+ input.className = "form-input text-sm"
+ break
+ case "number":
+ case "currency":
+ input = document.createElement("input")
+ input.type = "number"
+ input.className = "form-input text-sm"
+ input.step = fieldConfig.type === "currency" ? "0.01" : "1"
+ break
+ case "boolean":
+ input = document.createElement("select")
+ input.className = "form-select text-sm"
+ input.innerHTML = `
+ <option value="true">Yes</option>
+ <option value="false">No</option>
+ `
+ break
+ case "status":
+ input = document.createElement("select")
+ input.className = "form-select text-sm"
+ input.innerHTML = '<option value="">Select...</option>'
+ if (fieldConfig.value_options) {
+ fieldConfig.value_options.forEach(opt => {
+ const option = document.createElement("option")
+ option.value = opt.value || opt
+ option.textContent = opt.label || opt
+ input.appendChild(option)
+ })
+ }
+ break
+ case "autocomplete":
+ // Create a wrapper div with select controller
+ const wrapper = document.createElement("div")
+ wrapper.className = "w-full"
+ wrapper.dataset.controller = "select"
+ wrapper.dataset.selectMultipleValue = "true"
+
+ if (fieldConfig.search_url) {
+ wrapper.dataset.selectUrlValue = fieldConfig.search_url
+ // Use remote search mode so it doesn't pre-fetch and overwrite our preloaded options
+ wrapper.dataset.selectRemoteSearchValue = "true"
+ }
+
+ // Use name as value field for tags (tags_name ransack attribute expects tag names)
+ const useNameAsValue = fieldConfig.key && fieldConfig.key.includes("name")
+ if (useNameAsValue) {
+ wrapper.dataset.selectValueFieldValue = "name"
+ }
+
+ input = document.createElement("select")
+ input.className = "form-select text-sm"
+ input.multiple = true
+ input.dataset.selectTarget = "input"
+ input.dataset.valueInput = "" // Mark as value input for serialization
+
+ // Restore existing values - we store as array of {id, name} objects
+ // Use remoteSearchActiveOption which properly preloads options and selects them
+ if (existingValue !== null && existingValue !== undefined && Array.isArray(existingValue) && existingValue.length > 0) {
+ const preloadedOptions = existingValue.map(item => {
+ if (typeof item === 'object') {
+ return { id: useNameAsValue ? item.name : item.id, name: item.name }
+ } else {
+ return { id: item, name: item }
+ }
+ })
+ wrapper.dataset.selectRemoteSearchActiveOptionValue = JSON.stringify(preloadedOptions)
+ }
+
+ // Set up change listener on select element directly
+ input.dataset.action = "change->query-builder#onValueChange"
+
+ wrapper.appendChild(input)
+ valueContainer.appendChild(wrapper)
+
+ return // Early return since we already appended
+ default:
+ input = document.createElement("input")
+ input.type = "text"
+ input.className = "form-input text-sm"
+ input.placeholder = "Enter value..."
+ }
+
+ input.dataset.valueInput = ""
+ input.dataset.action = "input->query-builder#onValueChange change->query-builder#onValueChange"
+
+ if (existingValue !== null && existingValue !== undefined) {
+ input.value = existingValue
+ }
+
+ valueContainer.appendChild(input)
+ }
+
+ clear(event) {
+ event.preventDefault()
+ this.filtersContainerTarget.innerHTML = ""
+ this.groupsContainerTarget.innerHTML = ""
+ this.rootCombinator = "and"
+ this.updateCombinatorDisplay()
+ this.updateHiddenInput()
+ }
+
+ updateHiddenInput() {
+ const state = this.serializeState()
+ this.hiddenInputTarget.value = JSON.stringify(state)
+ }
+
+ serializeState() {
+ const filters = this.serializeFilters(this.filtersContainerTarget)
+ const groups = this.serializeGroups()
+
+ return {
+ id: "root",
+ combinator: this.rootCombinator,
+ filters: filters,
+ groups: groups
+ }
+ }
+
+ serializeFilters(container) {
+ const filters = []
+ container.querySelectorAll(":scope > [data-filter-id]").forEach(row => {
+ // Handle multi-select (tom-select) values
+ const valueInput = row.querySelector("[data-value-input]")
+ let value = null
+
+ if (valueInput) {
+ if (valueInput.multiple) {
+ // Get all selected options for multi-select
+ // Store as objects with id and name for autocomplete restoration
+ value = Array.from(valueInput.selectedOptions).map(opt => ({
+ id: opt.value,
+ name: opt.textContent
+ }))
+ } else {
+ value = valueInput.value
+ }
+ }
+
+ const filter = {
+ id: row.dataset.filterId,
+ field: row.querySelector("[data-field-select]")?.value,
+ operator: row.querySelector("[data-operator-select]")?.value,
+ value: value
+ }
+ if (filter.field) {
+ filters.push(filter)
+ }
+ })
+ return filters
+ }
+
+ serializeGroups() {
+ const groups = []
+ this.groupsContainerTarget.querySelectorAll(":scope > [data-group-id]").forEach(groupEl => {
+ const filtersContainer = groupEl.querySelector("[data-group-filters-container]")
+ const group = {
+ id: groupEl.dataset.groupId,
+ combinator: groupEl.dataset.combinator || "or",
+ filters: this.serializeFilters(filtersContainer),
+ groups: []
+ }
+ groups.push(group)
+ })
+ return groups
+ }
+
+ generateId() {
+ return Math.random().toString(36).substring(2, 10)
+ }
+
+ // Generate ransack params from filters and add as hidden inputs to form
+ generateRansackInputs(form) {
+ // Remove any existing ransack inputs we've added
+ form.querySelectorAll("[data-ransack-input]").forEach(el => el.remove())
+
+ const state = this.serializeState()
+ const ransackParams = this.stateToRansackParams(state)
+
+ // Add hidden inputs for each ransack param
+ Object.entries(ransackParams).forEach(([key, value]) => {
+ if (Array.isArray(value)) {
+ // For array values (like _in predicates), add multiple inputs with same name
+ value.forEach(v => {
+ const input = document.createElement("input")
+ input.type = "hidden"
+ input.name = `q[${key}][]`
+ input.value = v
+ input.dataset.ransackInput = ""
+ form.appendChild(input)
+ })
+ } else {
+ const input = document.createElement("input")
+ input.type = "hidden"
+ input.name = `q[${key}]`
+ input.value = value
+ input.dataset.ransackInput = ""
+ form.appendChild(input)
+ }
+ })
+ }
+
+ // Convert state object to ransack params object
+ stateToRansackParams(state) {
+ const params = {}
+ const combinator = state.combinator || "and"
+
+ // For "and" combinator, each filter becomes a separate ransack param
+ // For "or" combinator, we need to use ransack's grouping (more complex)
+ // For simplicity, we'll handle "and" directly and "or" with groupings
+
+ if (combinator === "and") {
+ // Simple case: all filters are ANDed together
+ state.filters.forEach(filter => {
+ const ransackParam = this.filterToRansackParam(filter)
+ Object.assign(params, ransackParam)
+ })
+
+ // Handle groups (OR groups within AND root)
+ state.groups.forEach((group, idx) => {
+ const groupParams = this.groupToRansackParams(group, idx)
+ Object.assign(params, groupParams)
+ })
+ } else {
+ // OR at root level - use grouping syntax
+ // ransack uses: { g: { '0' => { m: 'or', c: { '0' => {...}, '1' => {...} } } } }
+ // This is complex, so for MVP we'll just OR the filters
+ const groupKey = `g[0]`
+ params[`${groupKey}[m]`] = "or"
+ state.filters.forEach((filter, idx) => {
+ const filterParams = this.filterToRansackParam(filter)
+ Object.entries(filterParams).forEach(([key, value]) => {
+ params[`${groupKey}[c][${idx}][${key}]`] = value
+ })
+ })
+ }
+
+ return params
+ }
+
+ // Convert a single filter to ransack param
+ filterToRansackParam(filter) {
+ if (!filter.field || !filter.operator) return {}
+
+ const operatorMap = {
+ eq: "_eq",
+ not_eq: "_not_eq",
+ cont: "_cont",
+ not_cont: "_not_cont",
+ start: "_start",
+ end: "_end",
+ gt: "_gt",
+ gteq: "_gteq",
+ lt: "_lt",
+ lteq: "_lteq",
+ in: "_in",
+ not_in: "_not_in",
+ null: "_null",
+ not_null: "_not_null"
+ }
+
+ const predicate = operatorMap[filter.operator] || "_eq"
+ const paramName = filter.field + predicate
+
+ // Handle null/not_null which don't need values
+ if (filter.operator === "null" || filter.operator === "not_null") {
+ return { [paramName]: true }
+ }
+
+ // Extract values from autocomplete objects
+ let value = filter.value
+ if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object') {
+ // For autocomplete values, extract just the IDs
+ value = value.map(item => item.id)
+ }
+
+ return { [paramName]: value }
+ }
+
+ // Convert a group to ransack params using grouping syntax
+ groupToRansackParams(group, groupIdx) {
+ const params = {}
+ const groupKey = `g[${groupIdx}]`
+ params[`${groupKey}[m]`] = group.combinator || "or"
+
+ group.filters.forEach((filter, filterIdx) => {
+ const filterParams = this.filterToRansackParam(filter)
+ Object.entries(filterParams).forEach(([key, value]) => {
+ if (Array.isArray(value)) {
+ value.forEach((v, vIdx) => {
+ params[`${groupKey}[c][${filterIdx}][${key}][]`] = v
+ })
+ } else {
+ params[`${groupKey}[c][${filterIdx}][${key}]`] = value
+ }
+ })
+ })
+
+ return params
+ }
+}
diff --git a/admin/app/javascript/spree/admin/controllers/record_list_controller.js b/admin/app/javascript/spree/admin/controllers/record_list_controller.js
new file mode 100644
index 0000000000..e24d44006e
--- /dev/null
+++ b/admin/app/javascript/spree/admin/controllers/record_list_controller.js
@@ -0,0 +1,20 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+ static values = {
+ url: String
+ }
+
+ connect() {
+ // Controller is ready
+ }
+
+ // This method can be used to handle custom list interactions
+ // Currently, form submission is handled by the form's native behavior
+ // with Turbo, so this is mainly a placeholder for future enhancements
+
+ refresh() {
+ // Reload the current page with Turbo
+ Turbo.visit(window.location.href)
+ }
+}
diff --git a/admin/app/javascript/spree/admin/controllers/select_controller.js b/admin/app/javascript/spree/admin/controllers/select_controller.js
index 2aaefeed4c..fecaf1297b 100644
--- a/admin/app/javascript/spree/admin/controllers/select_controller.js
+++ b/admin/app/javascript/spree/admin/controllers/select_controller.js
@@ -72,8 +72,14 @@ export default class extends Controller {
if (this.remoteSearchActiveOptionValue) {
const items = JSON.parse(this.remoteSearchActiveOptionValue)
- settings.options = items
- settings.items = items.map(item => item.id)
+ // Tom-select uses string values internally, ensure IDs are strings for matching
+ const normalizedItems = items.map(item => ({
+ ...item,
+ id: String(item.id),
+ name: item.name
+ }))
+ settings.options = normalizedItems
+ settings.items = normalizedItems.map(item => item[this.valueFieldValue])
}
}
diff --git a/admin/app/models/spree/admin/record_list.rb b/admin/app/models/spree/admin/record_list.rb
new file mode 100644
index 0000000000..a317250ffb
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list.rb
@@ -0,0 +1,158 @@
+module Spree
+ module Admin
+ class RecordList
+ attr_reader :columns, :context, :model_class
+ attr_accessor :search_param, :search_placeholder
+
+ def initialize(context, model_class: nil, search_param: :name_cont, search_placeholder: nil)
+ @context = context
+ @model_class = model_class
+ @columns = {}
+ @search_param = search_param
+ @search_placeholder = search_placeholder
+ end
+
+ # Add a column definition
+ # @param key [Symbol] unique column identifier
+ # @param options [Hash] column options (label, type, sortable, filterable, default, position, etc.)
+ # @return [Column] the created column
+ def add(key, **options, &block)
+ key = key.to_sym
+ column = Column.new(key, **options)
+ @columns[key] = column
+
+ if block_given?
+ builder = Builder.new(self, column)
+ builder.instance_eval(&block)
+ end
+
+ sort_columns!
+ column
+ end
+
+ # Remove a column
+ # @param key [Symbol] column key to remove
+ # @return [Column, nil] the removed column or nil
+ def remove(key)
+ @columns.delete(key.to_sym)
+ end
+
+ # Update an existing column
+ # @param key [Symbol] column key to update
+ # @param options [Hash] attributes to update
+ # @return [Column, nil] the updated column or nil
+ def update(key, **options)
+ column = @columns[key.to_sym]
+ return nil unless column
+
+ options.each do |attr, value|
+ column.send("#{attr}=", value) if column.respond_to?("#{attr}=")
+ end
+
+ sort_columns!
+ column
+ end
+
+ # Find a column by key
+ # @param key [Symbol] column key
+ # @return [Column, nil]
+ def find(key)
+ @columns[key.to_sym]
+ end
+
+ # Check if column exists
+ # @param key [Symbol] column key
+ # @return [Boolean]
+ def exists?(key)
+ @columns.key?(key.to_sym)
+ end
+
+ # Insert column before another column
+ # @param target_key [Symbol] existing column key
+ # @param new_key [Symbol] new column key
+ # @param options [Hash] column options
+ # @return [Column, nil]
+ def insert_before(target_key, new_key, **options)
+ target = find(target_key)
+ return nil unless target
+
+ add(new_key, **options.merge(position: target.position - 1))
+ end
+
+ # Insert column after another column
+ # @param target_key [Symbol] existing column key
+ # @param new_key [Symbol] new column key
+ # @param options [Hash] column options
+ # @return [Column, nil]
+ def insert_after(target_key, new_key, **options)
+ target = find(target_key)
+ return nil unless target
+
+ add(new_key, **options.merge(position: target.position + 1))
+ end
+
+ # Get visible columns for user (respecting selection)
+ # @param selected_keys [Array<Symbol>, nil] user-selected column keys
+ # @param view_context [Object, nil] view context for visibility checks
+ # @return [Array<Column>]
+ def visible_columns(selected_keys = nil, view_context = nil)
+ cols = if selected_keys.present?
+ selected_keys.map { |k| find(k) }.compact
+ else
+ default_columns
+ end
+
+ cols.select { |c| c.visible?(view_context) }
+ end
+
+ # Get default columns (marked as default: true and displayable)
+ # @return [Array<Column>]
+ def default_columns
+ @columns.values.select { |c| c.default? && c.displayable? }.sort_by(&:position)
+ end
+
+ # Get all available columns that can be displayed
+ # @return [Array<Column>]
+ def available_columns
+ @columns.values.select(&:displayable?).sort_by(&:position)
+ end
+
+ # Get sortable columns
+ # @return [Array<Column>]
+ def sortable_columns
+ @columns.values.select(&:sortable?).sort_by(&:position)
+ end
+
+ # Get filterable columns (columns that can be used in query builder)
+ # @return [Array<Column>]
+ def filterable_columns
+ @columns.values.select(&:filterable?).sort_by(&:position)
+ end
+
+ # Deep clone the registry
+ # @return [RecordList]
+ def deep_clone
+ cloned = self.class.new(context, model_class: model_class, search_param: search_param, search_placeholder: search_placeholder)
+ @columns.each do |key, column|
+ cloned.columns[key] = column.deep_clone
+ end
+ cloned
+ end
+
+ # Clear all columns
+ def clear
+ @columns.clear
+ end
+
+ def inspect
+ "#<Spree::Admin::RecordList context=#{context} columns=#{@columns.size}>"
+ end
+
+ private
+
+ def sort_columns!
+ @columns = @columns.sort_by { |_key, col| [col.position, col.key.to_s] }.to_h
+ end
+ end
+ end
+end
diff --git a/admin/app/models/spree/admin/record_list/builder.rb b/admin/app/models/spree/admin/record_list/builder.rb
new file mode 100644
index 0000000000..1be6baa5e5
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list/builder.rb
@@ -0,0 +1,55 @@
+module Spree
+ module Admin
+ class RecordList
+ class Builder
+ attr_reader :registry, :parent_column
+
+ def initialize(registry, parent_column = nil)
+ @registry = registry
+ @parent_column = parent_column
+ end
+
+ # Add a column
+ # @param key [Symbol] column key
+ # @param options [Hash] column options
+ # @return [Column]
+ def add(key, **options, &block)
+ @registry.add(key, **options, &block)
+ end
+
+ # Remove a column
+ # @param key [Symbol] column key
+ # @return [Column, nil]
+ def remove(key)
+ @registry.remove(key)
+ end
+
+ # Update a column
+ # @param key [Symbol] column key
+ # @param options [Hash] attributes to update
+ # @return [Column, nil]
+ def update(key, **options)
+ @registry.update(key, **options)
+ end
+
+ # Insert before another column
+ # @param target_key [Symbol] existing column key
+ # @param new_key [Symbol] new column key
+ # @param options [Hash] column options
+ # @return [Column, nil]
+ def insert_before(target_key, new_key, **options)
+ @registry.insert_before(target_key, new_key, **options)
+ end
+
+ # Insert after another column
+ # @param target_key [Symbol] existing column key
+ # @param new_key [Symbol] new column key
+ # @param options [Hash] column options
+ # @return [Column, nil]
+ def insert_after(target_key, new_key, **options)
+ @registry.insert_after(target_key, new_key, **options)
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/models/spree/admin/record_list/column.rb b/admin/app/models/spree/admin/record_list/column.rb
new file mode 100644
index 0000000000..1bba790fee
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list/column.rb
@@ -0,0 +1,152 @@
+module Spree
+ module Admin
+ class RecordList
+ class Column
+ TYPES = %i[string number date datetime currency status link boolean image custom].freeze
+ FILTER_TYPES = %i[string number date datetime currency status boolean autocomplete].freeze
+
+ attr_accessor :key, :label, :type, :filter_type, :sortable, :filterable, :displayable, :default, :position,
+ :partial, :method, :width, :align, :format, :condition,
+ :ransack_attribute, :operators, :value_options, :search_url
+
+ def initialize(key, **options)
+ @key = key.to_sym
+ @label = options[:label]
+ @type = (options[:type] || :string).to_sym
+ @filter_type = (options[:filter_type] || @type).to_sym
+ @sortable = options.fetch(:sortable, true)
+ @filterable = options.fetch(:filterable, true)
+ @displayable = options.fetch(:displayable, true)
+ @default = options.fetch(:default, false)
+ @position = options[:position] || 999
+ @partial = options[:partial]
+ @method = options[:method] || key
+ @width = options[:width]
+ @align = options[:align] || :left
+ @format = options[:format]
+ @condition = options.key?(:if) ? options[:if] : options[:condition]
+ @ransack_attribute = options[:ransack_attribute] || key.to_s
+ @value_options = options[:value_options]
+ @search_url = options[:search_url]
+ @operators = options[:operators] || default_operators_for_type
+ end
+
+ def sortable?
+ @sortable
+ end
+
+ def filterable?
+ @filterable
+ end
+
+ def displayable?
+ @displayable
+ end
+
+ def default?
+ @default
+ end
+
+ # Check if column is visible for the given context
+ # @param context [Object, nil] view context with access to helper methods
+ # @return [Boolean]
+ def visible?(context = nil)
+ return true if condition.nil?
+
+ if condition.respond_to?(:call)
+ if context&.respond_to?(:instance_exec)
+ context.instance_exec(&condition)
+ else
+ condition.call(context)
+ end
+ else
+ condition
+ end
+ end
+
+ # Resolve label (handles i18n keys)
+ # @return [String]
+ def resolve_label
+ if label.is_a?(String) && label.present?
+ return label
+ end
+
+ key_to_translate = label || key
+ Spree.t(key_to_translate, default: key_to_translate.to_s.humanize)
+ end
+
+ # Resolve value from record
+ # @param record [Object] the record to extract value from
+ # @param context [Object, nil] view context
+ # @return [Object]
+ def resolve_value(record, context = nil)
+ if method.respond_to?(:call)
+ if context&.respond_to?(:instance_exec)
+ context.instance_exec(record, &method)
+ else
+ method.call(record)
+ end
+ elsif record.respond_to?(method)
+ record.send(method)
+ end
+ end
+
+ # Get default operators based on column filter_type
+ # @return [Array<Symbol>]
+ def default_operators_for_type
+ case filter_type
+ when :string
+ %i[eq not_eq cont not_cont start end in not_in null not_null]
+ when :number, :currency
+ %i[eq not_eq gt gteq lt lteq in not_in null not_null]
+ when :date, :datetime
+ %i[eq not_eq gt gteq lt lteq null not_null]
+ when :boolean
+ %i[eq]
+ when :status
+ %i[eq not_eq in not_in]
+ when :association, :tags, :autocomplete
+ %i[in not_in]
+ else
+ %i[eq not_eq cont null not_null]
+ end
+ end
+
+ # Convert to hash
+ # @return [Hash]
+ def to_h
+ {
+ key: key,
+ label: label,
+ type: type,
+ filter_type: filter_type,
+ sortable: sortable,
+ filterable: filterable,
+ displayable: displayable,
+ default: default,
+ position: position,
+ partial: partial,
+ method: method,
+ width: width,
+ align: align,
+ format: format,
+ ransack_attribute: ransack_attribute,
+ operators: operators,
+ value_options: value_options,
+ search_url: search_url
+ }
+ end
+
+ # Deep clone the column
+ # @return [Column]
+ def deep_clone
+ self.class.new(key, to_h.merge(condition: condition, method: method))
+ end
+
+ def inspect
+ "#<Spree::Admin::RecordList::Column key=#{key} type=#{type} default=#{default}>"
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/models/spree/admin/record_list/filter.rb b/admin/app/models/spree/admin/record_list/filter.rb
new file mode 100644
index 0000000000..af9159ca5f
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list/filter.rb
@@ -0,0 +1,109 @@
+module Spree
+ module Admin
+ class RecordList
+ class Filter
+ OPERATORS = {
+ eq: { label: 'equals', predicate: '_eq' },
+ not_eq: { label: 'does not equal', predicate: '_not_eq' },
+ cont: { label: 'contains', predicate: '_cont' },
+ not_cont: { label: 'does not contain', predicate: '_not_cont' },
+ start: { label: 'starts with', predicate: '_start' },
+ end: { label: 'ends with', predicate: '_end' },
+ gt: { label: 'greater than', predicate: '_gt' },
+ gteq: { label: 'greater than or equal to', predicate: '_gteq' },
+ lt: { label: 'less than', predicate: '_lt' },
+ lteq: { label: 'less than or equal to', predicate: '_lteq' },
+ in: { label: 'is any of', predicate: '_in' },
+ not_in: { label: 'is none of', predicate: '_not_in' },
+ null: { label: 'is empty', predicate: '_null', no_value: true },
+ not_null: { label: 'is not empty', predicate: '_not_null', no_value: true }
+ }.freeze
+
+ attr_accessor :field, :operator, :value, :id
+
+ def initialize(field: nil, operator: :eq, value: nil, id: nil)
+ @field = field
+ @operator = operator.to_sym
+ @value = value
+ @id = id || SecureRandom.hex(8)
+ end
+
+ # Convert to ransack parameter format
+ # @return [Hash]
+ def to_ransack_param
+ return {} if field.blank?
+
+ operator_config = OPERATORS[@operator]
+ return {} unless operator_config
+
+ param_name = "#{field}#{operator_config[:predicate]}"
+
+ if operator_config[:no_value]
+ { param_name => true }
+ else
+ { param_name => extract_ransack_value }
+ end
+ end
+
+ private
+
+ # Extract the actual value for ransack from potentially complex value structures
+ # Handles arrays of objects (from autocomplete) by extracting IDs
+ # @return [Object]
+ def extract_ransack_value
+ return value unless value.is_a?(Array)
+
+ # If array contains hashes with 'id' key, extract the IDs
+ if value.first.is_a?(Hash) && (value.first.key?('id') || value.first.key?(:id))
+ value.map { |item| item['id'] || item[:id] }
+ else
+ value
+ end
+ end
+
+ public
+
+ # Get human-readable operator label
+ # @return [String]
+ def operator_label
+ OPERATORS.dig(@operator, :label) || @operator.to_s.humanize
+ end
+
+ # Check if this operator requires a value
+ # @return [Boolean]
+ def requires_value?
+ !OPERATORS.dig(@operator, :no_value)
+ end
+
+ # Convert to hash
+ # @return [Hash]
+ def to_h
+ { field: field, operator: operator, value: value, id: id }
+ end
+
+ # Create filter from params hash
+ # @param params [Hash]
+ # @return [Filter, nil]
+ def self.from_params(params)
+ return nil unless params.is_a?(Hash)
+
+ params = params.symbolize_keys
+ new(
+ field: params[:field],
+ operator: params[:operator] || :eq,
+ value: params[:value],
+ id: params[:id]
+ )
+ end
+
+ # Get available operators with labels for UI
+ # @return [Array<Hash>]
+ def self.operators_for_select
+ OPERATORS.map do |key, config|
+ { value: key.to_s, label: config[:label], no_value: config[:no_value] || false }
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/models/spree/admin/record_list/filter_group.rb b/admin/app/models/spree/admin/record_list/filter_group.rb
new file mode 100644
index 0000000000..51bd668d1f
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list/filter_group.rb
@@ -0,0 +1,144 @@
+module Spree
+ module Admin
+ class RecordList
+ class FilterGroup
+ COMBINATORS = %i[and or].freeze
+
+ attr_accessor :combinator, :filters, :groups, :id
+
+ def initialize(combinator: :and, filters: [], groups: [], id: nil)
+ @combinator = combinator.to_sym
+ @filters = filters
+ @groups = groups
+ @id = id || SecureRandom.hex(8)
+ end
+
+ # Add a filter to this group
+ # @param filter [Filter]
+ def add_filter(filter)
+ @filters << filter
+ end
+
+ # Add a nested group
+ # @param group [FilterGroup]
+ def add_group(group)
+ @groups << group
+ end
+
+ # Remove a filter by id
+ # @param filter_id [String]
+ def remove_filter(filter_id)
+ @filters.reject! { |f| f.id == filter_id }
+ end
+
+ # Remove a nested group by id
+ # @param group_id [String]
+ def remove_group(group_id)
+ @groups.reject! { |g| g.id == group_id }
+ end
+
+ # Check if group is empty
+ # @return [Boolean]
+ def empty?
+ @filters.empty? && @groups.empty?
+ end
+
+ # Convert to ransack params format
+ # AND groups use regular params: { name_cont: 'value', status_eq: 'active' }
+ # OR groups use ransack groupings: { g: { '0' => { m: 'or', c: { ... } } } }
+ # @return [Hash]
+ def to_ransack_params
+ if combinator == :or
+ to_or_ransack_params
+ else
+ to_and_ransack_params
+ end
+ end
+
+ # Convert to hash for JSON serialization
+ # @return [Hash]
+ def to_h
+ {
+ combinator: combinator,
+ filters: filters.map(&:to_h),
+ groups: groups.map(&:to_h),
+ id: id
+ }
+ end
+
+ # Create from params hash
+ # @param params [Hash]
+ # @return [FilterGroup]
+ def self.from_params(params)
+ return new if params.blank?
+
+ params = params.symbolize_keys if params.respond_to?(:symbolize_keys)
+
+ group = new(
+ combinator: params[:combinator] || :and,
+ id: params[:id]
+ )
+
+ Array(params[:filters]).each do |filter_params|
+ filter = Filter.from_params(filter_params)
+ group.add_filter(filter) if filter
+ end
+
+ Array(params[:groups]).each do |group_params|
+ nested_group = from_params(group_params)
+ group.add_group(nested_group) if nested_group
+ end
+
+ group
+ end
+
+ private
+
+ def to_and_ransack_params
+ result = {}
+
+ filters.each do |filter|
+ result.merge!(filter.to_ransack_param)
+ end
+
+ groups.each_with_index do |group, index|
+ if group.combinator == :or
+ result[:g] ||= {}
+ result[:g][index.to_s] = build_or_grouping(group)
+ else
+ result.merge!(group.to_ransack_params)
+ end
+ end
+
+ result
+ end
+
+ def to_or_ransack_params
+ {
+ g: {
+ '0' => build_or_grouping(self)
+ }
+ }
+ end
+
+ def build_or_grouping(group)
+ conditions = {}
+
+ group.filters.each_with_index do |filter, index|
+ param = filter.to_ransack_param
+ next if param.empty?
+
+ conditions[index.to_s] = {
+ a: { '0' => { name: filter.field, p: filter.operator.to_s.sub('_', ''), v: { '0' => { value: filter.value } } } }
+ }
+ end
+
+ {
+ m: 'or',
+ c: conditions
+ }
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/models/spree/admin/record_list/query_builder.rb b/admin/app/models/spree/admin/record_list/query_builder.rb
new file mode 100644
index 0000000000..5dc05c4799
--- /dev/null
+++ b/admin/app/models/spree/admin/record_list/query_builder.rb
@@ -0,0 +1,109 @@
+module Spree
+ module Admin
+ class RecordList
+ class QueryBuilder
+ attr_reader :root_group, :record_list
+
+ def initialize(record_list)
+ @record_list = record_list
+ @root_group = FilterGroup.new(combinator: :and)
+ end
+
+ # Add a filter to the root group
+ # @param field [String] ransack attribute name
+ # @param operator [Symbol] filter operator
+ # @param value [Object] filter value
+ # @return [Filter]
+ def add_filter(field:, operator:, value:)
+ filter = Filter.new(field: field, operator: operator, value: value)
+ @root_group.add_filter(filter)
+ filter
+ end
+
+ # Add a nested group
+ # @param combinator [Symbol] :and or :or
+ # @return [FilterGroup]
+ def add_group(combinator: :and)
+ group = FilterGroup.new(combinator: combinator)
+ @root_group.add_group(group)
+ group
+ end
+
+ # Clear all filters
+ def clear
+ @root_group = FilterGroup.new(combinator: :and)
+ end
+
+ # Check if there are any filters
+ # @return [Boolean]
+ def empty?
+ @root_group.empty?
+ end
+
+ # Convert to ransack params format
+ # @return [Hash]
+ def to_ransack_params
+ @root_group.to_ransack_params
+ end
+
+ # Convert to JSON string for storing in hidden field
+ # @return [String]
+ def to_json_state
+ @root_group.to_h.to_json
+ end
+
+ # Load state from params hash
+ # @param params [Hash]
+ def load_from_params(params)
+ @root_group = FilterGroup.from_params(params)
+ end
+
+ # Load state from JSON string
+ # @param json_string [String]
+ def load_from_json(json_string)
+ return if json_string.blank?
+
+ params = JSON.parse(json_string, symbolize_names: true)
+ @root_group = FilterGroup.from_params(params)
+ rescue JSON::ParserError
+ @root_group = FilterGroup.new(combinator: :and)
+ end
+
+ # Get available fields for filtering based on record_list configuration
+ # @return [Array<Hash>]
+ def available_fields
+ @record_list.filterable_columns.map do |column|
+ {
+ key: column.ransack_attribute,
+ label: column.resolve_label,
+ type: column.filter_type.to_s,
+ operators: column.operators.map(&:to_s),
+ value_options: format_value_options(column.value_options),
+ search_url: column.search_url
+ }
+ end
+ end
+
+ # Get available operators for UI
+ # @return [Array<Hash>]
+ def available_operators
+ Filter.operators_for_select
+ end
+
+ private
+
+ def format_value_options(options)
+ return nil if options.blank?
+
+ options.map do |opt|
+ if opt.is_a?(Hash)
+ { value: opt[:value] || opt['value'], label: opt[:label] || opt['label'] }
+ else
+ { value: opt.to_s, label: opt.to_s.humanize }
+ end
+ end
+ end
+ end
+ end
+ end
+end
diff --git a/admin/app/views/spree/admin/products/index.html.erb b/admin/app/views/spree/admin/products/index.html.erb
index 74890e49a3..662933f13a 100644
--- a/admin/app/views/spree/admin/products/index.html.erb
+++ b/admin/app/views/spree/admin/products/index.html.erb
@@ -11,20 +11,7 @@
<%= render_admin_partials(:products_header_partials) %>
-<div class="card-lg">
- <% if params[:frame_name].present? %>
- <%= turbo_frame_tag params[:frame_name], autoscroll: true, data: { autoscroll_block: :start, autoscroll_behavior: :smooth } do %>
- <%= render 'filters', frame_name: params[:frame_name] %>
- <%= render 'list' %>
- <% end %>
- <% else %>
- <%= turbo_frame_tag "products", autoscroll: true, data: { autoscroll_behavior: :smooth, turbo_action: 'advance' } do %>
- <%= render 'spree/admin/shared/export_modal', export_type: Spree::Exports::Products %>
- <%= render 'filters' %>
- <%= render 'list' %>
- <% end %>
- <% end %>
-</div>
+<%= render_record_list @collection, :products, bulk_operations: true %>
<p class="documentation-link-container">
Learn more about
diff --git a/admin/app/views/spree/admin/record_lists/_column_selector.html.erb b/admin/app/views/spree/admin/record_lists/_column_selector.html.erb
new file mode 100644
index 0000000000..a20ff78551
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_column_selector.html.erb
@@ -0,0 +1,53 @@
+<%# locals: (record_list:, list_key:, selected_columns:) %>
+<div data-controller="column-selector">
+ <%= form_with url: spree.admin_record_list_columns_path,
+ method: :post,
+ data: { turbo_frame: '_top' } do |f| %>
+ <%= hidden_field_tag :list_key, list_key %>
+
+ <%= dropdown(portal: false) do %>
+ <%= dropdown_toggle(class: 'btn-light btn-sm flex items-center gap-1') do %>
+ <%= icon 'columns-3', class: 'w-4 h-4' %>
+ <span><%= Spree.t('admin.record_lists.columns') %></span>
+ <%= icon 'chevron-down', class: 'w-3 h-3' %>
+ <% end %>
+
+ <%= dropdown_menu(class: 'min-w-[250px] p-4') do %>
+ <div class="mb-3">
+ <h6 class="font-semibold text-gray-700 text-sm">
+ <%= Spree.t('admin.record_lists.visible_columns') %>
+ </h6>
+ </div>
+
+ <div class="space-y-2 max-h-[300px] overflow-y-auto mb-4">
+ <% record_list.available_columns.each do |column| %>
+ <% next unless column.visible?(self) %>
+ <% is_selected = selected_columns.nil? ? column.default? : selected_columns.include?(column.key) %>
+ <label class="flex items-center gap-2 cursor-pointer hover:bg-gray-50 p-1.5 rounded">
+ <%= check_box_tag 'columns[]',
+ column.key,
+ is_selected,
+ id: "column_#{column.key}",
+ data: {
+ column_selector_target: 'checkbox',
+ default: column.default?
+ },
+ class: 'form-checkbox rounded' %>
+ <span class="text-sm text-gray-700"><%= column.resolve_label %></span>
+ </label>
+ <% end %>
+ </div>
+
+ <div class="flex gap-2 pt-3 border-t border-gray-200">
+ <button type="button"
+ class="btn btn-sm btn-light flex-1"
+ data-action="column-selector#reset">
+ <%= Spree.t('admin.record_lists.reset_to_default') %>
+ </button>
+ <%= f.submit Spree.t('admin.record_lists.apply'),
+ class: 'btn btn-sm btn-primary flex-1 cursor-pointer' %>
+ </div>
+ <% end %>
+ <% end %>
+ <% end %>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/_filter_group.html.erb b/admin/app/views/spree/admin/record_lists/_filter_group.html.erb
new file mode 100644
index 0000000000..8b96d78da1
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_filter_group.html.erb
@@ -0,0 +1,33 @@
+<%# Template for a nested OR filter group - populated by JavaScript %>
+<div class="p-4 border-2 border-dashed border-gray-300 rounded-lg bg-white"
+ data-group-id=""
+ data-combinator="or">
+ <div class="flex items-center justify-between mb-3">
+ <div class="flex items-center gap-2">
+ <span class="text-sm text-gray-600"><%= Spree.t('admin.record_lists.match') %></span>
+ <button type="button"
+ class="btn btn-sm btn-outline-secondary px-2 py-1"
+ data-action="query-builder#toggleGroupCombinator">
+ <span data-group-combinator-label>OR</span>
+ </button>
+ <span class="text-sm text-gray-600"><%= Spree.t('admin.record_lists.of_the_following') %></span>
+ </div>
+ <button type="button"
+ class="btn btn-sm btn-light text-red-600 hover:text-red-700 hover:bg-red-50 p-1.5"
+ data-action="query-builder#removeGroup"
+ title="<%= Spree.t(:remove) %>">
+ <%= icon 'x', class: 'w-4 h-4' %>
+ </button>
+ </div>
+
+ <div data-group-filters-container class="space-y-3 mb-3">
+ <%# Filter rows within this group will be added here %>
+ </div>
+
+ <button type="button"
+ class="btn btn-sm btn-light flex items-center gap-1"
+ data-action="query-builder#addFilterToGroup">
+ <%= icon 'plus', class: 'w-4 h-4' %>
+ <%= Spree.t('admin.record_lists.add_filter') %>
+ </button>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/_filter_row.html.erb b/admin/app/views/spree/admin/record_lists/_filter_row.html.erb
new file mode 100644
index 0000000000..84418647b7
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_filter_row.html.erb
@@ -0,0 +1,29 @@
+<%# Template for a single filter row - populated by JavaScript %>
+<div class="flex items-center gap-2 p-3 bg-gray-50 rounded-lg" data-filter-id="">
+ <select class="form-select flex-1 text-sm"
+ data-field-select
+ data-action="change->query-builder#onFieldChange">
+ <option value=""><%= Spree.t('admin.record_lists.select_field') %></option>
+ </select>
+
+ <select class="form-select flex-shrink-0 w-[160px] text-sm"
+ data-operator-select
+ data-action="change->query-builder#onOperatorChange">
+ <option value="eq"><%= Spree.t('admin.record_lists.operators.equals') %></option>
+ </select>
+
+ <div data-value-container class="flex-1">
+ <input type="text"
+ class="form-input text-sm"
+ placeholder="<%= Spree.t('admin.record_lists.enter_value') %>"
+ data-value-input
+ data-action="input->query-builder#onValueChange">
+ </div>
+
+ <button type="button"
+ class="btn btn-sm btn-light text-red-600 hover:text-red-700 hover:bg-red-50 p-1.5"
+ data-action="query-builder#removeFilter"
+ title="<%= Spree.t(:remove) %>">
+ <%= icon 'x', class: 'w-4 h-4' %>
+ </button>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/_query_builder.html.erb b/admin/app/views/spree/admin/record_lists/_query_builder.html.erb
new file mode 100644
index 0000000000..44e6da5942
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_query_builder.html.erb
@@ -0,0 +1,92 @@
+<%# locals: (record_list:, list_key:) %>
+<% fields_json = query_builder_fields_json(record_list) %>
+<% operators_json = query_builder_operators_json %>
+<% current_state = params[:query_state] || '{}' %>
+
+<div data-controller="dialog">
+ <button type="button"
+ class="btn btn-light btn-sm flex items-center gap-1"
+ data-action="dialog#open">
+ <%= icon 'filter', class: 'w-4 h-4' %>
+ <span><%= Spree.t('admin.record_lists.filters') %></span>
+ </button>
+
+ <dialog class="drawer"
+ data-dialog-target="dialog"
+ id="query-builder-drawer-<%= list_key %>">
+ <%= drawer_header(Spree.t('admin.record_lists.filter_builder'), 'dialog') %>
+
+ <div data-controller="query-builder"
+ data-query-builder-fields-value="<%= fields_json %>"
+ data-query-builder-operators-value="<%= operators_json %>">
+
+ <%= form_with url: url_for, method: :get, data: { turbo_frame: '_top', query_builder_target: 'form', action: 'submit->query-builder#submitForm' } do |f| %>
+ <div class="drawer-body">
+ <div class="mb-4 flex items-center gap-2 flex-wrap">
+ <span class="text-sm text-gray-600">
+ <%= Spree.t('admin.record_lists.match') %>
+ </span>
+ <button type="button"
+ class="btn btn-sm btn-outline-secondary px-2 py-1"
+ data-action="query-builder#toggleCombinator"
+ data-query-builder-target="combinatorButton">
+ <span data-query-builder-target="combinatorLabel">AND</span>
+ </button>
+ <span class="text-sm text-gray-600">
+ <%= Spree.t('admin.record_lists.of_the_following') %>
+ </span>
+ </div>
+
+ <div data-query-builder-target="filtersContainer" class="space-y-3 mb-4">
+ <%# Filter rows will be added here dynamically %>
+ </div>
+
+ <div data-query-builder-target="groupsContainer" class="space-y-3 mb-4">
+ <%# Nested groups will be added here %>
+ </div>
+
+ <div class="flex gap-2">
+ <button type="button"
+ class="btn btn-sm btn-light flex items-center gap-1"
+ data-action="query-builder#addFilter">
+ <%= icon 'plus', class: 'w-4 h-4' %>
+ <%= Spree.t('admin.record_lists.add_filter') %>
+ </button>
+ <button type="button"
+ class="btn btn-sm btn-light flex items-center gap-1"
+ data-action="query-builder#addOrGroup">
+ <%= icon 'brackets', class: 'w-4 h-4' %>
+ <%= Spree.t('admin.record_lists.add_or_group') %>
+ </button>
+ </div>
+
+ <input type="hidden"
+ name="query_state"
+ data-query-builder-target="hiddenInput"
+ value="<%= h current_state %>">
+ </div>
+
+ <div class="drawer-footer">
+ <%= drawer_discard_button('dialog') %>
+ <button type="button"
+ class="btn btn-light"
+ data-action="query-builder#clear">
+ <%= Spree.t('admin.record_lists.clear_all') %>
+ </button>
+ <%= f.submit Spree.t('admin.record_lists.apply_filters'),
+ class: 'btn btn-primary cursor-pointer' %>
+ </div>
+ <% end %>
+
+ <%# Filter row template %>
+ <template data-query-builder-target="filterTemplate">
+ <%= render 'spree/admin/record_lists/filter_row' %>
+ </template>
+
+ <%# Filter group template %>
+ <template data-query-builder-target="groupTemplate">
+ <%= render 'spree/admin/record_lists/filter_group' %>
+ </template>
+ </div>
+ </dialog>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/_record_list.html.erb b/admin/app/views/spree/admin/record_lists/_record_list.html.erb
new file mode 100644
index 0000000000..cc1eae3542
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_record_list.html.erb
@@ -0,0 +1,49 @@
+<%# locals: (collection:, record_list:, list_key:, selected_columns: nil, frame_name: nil, bulk_operations: false, sortable: false) %>
+<% frame_name ||= controller_name %>
+<% columns = record_list.visible_columns(selected_columns, self) %>
+<% current_sort = params.dig(:q, :s) %>
+<% search_param = record_list.respond_to?(:search_param) ? record_list.search_param : :name_cont %>
+<% search_placeholder = (record_list.respond_to?(:search_placeholder) && record_list.search_placeholder) || [Spree.t(:search), controller_name.humanize.downcase].join(' ') %>
+
+<%= turbo_frame_tag frame_name, autoscroll: true, data: { autoscroll_block: :start, turbo_action: 'advance' } do %>
+ <div class="card-lg" data-controller="record-list" data-record-list-url-value="<%= request.path %>">
+ <div class="p-4 border-b border-gray-200">
+ <%= search_form_for @search, url: url_for, html: { data: { turbo_frame: frame_name, turbo_action: 'advance' } } do |f| %>
+ <div class="flex flex-col lg:flex-row gap-3 items-start lg:items-center justify-between">
+ <div class="flex gap-2 items-center flex-wrap grow">
+ <div class="form-input flex items-center py-0 focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-blue-500 grow max-lg:max-w-[300px] mr-auto h-[2.125rem] transition-all duration-100 ease-in-out">
+ <%= icon "search", class: "mr-4 text-gray-600" %>
+ <%= search_field_tag "q[#{search_param}]",
+ params.dig(:q, search_param),
+ class: "outline-none border-0 h-full focus:border-0 focus:ring-0 p-0 text-base w-full",
+ placeholder: search_placeholder %>
+ </div>
+ <%= render 'spree/admin/record_lists/query_builder', record_list: record_list, list_key: list_key %>
+ </div>
+
+ <div class="flex gap-2 items-center">
+ <%= record_list_sort_dropdown(record_list, current_sort) %>
+ <%= render 'spree/admin/record_lists/column_selector',
+ record_list: record_list,
+ list_key: list_key,
+ selected_columns: selected_columns %>
+ </div>
+ </div>
+ <% end %>
+ </div>
+
+ <% if collection.any? %>
+ <%= render 'spree/admin/record_lists/table',
+ collection: collection,
+ columns: columns,
+ record_list: record_list,
+ bulk_operations: bulk_operations,
+ sortable: sortable %>
+
+ <%= render 'spree/admin/shared/index_table_options', collection: collection %>
+ <% else %>
+ <%= render 'spree/admin/shared/no_resource_found',
+ new_object_url: (new_object_url if respond_to?(:new_object_url) && can?(:create, record_list.model_class)) %>
+ <% end %>
+ </div>
+<% end %>
diff --git a/admin/app/views/spree/admin/record_lists/_row_actions.html.erb b/admin/app/views/spree/admin/record_lists/_row_actions.html.erb
new file mode 100644
index 0000000000..8744113f73
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_row_actions.html.erb
@@ -0,0 +1,24 @@
+<%# locals: (record:) %>
+<div class="flex items-center justify-end gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
+ <% if respond_to?(:edit_object_url) && can?(:update, record) %>
+ <%= link_to edit_object_url(record),
+ class: 'btn btn-sm btn-light',
+ title: Spree.t(:edit),
+ data: { 'turbo-frame': '_top' } do %>
+ <%= icon 'pencil', class: 'w-4 h-4' %>
+ <% end %>
+ <% end %>
+
+ <% if respond_to?(:object_url) && can?(:destroy, record) %>
+ <%= link_to object_url(record),
+ method: :delete,
+ class: 'btn btn-sm btn-light text-red-600 hover:text-red-700',
+ title: Spree.t(:delete),
+ data: {
+ turbo_method: :delete,
+ turbo_confirm: Spree.t(:are_you_sure)
+ } do %>
+ <%= icon 'trash', class: 'w-4 h-4' %>
+ <% end %>
+ <% end %>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/_table.html.erb b/admin/app/views/spree/admin/record_lists/_table.html.erb
new file mode 100644
index 0000000000..b600ae176d
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_table.html.erb
@@ -0,0 +1,92 @@
+<%# locals: (collection:, columns:, record_list:, bulk_operations: false, sortable: false) %>
+<% if bulk_operations %>
+ <div data-controller="bulk-operation bulk-dialog" data-action="keydown.esc->bulk-operation#cancel" tabindex="0">
+ <%= form_tag url_for(action: :index), method: :put, data: { 'bulk-operation-target': 'form' } do %>
+ <%= render 'spree/admin/shared/bulk_modal' %>
+
+ <div class="table-responsive">
+ <table class="table" id="listing_<%= controller_name %>">
+ <thead>
+ <tr>
+ <th scope="col" class="pr-0 w-5">
+ <%= bulk_operations_select_all_checkbox %>
+ </th>
+
+ <% columns.each do |column| %>
+ <th scope="col" class="<%= column_header_class(column) %>">
+ <% if column.sortable? && @search %>
+ <%= sort_link @search, column.ransack_attribute, column.resolve_label,
+ default_order: 'desc',
+ title: "#{controller_name}_listing_#{column.key}_title" %>
+ <% else %>
+ <%= column.resolve_label %>
+ <% end %>
+ </th>
+ <% end %>
+
+ <th scope="col" class="w-10"></th>
+ </tr>
+ </thead>
+ <tbody
+ <% if sortable %>
+ data-controller="sortable"
+ data-sortable-handle-value=".move-handle"
+ data-sortable-resource-name-value="<%= controller_name.singularize %>"
+ data-sortable-response-kind-value="turbo-stream"
+ <% end %>
+ >
+ <%= render partial: 'spree/admin/record_lists/table_row',
+ collection: collection,
+ as: :record,
+ locals: {
+ columns: columns,
+ record_list: record_list,
+ bulk_operations: bulk_operations,
+ sortable: sortable
+ } %>
+ </tbody>
+ </table>
+ </div>
+ <% end %>
+ </div>
+<% else %>
+ <div class="table-responsive">
+ <table class="table" id="listing_<%= controller_name %>">
+ <thead>
+ <tr>
+ <% columns.each do |column| %>
+ <th scope="col" class="<%= column_header_class(column) %>">
+ <% if column.sortable? && @search %>
+ <%= sort_link @search, column.ransack_attribute, column.resolve_label,
+ default_order: 'desc',
+ title: "#{controller_name}_listing_#{column.key}_title" %>
+ <% else %>
+ <%= column.resolve_label %>
+ <% end %>
+ </th>
+ <% end %>
+
+ <th scope="col" class="w-10"></th>
+ </tr>
+ </thead>
+ <tbody
+ <% if sortable %>
+ data-controller="sortable"
+ data-sortable-handle-value=".move-handle"
+ data-sortable-resource-name-value="<%= controller_name.singularize %>"
+ data-sortable-response-kind-value="turbo-stream"
+ <% end %>
+ >
+ <%= render partial: 'spree/admin/record_lists/table_row',
+ collection: collection,
+ as: :record,
+ locals: {
+ columns: columns,
+ record_list: record_list,
+ bulk_operations: false,
+ sortable: sortable
+ } %>
+ </tbody>
+ </table>
+ </div>
+<% end %>
diff --git a/admin/app/views/spree/admin/record_lists/_table_row.html.erb b/admin/app/views/spree/admin/record_lists/_table_row.html.erb
new file mode 100644
index 0000000000..b142816ac9
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/_table_row.html.erb
@@ -0,0 +1,26 @@
+<%# locals: (record:, columns:, record_list:, bulk_operations: false, sortable: false) %>
+<tr id="<%= dom_id record %>" class="group">
+ <% if bulk_operations %>
+ <td class="pr-0 w-5">
+ <%= bulk_operations_checkbox(record) %>
+ </td>
+ <% end %>
+
+ <% columns.each_with_index do |column, index| %>
+ <td class="<%= column_cell_class(column) %>">
+ <% if index == 0 %>
+ <%= link_to edit_object_url(record),
+ class: 'flex items-center w-full no-underline hover:text-primary',
+ data: { 'turbo-frame': '_top' } do %>
+ <%= render_column_value(record, column, record_list) %>
+ <% end %>
+ <% else %>
+ <%= render_column_value(record, column, record_list) %>
+ <% end %>
+ </td>
+ <% end %>
+
+ <td class="w-10 text-right">
+ <%= render 'spree/admin/record_lists/row_actions', record: record %>
+ </td>
+</tr>
diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erb
new file mode 100644
index 0000000000..1bf4065846
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/columns/_product_inventory.html.erb
@@ -0,0 +1,3 @@
+<%# locals: (record:, column:, value:) %>
+<% product = record %>
+<%= display_inventory(product) %>
diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erb
new file mode 100644
index 0000000000..4703828e51
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/columns/_product_name.html.erb
@@ -0,0 +1,8 @@
+<%# locals: (record:, column:, value:) %>
+<% product = record %>
+<div class="flex items-center gap-3">
+ <%= render 'spree/admin/shared/product_image', object: product %>
+ <span class="text-gray-900 font-medium">
+ <%= product.name %>
+ </span>
+</div>
diff --git a/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erb b/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erb
new file mode 100644
index 0000000000..ab73fd56c4
--- /dev/null
+++ b/admin/app/views/spree/admin/record_lists/columns/_product_status.html.erb
@@ -0,0 +1,6 @@
+<%# locals: (record:, column:, value:) %>
+<% product = record %>
+<div class="text-center">
+ <%= product_status(product) %>
+ <%= help_bubble(Spree.t("admin.products.help_bubble")) %>
+</div>
diff --git a/admin/config/initializers/record_lists.rb b/admin/config/initializers/record_lists.rb
new file mode 100644
index 0000000000..5da46ee761
--- /dev/null
+++ b/admin/config/initializers/record_lists.rb
@@ -0,0 +1,331 @@
+# Default column configurations for Spree Admin Record Lists
+#
+# This initializer registers the default record lists and their columns.
+# Developers can extend these in their own initializers by:
+#
+# Rails.application.config.after_initialize do
+# Spree.admin.record_lists.products.add :custom_column, type: :string, default: true
+# Spree.admin.record_lists.products.remove :sku
+# Spree.admin.record_lists.products.update :name, position: 5
+# Spree.admin.record_lists.products.insert_after :name, :vendor, type: :string
+# end
+
+Rails.application.config.after_initialize do
+ # Register Products record list
+ Spree.admin.record_lists.register(:products, model_class: Spree::Product, search_param: :multi_search)
+
+ # Product name with image (custom partial)
+ Spree.admin.record_lists.products.add :name,
+ label: :name,
+ type: :custom,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 10,
+ partial: 'spree/admin/record_lists/columns/product_name'
+
+ # Product status with help bubble (custom partial)
+ Spree.admin.record_lists.products.add :status,
+ label: :status,
+ type: :custom,
+ filter_type: :status,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 20,
+ partial: 'spree/admin/record_lists/columns/product_status',
+ value_options: [
+ { value: 'draft', label: 'Draft' },
+ { value: 'active', label: 'Active' },
+ { value: 'archived', label: 'Archived' }
+ ]
+
+ # Inventory display (custom partial)
+ Spree.admin.record_lists.products.add :inventory,
+ label: :inventory,
+ type: :custom,
+ sortable: false,
+ filterable: false,
+ default: true,
+ position: 25,
+ partial: 'spree/admin/record_lists/columns/product_inventory'
+
+ Spree.admin.record_lists.products.add :sku,
+ label: :sku,
+ type: :string,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 30,
+ ransack_attribute: 'master_sku',
+ method: ->(product) { product.sku }
+
+ Spree.admin.record_lists.products.add :price,
+ label: :price,
+ type: :currency,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 40,
+ ransack_attribute: 'master_price',
+ method: ->(product) { product.price }
+
+ Spree.admin.record_lists.products.add :created_at,
+ label: :created_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 50
+
+ Spree.admin.record_lists.products.add :updated_at,
+ label: :updated_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 60
+
+ # Stock filter (filter-only, not displayed as column)
+ Spree.admin.record_lists.products.add :in_stock,
+ label: 'In Stock',
+ type: :boolean,
+ filter_type: :boolean,
+ sortable: false,
+ filterable: true,
+ displayable: false,
+ default: false,
+ position: 70,
+ ransack_attribute: 'in_stock_items'
+
+ # Taxons - displayed as comma-separated list, filtered via autocomplete
+ Spree.admin.record_lists.products.add :taxons,
+ label: :taxons,
+ type: :association,
+ filter_type: :autocomplete,
+ sortable: false,
+ filterable: true,
+ default: false,
+ position: 80,
+ ransack_attribute: 'taxons_id',
+ operators: %i[in],
+ search_url: '/admin/taxons/select_options.json',
+ method: ->(product) { product.taxons.map(&:pretty_name).join(', ') }
+
+ # Tags - displayed as comma-separated list, filtered via autocomplete
+ Spree.admin.record_lists.products.add :tags,
+ label: :tags,
+ type: :association,
+ filter_type: :autocomplete,
+ sortable: false,
+ filterable: true,
+ default: false,
+ position: 85,
+ ransack_attribute: 'tags_name',
+ operators: %i[in],
+ search_url: '/admin/tags/select_options.json?taggable_type=Spree::Product',
+ method: ->(product) { product.tag_list.join(', ') }
+
+ # Register Orders record list
+ Spree.admin.record_lists.register(:orders, model_class: Spree::Order, search_param: :number_or_email_cont)
+
+ Spree.admin.record_lists.orders.add :number,
+ label: :order_number,
+ type: :link,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 10
+
+ Spree.admin.record_lists.orders.add :state,
+ label: :state,
+ type: :status,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 20,
+ value_options: [
+ { value: 'cart', label: 'Cart' },
+ { value: 'address', label: 'Address' },
+ { value: 'delivery', label: 'Delivery' },
+ { value: 'payment', label: 'Payment' },
+ { value: 'confirm', label: 'Confirm' },
+ { value: 'complete', label: 'Complete' },
+ { value: 'canceled', label: 'Canceled' }
+ ]
+
+ Spree.admin.record_lists.orders.add :payment_state,
+ label: :payment_state,
+ type: :status,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 30,
+ value_options: [
+ { value: 'balance_due', label: 'Balance Due' },
+ { value: 'credit_owed', label: 'Credit Owed' },
+ { value: 'failed', label: 'Failed' },
+ { value: 'paid', label: 'Paid' },
+ { value: 'void', label: 'Void' }
+ ]
+
+ Spree.admin.record_lists.orders.add :shipment_state,
+ label: :shipment_state,
+ type: :status,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 35,
+ value_options: [
+ { value: 'backorder', label: 'Backorder' },
+ { value: 'canceled', label: 'Canceled' },
+ { value: 'partial', label: 'Partial' },
+ { value: 'pending', label: 'Pending' },
+ { value: 'ready', label: 'Ready' },
+ { value: 'shipped', label: 'Shipped' }
+ ]
+
+ Spree.admin.record_lists.orders.add :total,
+ label: :total,
+ type: :currency,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 40,
+ method: ->(order) { order.display_total }
+
+ Spree.admin.record_lists.orders.add :email,
+ label: :email,
+ type: :string,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 45
+
+ Spree.admin.record_lists.orders.add :completed_at,
+ label: :completed_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 50
+
+ Spree.admin.record_lists.orders.add :created_at,
+ label: :created_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 60
+
+ # Register Users record list
+ Spree.admin.record_lists.register(:users, model_class: Spree.user_class, search_param: :email_cont)
+
+ Spree.admin.record_lists.users.add :email,
+ label: :email,
+ type: :link,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 10
+
+ Spree.admin.record_lists.users.add :first_name,
+ label: :first_name,
+ type: :string,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 20,
+ ransack_attribute: 'bill_address_firstname'
+
+ Spree.admin.record_lists.users.add :last_name,
+ label: :last_name,
+ type: :string,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 30,
+ ransack_attribute: 'bill_address_lastname'
+
+ Spree.admin.record_lists.users.add :created_at,
+ label: :created_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 40
+
+ # Register Promotions record list
+ Spree.admin.record_lists.register(:promotions, model_class: Spree::Promotion, search_param: :name_cont)
+
+ Spree.admin.record_lists.promotions.add :name,
+ label: :name,
+ type: :link,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 10
+
+ Spree.admin.record_lists.promotions.add :code,
+ label: :code,
+ type: :string,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 20
+
+ Spree.admin.record_lists.promotions.add :starts_at,
+ label: :starts_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 30
+
+ Spree.admin.record_lists.promotions.add :expires_at,
+ label: :expires_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 40
+
+ # Register Posts record list
+ Spree.admin.record_lists.register(:posts, model_class: Spree::Post, search_param: :title_cont)
+
+ Spree.admin.record_lists.posts.add :title,
+ label: :title,
+ type: :link,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 10
+
+ Spree.admin.record_lists.posts.add :status,
+ label: :status,
+ type: :status,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 20,
+ value_options: [
+ { value: 'draft', label: 'Draft' },
+ { value: 'published', label: 'Published' }
+ ]
+
+ Spree.admin.record_lists.posts.add :published_at,
+ label: :published_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: true,
+ position: 30
+
+ Spree.admin.record_lists.posts.add :created_at,
+ label: :created_at,
+ type: :datetime,
+ sortable: true,
+ filterable: true,
+ default: false,
+ position: 40
+end
diff --git a/admin/config/locales/en.yml b/admin/config/locales/en.yml
index b615334c1d..bdee044f42 100644
--- a/admin/config/locales/en.yml
+++ b/admin/config/locales/en.yml
@@ -338,3 +338,34 @@ en:
subscriptions: Subscriptions
time_of_last_event: Time of Last Event
webhooks_events: Webhooks Events
+ record_lists:
+ add_filter: Add filter
+ add_or_group: Add OR group
+ apply: Apply
+ apply_filters: Apply Filters
+ clear_all: Clear All
+ columns: Columns
+ enter_value: Enter value...
+ filter_builder: Filter Builder
+ filters: Filters
+ match: Match
+ of_the_following: of the following
+ operators:
+ contains: contains
+ does_not_contain: does not contain
+ ends_with: ends with
+ equals: equals
+ greater_than: greater than
+ greater_than_or_equal: greater than or equal
+ is_any_of: is any of
+ is_empty: is empty
+ is_none_of: is none of
+ is_not_empty: is not empty
+ less_than: less than
+ less_than_or_equal: less than or equal
+ not_equals: does not equal
+ starts_with: starts with
+ reset_to_default: Reset to Default
+ select_field: Select field...
+ sort_by: Sort by
+ visible_columns: Visible Columns
diff --git a/admin/config/routes.rb b/admin/config/routes.rb
index 9a108333bd..647d0dcb8b 100644
--- a/admin/config/routes.rb
+++ b/admin/config/routes.rb
@@ -44,6 +44,7 @@ Spree::Core::Engine.add_routes do
resources :classifications, only: %i[index new create update destroy]
end
get '/taxons/select_options' => 'taxons#select_options', as: :taxons_select_options, defaults: { format: :json }
+ get '/tags/select_options' => 'tags#select_options', as: :tags_select_options, defaults: { format: :json }
# media library
resources :assets, only: [:create, :edit, :update, :destroy] do
@@ -230,6 +231,9 @@ Spree::Core::Engine.add_routes do
get '/errors/:path', to: 'errors#show', as: :pathed_errors
end
+ # record list columns (for session-based column selection)
+ post 'record_list_columns', to: 'record_list_columns#update', as: :record_list_columns
+
# dashboard
resource :dashboard, controller: 'dashboard'
get '/dashboard/analytics', to: 'dashboard#analytics', as: :dashboard_analytics
diff --git a/admin/lib/spree/admin.rb b/admin/lib/spree/admin.rb
index 205854f0cb..cb57e17cdb 100644
--- a/admin/lib/spree/admin.rb
+++ b/admin/lib/spree/admin.rb
@@ -37,5 +37,9 @@ module Spree
def navigation
Rails.application.config.spree_admin.navigation
end
+
+ def record_lists
+ Rails.application.config.spree_admin.record_lists
+ end
end
end
diff --git a/admin/lib/spree/admin/engine.rb b/admin/lib/spree/admin/engine.rb
index d4273a5ea7..d9a95ccea1 100644
--- a/admin/lib/spree/admin/engine.rb
+++ b/admin/lib/spree/admin/engine.rb
@@ -126,7 +126,8 @@ module Spree
:vendors_nav_partials,
:zones_actions_partials,
:zones_header_partials,
- :navigation
+ :navigation,
+ :record_lists
)
class NavigationEnvironment
@@ -178,6 +179,58 @@ module Spree
end
end
+ class RecordListsEnvironment
+ def initialize
+ @registries = {}
+ end
+
+ # Register a new record list
+ # @param name [Symbol] The name of the record list (e.g., :products, :orders)
+ # @param model_class [Class, nil] The model class for this list
+ # @param search_param [Symbol] The ransack parameter for text search (default: :name_cont)
+ # @param search_placeholder [String, nil] Custom placeholder for search field
+ # @return [Spree::Admin::RecordList] The record list instance
+ def register(name, model_class: nil, search_param: :name_cont, search_placeholder: nil)
+ name = name.to_sym
+ @registries[name] ||= Spree::Admin::RecordList.new(name, model_class: model_class, search_param: search_param, search_placeholder: search_placeholder)
+ end
+
+ # Get a registered record list
+ # @param name [Symbol] The name of the record list
+ # @return [Spree::Admin::RecordList] The record list instance
+ # @raise [NoMethodError] if the record list hasn't been registered
+ def get(name)
+ name = name.to_sym
+ @registries[name] || raise(NoMethodError, "Record list '#{name}' has not been registered. Use Spree.admin.record_lists.register(:#{name}) first.")
+ end
+
+ # Check if a record list is registered
+ # @param name [Symbol] The record list name
+ # @return [Boolean]
+ def registered?(name)
+ @registries.key?(name.to_sym)
+ end
+
+ # List all registered record lists
+ # @return [Array<Symbol>]
+ def registries
+ @registries.keys
+ end
+
+ # Define accessor methods for registered record lists
+ def method_missing(method_name, *args)
+ if method_name.to_s.end_with?('=')
+ super
+ else
+ get(method_name)
+ end
+ end
+
+ def respond_to_missing?(method_name, include_private = false)
+ method_name.to_s.end_with?('=') ? false : registered?(method_name)
+ end
+ end
+
# Add app/subscribers to autoload paths
config.paths.add 'app/subscribers', eager_load: true
@@ -254,6 +307,9 @@ module Spree
app.config.spree_admin.navigation.register_context(:returns_tabs)
app.config.spree_admin.navigation.register_context(:developers_tabs)
app.config.spree_admin.navigation.register_context(:audit_tabs)
+
+ # Register record lists environment
+ app.config.spree_admin.record_lists = RecordListsEnvironment.new
end
# Add admin event subscribers