SPA Editor Overview
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.
Page Model Management
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 cq-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:
- If the template is editable, add it to the page policy.
- Or add the categories using the customfooterlibs.html .
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.
Communication Data Type
When the 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.
- The communication between the page editor and the SPA is made using JSON instead of HTML.
- The page editor provides the latest version of the page model to the SPA via the iframe and messaging API.
- The page model manager notifies the editor it is ready for edition and passes the page model as a JSON structure.
- The editor doesn't alter or even access the DOM structure of the page being authored rather it provides the latest page model.
Basic SPA Editor Workflow
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:
- The SPA is always in charge of its display.
- The SPA Editor is isolated from the SPA itself.
- In production (publish), the SPA editor is never loaded.
Client-Server Page Editing Workflow
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.
Requirements & Limitations
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:
- React 16.3
- Angular 6.x
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.
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:
- Target mode
- Inline image editing
- Edit configs (eg. listeners)
- Style System
- Undo / Redo
- Page diff and Time Warp
- Features performing HTML rewriting server-side such as Link Checker, CDN rewriter service, URL shortening etc.
- Developer mode
- AEM Launches