Single page applications (SPAs) can offer compelling experiences for website users. Developers want to be able to build sites using SPA frameworks and authors want to seamlessly edit content within AEM for a site built using such frameworks.
The SPA Editor offers a comprehensive solution for supporting SPAs within AEM. This page gives an overview of how SPA support is structured in AEM, how the SPA Editor works, and how the SPA framework and AEM keep in synch.
The Single-Page Application (SPA) Editor feature requires AEM 6.4 service pack 2 or newer.
The SPA Editor is the recommended solution for projects that require SPA framework based client-side rendering (e.g. React or Angular).
Sites built using common SPA frameworks such as React and Angular load their content via dynamic JSON and do not provide the HTML structure that is necessary for the AEM Page Editor to be able to place edit controls.
To enable the editing of SPAs within AEM, a mapping between the JSON output of the SPA and the content model in the AEM repository is needed to save changes to the content.
SPA support in AEM introduces a thin JS layer that interacts with the SPA JS code when loaded in the Page Editor with which events can be sent and the location for the edit controls can be activated to allow in-context editing. This feature builds upon the Content Services API Endpoint concept since the content from the SPA needs to be loaded via Content Services.
For further details about SPAs in AEM, see the following documents:
The page component for a SPA doesn’t provide the HTML elements of its child components via the JSP or HTL file. This operation is delegated to the SPA framework. The representation of child components or model is fetched as a JSON data structure from the JCR. The SPA components are then added to the page according to that structure. This behavior differentiates the page component’s initial body composition from non-SPA counterparts.
The resolution and the management of the page model is delegated to a provided
PageModel library. The SPA must use the Page Model library in order to be initialized and be authored by the SPA Editor. The Page Model library provided indirectly to the AEM Page component via the
aem-react-editable-components npm. The Page Model is an interpreter between AEM and the SPA and therefore always must be present. When the page is authored, an additional library
cq.authoring.pagemodel.messaging must be added in order to enable the communication with the page editor.
If the SPA page component inherits from the page core component, there are two options for making the
cq.authoring.pagemodel.messaging client library category available:
For each resource in the exported model the SPA will map an actual component which will do the
rendering. The model, represented as JSON, are then rendered using the component mappings within a container.
The inclusion of the
cq.authoring.pagemodel.messaging category should be limited to the context of the SPA Editor.
cq.authoring.pagemodel.messaging category is added to the page, it will send a message to the Page Editor to establish the JSON communication data type. When the communication data type is set to JSON, the GET requests will communicate with the Sling Model end-points of a component. After an update occurs in the page editor, the JSON representation of the updated component is sent to the Page Model library. The Page Model library then informs the SPA of updates.
You can understand the flow of the interaction between the SPA and AEM by thinking of the SPA Editor as a mediator between the two.
Keeping in mind the key elements of the SPA Editor, the high-level workflow of editing a SPA within AEM appears to the author as follows.
SPA Editor loads.
SPA is loaded in a separate frame.
SPA requests JSON content and renders components client-side.
SPA Editor detects rendered components and generates overlays.
Author clicks overlay, displaying the component’s edit toolbar.
SPA Editor persists edits with a POST request to the server.
SPA Editor requests updated JSON to the SPA Editor, which is sent to the SPA with a DOM Event.
SPA re-renders the concerned component, updating its DOM.
Keep in mind:
This is a more detailed overview of the client-server interaction when editing a SPA.
The SPA initializes itself and requests the page model from the Sling Model Exporter.
The Sling Model Exporter requests the resources that compose the page from the repository.
The repository returns the resources.
The Sling Model Exporter returns the model of the page.
The SPA instantiates its components based on the page model.
6a The content informs the editor that it is ready for authoring.
6b The page editor requests the component authoring configurations.
6c The page editor receives the component configurations.
When the author edits a component, the page editor posts a modification request to the default POST servlet.
The resource is updated in the repository.
The updated resource is provided to the POST servlet.
The default POST servlet informs the page editor that the resource has been updated.
The page editor requests the new page model.
The resources that compose the page are requested from the repository.
The resources that compose the page are provided by the repository to the Sling Model Exporter.
The updated page model is returned to the editor.
The page editor updates the page model reference of the SPA.
The SPA updates its components based on the new page model reference.
The component configurations of the page editors are updated.
17a The SPA signals the page editor that content is ready.
17b The page editor provides the SPA with component configurations.
17c The SPA provides updated component configurations.
This is a more detailed overview focusing on the authoring experience.
The SPA fetches the page model.
2a The page model provides the editor with the data required for authoring.
2b When notified, the component orchestrator update the content structure of the page.
The component orchestrator queries the mapping between an AEM resource type and a SPA component.
The component orchestrator dynamically instantiates the SPA component based on the page model and component mapping.
The page editor updates the page model.
6a The page model provides updated authoring data to the page editor.
6b The page model dispatches changes to the component orchestrator.
The component orchestrator fetches the component mapping.
The component orchestrator updates the content of the page.
When the SPA completes updating the content of the page, the page editor loads the authoring environment.
To enable the author to use the page editor to edit the content of an SPA, your SPA application must be implemented to interact with the AEM SPA Editor SDK. Please see the Getting Started with SPAs in AEM document for minimum that you need to know to get yours running.
The SPA Editor SDK supports the following minimal versions:
Previous versions of these frameworks may work with the AEM SPA Editor SDK, but are not supported.
Additional SPA frameworks can be implemented to work with the AEM SPA Editor SDK. Please see the SPA Blueprint document for the requirements that a framework must fulfill in order to create a framework-specific layer composed of modules, components, and services to work with the AEM SPA Editor.
Additional custom selectors can be defined and used as part of an SPA developed for the AEM SPA SDK. However this support requires that the
model selector be the first selector and the extension be
.json as required by the JSON Exporter.
If you want to use the in place editor of a text component created in SPA there is additional configuration required.
<div>element and the selector that has been used is
editElementQueryon the corresponding AEM text component’s
cq:InplaceEditingConfigthat points to that selector e.g.
data-rte-editelement. This lets the editor know which HTML element wraps the HTML text.
For an example of how this is done, see the WKND Journal sample content.
For additional information about the
editElementQuery property and the configuration of the rich text editor, see Configure the Rich Text Editor.
The AEM SPA Editor SDK was introduced with AEM 6.4 service pack 2. It is fully supported by Adobe, and as a new feature it continues to be enhanced and expanded. The following AEM features are not yet covered by the SPA Editor: