Skip to content

Main Navigation Docs Apps Themes APIs Frontends

HTTP APIs

Meteor

Meteor Admin SDK

Meteor Component Library

Meteor Icon Kit

Design

shopware.design

Releases

Learning

Appearance

Sidebar Navigation

Docs

Concepts

Commerce

Catalog

Products

Categories

Sales Channels

Checkout

Cart

Orders

Payments

Content

Shopping Experiences (CMS)

Cookie Consent Management

Framework

Architecture

Storefront

Administration

Rule system

Rule concepts

Rule evaluation

Data Abstraction Layer

Messaging

Migrations

HTTP Cache

Elasticsearch

Flow

System Check

In-App Purchases

Extensions

Apps

Plugins

API

Store API

Admin API

Translations

Built-in Translation Handling

Fallback language selection

Guides

Development

Accessibility

Storefront Accessibility

Accessibility Checklist

Extensions

Extension Architecture

Extendability

Final and Internal Annotation

Public API and Internal Annotation

Code Structure

APIs

API Flows

Create a Product and Complete Checkout

Authentication and API Requests

Search Criteria

Request Headers

Partial Data Loading

Generated Reference

Monetization

Quality Guidelines for Store Extensions

Store Review Errors

In-App Purchases (IAP)

Tooling

Hot Module Reloading using watchers

Shopware Toolbox

Fixture Bundle

Troubleshooting

DAL Reference

Fields Reference

EnumField reference

Flags Reference

Filters Reference

Aggregations Reference

Flow Reference

Rules Reference

Testing

Playwright E2E testing

Install & Configure

Deployment

Fixtures

Page Objects

Actor Pattern

Test Suite Types

Test Suite

Local development

Language Agnostic Testing

Test Data Service

Best Practices

Legacy

Cypress

Best practices on writing end-to-end tests

Unit Testing

Jest unit tests in Shopware's administration

Jest unit tests in Shopware's storefront

PHP Unit Testing

CI

Testing guidelines for extensions

Start Developing

Shopware 6 Installation

System Requirements

Project Structure Overview

Advanced Docker Config

Legacy Setups

Install with Docker

Install with Devenv

Install with Symfony CLI

Additional Devenv Config

Extensions

Apps

App SDKs

JavaScript App Server SDK

Getting Started

Lifecycle

Context

Signing Responses

HTTP-client

Integrations

External Frontend

Official Symfony bundle

Official PHP SDK

Getting started

Lifecycle

Context

Signing

HTTP-client

Events

App Scripts

Cart Manipulation

Starter Guide - Add an API endpoint

Data Loading

Custom Endpoints

Storefront

Apps as themes

Customize templates

Add Cookies to the Consent Manager

Administration

Meteor Admin SDK

Add custom action button

Add custom module

Add CMS element

Adding Translations

Create Admin Extensions

Flow Builder

Add custom flow action from app system

Add custom flow trigger from app system

Custom Data

Custom fields

Custom entities

Content

CMS

Add custom CMS blocks

Rule Builder

Add Custom Rule Conditions

Gateways

Checkout

Checkout Gateway

Command Reference

Context

Context Gateway Command Reference

Context Gateway

In app purchase

In-App Purchase Gateway

App Base Guide

Build an Admin UI App Locally

Checkout

Payment

Shipping Methods

Tax Provider

Lifecycle

Starter Guide - Read and write data

App Registration & Backend Setup

Signing & Verification in the App System

Webhook

Client-Side App Backend Communication

Configuration

Plugins

Administration

Administration Reference

Directives

Mixins

Utils

Advanced Configuration

Modify Dynamic Product Groups Blacklist

Extending Webpack

Add shortcuts

Add rule assignment configuration

Data Handling and Processing

Using the data handling

Using the data grid component

The Shopware object

Using custom fields

Add custom data to the search

Handling media

Using Vuex Stores

Mixins and Directives

Adding Mixins

Using Mixins

Using Directives

Modules and Components

Add custom module

Add custom component

Customize modules

Customizing components

Add custom input field to existing component

Using base components

Permissions and Error Handling

Adding permissions

Adding error handling

Routing and Navigation

Add custom route

Add menu entry

Override existing routes

Add tab to existing module

Services and Utilities

Making API requests

Adding Services

Extending Services

Using utility functions

Add filter

Using filter

Injecting services

The Sanitizer helper

Templates and Styling

Writing templates

Adding Snippets

Using Assets

Add custom styles

Adding responsive behavior

Plugin Architecture

Cart Extension Architecture

Rule System Extension Architecture

Dependency Injection & Dependency Handling

Event Extension Architecture

Page Loader Extension Architecture

Plugin Fundamentals

Add plugin configuration

Use Plugin Configuration

Add custom CLI commands

Add scheduled task

Plugin Lifecycle Methods

Logging

Checkout

Cart

Add cart collector/processor

Add Cart Items

Add Cart Discounts

Add Cart Validator

Change Price of Items in Cart

Customize Price Calculation

Tax Provider

Document

Add Custom Document

Add Custom Document Type

Order

Using the State Machine

Listen to Order Changes

Payment

Add Payment Plugin

Customize Payment Provider

Content

CMS

Add CMS block

Add CMS element

Add data to CMS element

Mail

Add Data to Mails

Add Mail Templates

Media

Prevent Deletion of Media Files Referenced in Plugins

Add Custom Media File Extensions

Remote Thumbnail Generation

SEO

Add Custom SEO URLs

Extend robots.txt Configuration

Sitemap

Add custom sitemap entries

Modifying Sitemap Entries

Remove sitemap entries

Stock

Implementing Your Own Stock Storage

Loading Stock Information from a Different Source

Reading and Writing Stock

Database

Database Migrations

Using custom fields of type media

Framework

Data Handling / Data Abstraction Layer

Adding Complex Data to Existing Entities

Adding Custom Complex Data

Adding Data Associations

Adding Data Indexer

Adding Data Translations

Removing Associated Data

Entities via Attributes

Field Inheritance

Reading Data

Replacing Associated Data

Using Database Events

Using Flags

Versioning Entities

Writing Data

Caching

Custom Fields

Add Custom Field

Fetching data from "entity selection" custom field

Event

Add Custom Event

Finding Events

Listening to Events

Extension Points

Finding Extension Points

Creating Custom Extension Points

Extension Points vs Events

Message Queue

Add message to queue

Add message handler

Add middleware

Rule

Add Custom Rules

Store API

Add Store API Route

Override existing route

Filesystem

Filesystem - Flysystem

Flow

Add Flow Builder Action

Add Flow Builder trigger

Running actions inside transactions

Rate Limiter

Add Rate Limiter to API Route

System Checks

Add custom check

Services

Dependency injection

Add Custom Service

Adjusting a service

Dependencies

Add plugin dependencies

Adding NPM dependencies

Adding Composer dependencies

Storefront

Templates

Customize templates

Twig Functions

Customize Header/Footer

Add Custom Twig Functions

Styling

Add Custom Assets

Add Custom Styling

Add Custom Icons

Add Translations

Add SCSS Variables

Add SCSS Variables via Subscriber

JavaScript

Storefront Plugins

Add Custom JavaScript

Override Existing JavaScript

Add JavaScript as Script tag

Fetching Data with JavaScript

Reacting to JavaScript Events

Advanced

Add Caching to Custom Controller

Add Cookie to Manager

Reacting to Cookie Consent Changes

Remove JavaScript Plugin

Storefront Controllers

Add Custom Controller

Add Dynamic Content via AJAX Calls

Add Custom Page

Add Custom Pagelet

Add Data to Storefront Page

How-To Guides

Add Custom Captcha

Add Custom Listing Filters

Working with Media and Thumbnails

Add Custom Field in the Storefront

Add Custom Sorting for Product Listing

Using a Modal Window

Using the Datepicker Plugin

Use Nested Line Items

Plugin Base Guide

Symfony Bundles

In-App Purchases (IAP)

Integrations

Commercial Plugins

Custom Pricing

Multi-Inventory

Elasticsearch

Add product entity extension to elasticsearch

Redis

Themes

Theme Base Guide

Create a first theme

Differences Plugins and Apps vs Themes

Theme Configuration

Add SCSS Styling and JavaScript to a Theme

Override Bootstrap variables in a Theme

Override responsive breakpoints in a Theme

Add Assets to a Theme

Add Custom Icons

Theme Inheritance

Theme with Bootstrap styling

Theme Inheritance Configuration

Upgrades and Migrations

Administration

Vue 3 upgrade

Upgrading to Meteor Components

Upgrading to Pinia

Changing from Webpack to Vite

Removing Vue Migration Build

Native Vue

Language Pack Migration

Upgrade Shopware

Migrating Extensions

Hosting

Installation & Updates

Deployments

Deployment with Deployer

Deployment Helper

Building without Database

Cluster Setup

Docker Image

Extension Management

Performing Shopware Updates

Creating Staging Instance

Configurations

Shopware

HTML sanitizer

Stock

Static System Configuration

Environment Variables

Framework

Custom routes

SameSite protection

Observability

Logging

Profiling / Tracing

OpenTelemetry

Performance

Cache

Performance Test with K6

Session

Increment Storage

Lock Storage

Number Ranges

Cart Storage

Performance Tweaks

Infrastructure

Elasticsearch

Set up Elasticsearch

Debugging Elasticsearch

Redis

Filesystem

Rate Limiter

Database

Message Queue

Scheduled Task

Reverse HTTP Cache

Products

Nexus

Getting Started

Nexus

Integration

Security and Troubleshooting

Shopware CLI

Other Installation Options

Command Types

Extension commands

Building extensions and creating archives

Standalone Admin Watcher

Extracting Meta Data

Configuration

Project commands

Generating MySQL dumps

Build a Complete Project

Remote Extension Management

Helper Commands

Autofixer

Image Proxy

Shopware account commands

Authentication

Releasing automated extension to Shopware Store

Updating Store Page of Extension

Configure Composer Repository

Validation

Formatter

Automatic refactoring

Extensions

Migration Assistant

Concept

Migration Process

Profile and Connection

DataSelection and DataSet

Migration Context

Premapping

Gateway and Reader

Convert and Mapping

Logging

Error Resolution

Writer

Media Processing

Guides

Extending a Shopware migration profile

Extending the Migration Connector

Decorating a Shopware Migration Assistant converter

Creating a new migration profile

B2B Suite

Concepts

System architecture

Basic conventions

Method structure

Line Item List

Guides

Core

Dependency injection

Store API

REST API

Listing service

CRUD service

Assignment service

Audit Log

Exception

Currency

Entity based ACL

Overloading classes

Storefront Authentication

Installation

Storefront

Ajax Panel

Product Search

Complex views

Modal component

Company

ACL and Routing

Extending the Storefront

Example Plugins

Administration

B2B Components

Employee Management

Concepts

Entities & Schema

Guides

API Route Restriction for Employees

Employee Invitation

B2B Roles

Create permissions via App

Create permissions via plugin

Subscription Integration

Quotes Management

Concepts

Entities & Schema

Guides

Quotes conversion

Shopping lists

Concepts

Entities & Schema

Guides

API & Pricing

Order Approval

Concepts

Entities and workflow

Guides

Order approval permissions

Payment Process

How to add a new approval condition

Organization unit

Concepts

Entities & Schema

Guides

Store API

Extending the Organization entity

How to identify the organization unit from the context

Individual Pricing

Concepts

Entities and Workflow

Pricing workflow

Guides

Extensibility - Events, Messages, and Extensions

B2B Suite Migration

Concept

Migration Table

Technical Terms and Concepts

Execution

Prerequisites

Running Migration

Troubleshooting

Development

Adding Component

Fields Mapping

Handlers

Extending Migration

Validation and Run

References

References

Role and Permission Mapping

Commercial

Advanced Search

Installation

Define a Custom Elasticsearch Definition

Add more fields to product search

Configure Searchable Fields

Language analyzers

Cross search

Extending search template

Modify search logic

Search and suggest routes

Completion

Subscriptions

Guides

Separate checkout

Mixed checkout

Template scoping

B2B Employee Integration

Subscription concept

PaaS

Shopware PaaS Native

Get Started

Prepare Shopware codebase

CLI

Quickstart

Fundamentals

Organizations

Projects

Applications

Environment variables

Secrets

Account

Application YAML

K8s Meta Package

Plugin Store Authentication

Resources

Databases

Object Storage

Monitoring

Logs

Traces

Monitor events

CDN

Guides

How to set up repository access

Using the Vault

Update Shopware in PaaS Native

How to set up OpenSearch

Clone Application

Manage Cron Jobs

Frequently Asked Questions

Known issues

Shopware PaaS

PaaS CLI Setup

Repository

Build & Deploy

Setup Template

Elasticsearch

RabbitMQ

Fastly

Blackfire

Composable frontends

Composable-Frontends Performance

Blackfire Continuous Profiling of Nuxt.js

Sales Agent

Customization

Branding Customization

I18n Customization

Component Customization

Best practices

Frontend App Deployment

Ubuntu Server with PM2

AWS

Cloudflare

Local installation

Testing

Digital Sales Rooms

Installation

Admin side installation

Frontend app installation

Setup 3rd parties

Realtime Video Call - Daily.co

Realtime Service - Mercure

Configuration

Domain Configuration

Plugin Configuration

Configuration with CLI

Customization

Branding Customization

I18n Customization

Component Customization

Best practices

Frontend App Deployment

Ubuntu Server with PM2

AWS

Cloudflare

SaaS

SaaS

Resources

References

Core Reference

Composer Commands Reference

Commands Reference

Actions Reference

App Reference

Script Reference

Cart Manipulation script services reference

Data Loading script services reference

Custom Endpoint script services reference

Miscellaneous script services reference

Script hooks reference

Product script services reference

Trigger Events Reference

Webhook Event Reference

Manifest Reference

Webhook Events Reference

Payment Reference

CMS Reference

Entities Reference

Flow Action Reference

Testing Reference

Custom E2E Commands

E2E Commands

Adr

Implement architecture decision records

Get control of association clone behavior as developer

Implement sales channel context token requirement for store-api and sales-channel-api

Document template refactoring

Implement app system inside platform

Implement individual sorting

Merchant registration

Notification titles are pre-defined and make use of the global namespace

Import ACL privileges from other roles

CustomField label loading in storefront

The best-practice to always re-fetch the data after saving

Creating events in Shopware

DAL join filter

Add the login required annotation

Decoration pattern

API version removal

Processing of nested line items

When to use plain SQL or the DAL

Vue administration app has ESLint support

Introduce jest-fail-on-console

Move storefront script to head with defer

Storefront coding standards

Make shopware/shopware stand-alone for development and testing

Refactor admin build process to webpack-multi-compiler mode

Make Core mail templates independent from Storefront urls

Technical concept custom entities

Refactor theme inheritance

Payment Flow

Refund handling

App scripts

Preparing data for rule evaluation

Adjust ADR approval rules for the new org structure

Introduce increment pattern

Merge E2E projects into a single project

Add possibility for plugins to add a HTML file

Admin extension API standards

Add feature flag support for Storefront SCSS

Allow apps to define custom api endpoints

Feature flags for major versions

Move controller level annotation into Symfony route annotation

Rule Scripting in apps

Domain exceptions

Consistent deprecation notices in Core

Use `ResetInterface` to reset instance state during requests

Extract data handling classes to extension sdk

New templates for line items and nested line items

Available stock improvements

Base sales channel context factory

Cache stampede protection

Initial state id loader

Prevent mail updates

Profiler integrations

Redis cart persister

Specify priority of translations in DAL write payloads

Add default cms pages to products and categories

Integrate an app into flow action

Introducing tax providers

Remove static analysis with psalm

Rule condition field abstraction

Integrate an app into the flow event

Add typescript support for storefront javascript

Providing the admin extension SDK

Concept for blogs using Shopping Experiences

Adding the `StorableFlow` instead of the `FlowEvent` for implementing the flow DelayAction in flow builder

Add bootstrap JS-plugin initialization utility to storefront JS

Vue 2.7 update

Mapping of product area

Hide and show CMS content

Deprecation handling during PHPUnit test execution

Test structure

Composer-based web updater

Deprecate the storefront CSRF implementation

Replace drop-shadow with box-shadow

Run Lighthouse tests in E2E env

Atomic theme compilation

Npm packages pre-release versions

Add native lazy loading for images to the storefront

App script product pricing

Deprecate autoloading associations in DAL entity definitions

Flow storer with scalar values

Follow test pyramid

Unstructured ADRs

Native extension system with vue

Admin text editor evaluation

Mocking repositories

Disable the CSS autoprefixer in the Storefront by default

New language inheritance mechanism for opensearch

Jest test files should be JavaScript only

Optimize cart cleanup

Experimental features

Stock Manipulation API

Use PHP 8.1 Enums

Switch to UUIDv7

Exception Log Level configuration

Client side communication to App Server

Default handling for non specified salutations

Flow Builder Preview

Collecting and dispatching entity data

Media path rewrite

Post updater

Add Feature property to `@experimental` annotation

Introduction of Unique Identifiers for Checkout Methods

Make more use of Bootstrap tooling and remove !important from Bootstrap CSS utils

Make feature flags toggleable on demand

New acceptance test suite

Introduce transactional flow actions

Disable Vue compat mode per component level

Implementation of Meteor Component Library

Checkout gateway

Add jest runner with disabled compat mode

Error-code log Level configuration in platform or cloud

Replace Vuex with Pinia

Transition to an Event-Based Extension System

Deprecating Meteor Admin SDK public SDK

Telemetry abstraction layer

Add more unit tests namespaces to FeatureFlag extension

System Health Checks in Shopware

Native Block System in Shopware

Vue 2 Options API to Vue 3 Composition API Conversion Codemod

[A11y] Offer HTML alternative to our pdf standard documents

Remove the asterisk next to every price and replace it with actual text

Make Rule classes internal

Move flow execution after business process

Deprecate Iterator.helper in Storefront JS

Context Gateway

Implement measurement system

Integrating the language pack into platform

Cache layer for navigation loader

Adding a country-agnostic language layer

App requirements validation

Caching Strategy for Store API

Co-locate Administration Technical Documentation with Source Code

Pin All NPM Dependencies to Exact Versions

Replace changelog ADR with "Changelog & Release Info Process"

Improved HTTP Cache Layer

Introduce Product Type And Deprecate Product States

Apply OpenSearch globally for admin-api

Refactor of document generation

Improved APP URL verification utils

New document generation architecture

New document generation extension points

Keep the Administration top bar under Shopware control

Config Reference

Server

Apache

Caddy

Nginx

Security

Shopware Tools Telemetry

Guidelines

Code

Core

2023-05-16 - PHP 8.1 & Symfony 6.1 new features

ADR

Introduction

Decorator pattern

Domain exceptions

Extendability

Introduction

Final and internal annotation

Internal

Unit tests

Writing code for static analysis

Contribution Guidelines

Backward Compatibility

Document Code

Platform Domains

Public APIs

Routing

Session and State

Store API

Storefront Controller

Troubleshooting

Performance

PHPStan

Elasticsearch

Document

Fonts & Formats

Text

Code

General

Methodize Assets

Conceptual Structure

Doc Process

Language & Grammar

Embedding external repositories

Services

Guides
Extensions
Plugins

On this page

docsmainPlugins

Services

This section explains how to register, customize and extend services within your plugin:

Dependency Injection
Add Custom Service
Adjusting a Service

Dependency injection

Add Custom Service

Adjusting a service

Ask a question on StackOverflow

Edit this page on GitHub

Pager

Previous pageAdd custom check

Next pageDependency injection

Was this page helpful?

UnsatisfiedSatisfied

Be the first to vote!

0.0 / 5 (0 votes)

info@shopware.com
00 800 746 7626 0

Product

APIs
SDKs
B2B Suite
Extensions
Headless Storefront

Resources

User Documentation
Design Documentation
E-commerce knowledge
Jump into development
Training & Certification

Community

Forum
Community Day
Stack Overflow
Feedback & Issues

GitHub Channels

Shopware 5
Shopware 6
Development Template
Contribute to the docs
Contribute to platform

News & Updates

Blog
Shopware TV
Announcements
Product Changelog

Newsletter

Copyright © shopware AG - All rights reserved

Terms & Conditions
Privacy policy
Legal notice
Cookie settings