FEATURE: switch to backend-calculated parent node links (needed for Event Sourced CR)

Classes/Domain/Model/FeedbackCollection.php

@@ -75,4 +75,9 @@ public function jsonSerialize()
             'feedbacks' => $feedbacks
         ];
     }
+
+    public function reset()
+    {
+        $this->feedbacks = [];
+    }
 }

Classes/FlowQueryOperations/NeosUiDefaultNodesOperation.php

@@ -11,6 +11,9 @@
  * source code.
  */
 
+use Neos\ContentRepository\Domain\NodeType\NodeTypeConstraintFactory;
+use Neos\ContentRepository\Domain\Projection\Content\TraversableNodeInterface;
+use Neos\ContentRepository\Exception\NodeException;
 use Neos\Flow\Annotations as Flow;
 use Neos\Flow\Property\PropertyMapper;
 use Neos\ContentRepository\Domain\Model\NodeInterface;
@@ -42,6 +45,12 @@ class NeosUiDefaultNodesOperation extends AbstractOperation
      */
     protected $propertyMapper;
 
+    /**
+     * @Flow\Inject
+     * @var NodeTypeConstraintFactory
+     */
+    protected $nodeTypeConstraintFactory;
+
     /**
      * {@inheritdoc}
      *
@@ -50,7 +59,7 @@ class NeosUiDefaultNodesOperation extends AbstractOperation
      */
     public function canEvaluate($context)
     {
-        return isset($context[0]) && ($context[0] instanceof NodeInterface);
+        return isset($context[0]) && ($context[0] instanceof TraversableNodeInterface);
     }
 
     /**
@@ -62,38 +71,48 @@ public function canEvaluate($context)
      */
     public function evaluate(FlowQuery $flowQuery, array $arguments)
     {
+        /** @var TraversableNodeInterface $siteNode */
+        /** @var TraversableNodeInterface $documentNode */
         list($siteNode, $documentNode) = $flowQuery->getContext();
+        /** @var TraversableNodeInterface $toggledNodes */
         list($baseNodeType, $loadingDepth, $toggledNodes, $clipboardNodesContextPaths) = $arguments;
 
         // Collect all parents of documentNode up to siteNode
         $parents = [];
-        $currentNode = $documentNode->getParent();
+        $currentNode = null;
+        try {
+            $currentNode = $documentNode->findParentNode();
+        } catch (NodeException $ignored) {
+            // parent does not exist
+        }
         if ($currentNode) {
-            $parentNodeIsUnderneathSiteNode = strpos($currentNode->getPath(), $siteNode->getPath()) === 0;
-            while ($currentNode !== $siteNode && $parentNodeIsUnderneathSiteNode) {
-                $parents[] = $currentNode->getContextPath();
-                $currentNode = $currentNode->getParent();
+            $parentNodeIsUnderneathSiteNode = strpos((string)$currentNode->findNodePath(), (string)$siteNode->findNodePath()) === 0;
+            while ((string)$currentNode->getNodeAggregateIdentifier() !== (string)$siteNode->getNodeAggregateIdentifier() && $parentNodeIsUnderneathSiteNode) {
+                $parents[] = (string)$currentNode->getNodeAggregateIdentifier();
+                $currentNode = $currentNode->findParentNode();
             }
         }
 
-        $nodes = [$siteNode];
-        $gatherNodesRecursively = function (&$nodes, $baseNode, $level = 0) use (&$gatherNodesRecursively, $baseNodeType, $loadingDepth, $toggledNodes, $parents) {
+        $nodes = [
+            ((string)$siteNode->getNodeAggregateIdentifier()) => $siteNode
+        ];
+        $gatherNodesRecursively = function (&$nodes, TraversableNodeInterface $baseNode, $level = 0) use (&$gatherNodesRecursively, $baseNodeType, $loadingDepth, $toggledNodes, $parents) {
             if (
                 $level < $loadingDepth || // load all nodes within loadingDepth
                 $loadingDepth === 0 || // unlimited loadingDepth
-                in_array($baseNode->getContextPath(), $toggledNodes) || // load toggled nodes
-                in_array($baseNode->getContextPath(), $parents) // load children of all parents of documentNode
+                in_array((string)$baseNode->getNodeAggregateIdentifier(), $toggledNodes) || // load toggled nodes
+                in_array((string)$baseNode->getNodeAggregateIdentifier(), $parents) // load children of all parents of documentNode
             ) {
-                foreach ($baseNode->getChildNodes($baseNodeType) as $childNode) {
-                    $nodes[] = $childNode;
+                foreach ($baseNode->findChildNodes($this->nodeTypeConstraintFactory->parseFilterString($baseNodeType)) as $childNode) {
+                    $nodes[(string)$childNode->getNodeAggregateIdentifier()] = $childNode;
                     $gatherNodesRecursively($nodes, $childNode, $level + 1);
                 }
             }
         };
         $gatherNodesRecursively($nodes, $siteNode);
 
-        if (!in_array($documentNode, $nodes)) {
-            $nodes[] = $documentNode;
+        if (!isset($nodes[(string)$documentNode->getNodeAggregateIdentifier()])) {
+            $nodes[(string)$documentNode->getNodeAggregateIdentifier()] = $documentNode;
         }
 
         foreach ($clipboardNodesContextPaths as $clipboardNodeContextPath) {

Classes/Fusion/Helper/NodeInfoHelper.php

@@ -212,6 +212,8 @@ protected function getBasicNodeInformation(NodeInterface $node): array
             'isAutoCreated' => $node->isAutoCreated(),
             'depth' => $node->getDepth(),
             'children' => [],
+            // In some rare cases the parent node cannot be resolved properly
+            'parent' => ($node->getParent() ? $node->getParent()->getContextPath() : null),
             'matchesCurrentDimensions' => ($node instanceof Node && $node->dimensionsAreMatchingTargetDimensionValues())
         ];
     }

packages/neos-ts-interfaces/src/index.ts

@@ -72,6 +72,7 @@ export interface Node {
     };
     isFullyLoaded: boolean;
     uri: string;
+    parent: NodeContextPath;
     policy?: NodePolicy;
     dimensions?: DimensionPresetCombination;
     otherNodeVariants?: DimensionPresetCombination[];

packages/neos-ui-redux-store/src/CR/Nodes/helpers.ts

@@ -21,24 +21,6 @@ export const getAllowedNodeTypesTakingAutoCreatedIntoAccount = (baseNode: Node,
     return nodeTypesRegistry.getAllowedChildNodeTypes(baseNode.nodeType);
 };
 
-//
-// Helper function to get parent contextPath from current contextPath
-//
-export const parentNodeContextPath = (contextPath: NodeContextPath) => {
-    if (typeof contextPath !== 'string') {
-        console.error('`contextPath` must be a string!'); // tslint:disable-line
-        return null;
-    }
-    const [path, context] = contextPath.split('@');
-
-    if (path.length === 0) {
-        // We are at top level; so there is no parent anymore!
-        return null;
-    }
-
-    return `${path.substr(0, path.lastIndexOf('/'))}@${context}`;
-};
-
 //
 // Helper function to check if the node is collapsed
 //
@@ -60,9 +42,9 @@ export const calculateNewFocusedNodes = (selectionMode: SelectionModeTypes, cont
         return [contextPath];
     } else if (selectionMode === SelectionModeTypes.RANGE_SELECT) {
         const lastSelectedNodeContextPath = focusedNodesContextPaths[focusedNodesContextPaths.length - 1];
-        const maybeParentNodeContextPath = parentNodeContextPath(lastSelectedNodeContextPath);
-        if (maybeParentNodeContextPath) {
-            const parentNode = getNodeOrThrow(nodesByContextPath, maybeParentNodeContextPath);
+        const lastSelectedNode = nodesByContextPath[lastSelectedNodeContextPath];
+        if (lastSelectedNode && lastSelectedNode.parent) {
+            const parentNode = getNodeOrThrow(nodesByContextPath, lastSelectedNode.parent);
             const tempSelection: string[] = [];
             let startSelectionFlag = false;
             // if both start and end nodes are within children, then we can do range select

packages/neos-ui-redux-store/src/CR/Nodes/index.spec.js

@@ -114,6 +114,7 @@ test(`The "move" action should move things right.`, () => {
                 ]
             },
             'abc/abc@user-admin;language=en_US': {
+                parent: 'abc@user-admin;language=en_US',
                 contextPath: 'abc/abc@user-admin;language=en_US',
                 children: [
                     {
@@ -122,10 +123,12 @@ test(`The "move" action should move things right.`, () => {
                 ]
             },
             'abc/abc2@user-admin;language=en_US': {
+                parent: 'abc@user-admin;language=en_US',
                 contextPath: 'abc/abc@user-admin;language=en_US',
                 children: []
             },
             'abc/abc/abc@user-admin;language=en_US': {
+                parent: 'abc/abc@user-admin;language=en_US',
                 contextPath: 'abc/abc/abc@user-admin;language=en_US',
                 children: []
             }
@@ -145,19 +148,26 @@ test(`The "move" action should move things right.`, () => {
                         contextPath: 'abc/abc2@user-admin;language=en_US'
                     },
                     {
+                        // NOTE: the context path below is "wrong" (because its's the pre-move state), but this gets updated when the server roundtrip is completed.
+                        // we just move the node client-side for immediate user feedback
                         contextPath: 'abc/abc/abc@user-admin;language=en_US'
                     }
                 ]
             },
             'abc/abc@user-admin;language=en_US': {
+                parent: 'abc@user-admin;language=en_US',
                 contextPath: 'abc/abc@user-admin;language=en_US',
                 children: []
             },
             'abc/abc2@user-admin;language=en_US': {
+                parent: 'abc@user-admin;language=en_US',
                 contextPath: 'abc/abc@user-admin;language=en_US',
                 children: []
             },
             'abc/abc/abc@user-admin;language=en_US': {
+                // NOTE: the parent path below is "wrong" (because its's the pre-move state), but this gets updated when the server roundtrip is completed.
+                // we just move the node client-side for immediate user feedback
+                parent: 'abc/abc@user-admin;language=en_US',
                 contextPath: 'abc/abc/abc@user-admin;language=en_US',
                 children: []
             }

packages/neos-ui-redux-store/src/CR/Nodes/index.ts

@@ -4,7 +4,7 @@ import {action as createAction, ActionType} from 'typesafe-actions';
 import {actionTypes as system, InitAction} from '@neos-project/neos-ui-redux-store/src/System';
 
 import * as selectors from './selectors';
-import {parentNodeContextPath, getNodeOrThrow, calculateNewFocusedNodes} from './helpers';
+import {calculateNewFocusedNodes, getNodeOrThrow} from './helpers';
 
 import {FusionPath, NodeContextPath, InsertPosition, NodeMap, ClipboardMode, SelectionModeTypes, NodeTypeName} from '@neos-project/neos-ts-interfaces';
 
@@ -340,30 +340,24 @@ const moveNodeInState = (
     position: string,
     draft: State
 ) => {
-    let baseNodeContextPath;
+    const sourceNode = getNodeOrThrow(draft.byContextPath, sourceNodeContextPath);
+    const targetNode = getNodeOrThrow(draft.byContextPath, targetNodeContextPath);
+    let baseNode;
     if (position === 'into') {
-        baseNodeContextPath = targetNodeContextPath;
+        baseNode = targetNode;
     } else {
-        baseNodeContextPath = parentNodeContextPath(targetNodeContextPath);
-        if (baseNodeContextPath === null) {
-            throw new Error(`Target node "{targetNodeContextPath}" doesn't have a parent, yet you are trying to move a node next to it`);
-        }
+        baseNode = getNodeOrThrow(draft.byContextPath, targetNode.parent);
     }
 
-    const sourceNodeParentContextPath = parentNodeContextPath(sourceNodeContextPath);
-    if (sourceNodeParentContextPath === null) {
-        throw new Error(`The source node "{sourceNodeParentContextPath}" doesn't have a parent, you can't move it`);
-    }
-    const baseNode = getNodeOrThrow(draft.byContextPath, baseNodeContextPath);
-    const sourceNodeParent = getNodeOrThrow(draft.byContextPath, sourceNodeParentContextPath);
+    const sourceNodeParent = getNodeOrThrow(draft.byContextPath, sourceNode.parent);
 
     const originalSourceChildren = sourceNodeParent.children;
     const sourceIndex = originalSourceChildren.findIndex(child => child.contextPath === sourceNodeContextPath);
     const childRepresentationOfSourceNode = originalSourceChildren[sourceIndex];
 
     const processedChildren = baseNode.children;
 
-    if (sourceNodeParentContextPath === baseNodeContextPath) {
+    if (sourceNodeParent === baseNode) {
         // If moving into the same parent, delete source node from it
         processedChildren.splice(sourceIndex, 1);
     } else {

packages/neos-ui-redux-store/src/CR/Nodes/selectors.ts

@@ -1,7 +1,6 @@
 import {$get} from 'plow-js';
 import {createSelector, defaultMemoize} from 'reselect';
 import {GlobalState} from '@neos-project/neos-ui-redux-store/src/System';
-import {parentNodeContextPath} from './helpers';
 import {NodeContextPath, NodeMap, Node, NodeTypeName, ClipboardMode, NodeTypesRegistry} from '@neos-project/neos-ts-interfaces';
 
 export const inlineValidationErrorsSelector = (state: GlobalState) => $get(['cr', 'nodes', 'inlineValidationErrors'], state);
@@ -138,19 +137,17 @@ export const byContextPathSelector = defaultMemoize(
 );
 
 export const parentNodeSelector = (state: GlobalState) => (baseNode: Node) => {
-    const parent = parentNodeContextPath(baseNode.contextPath);
-    if (parent !== null) {
-        return byContextPathSelector(parent)(state);
+    if (baseNode.parent !== null) {
+        return byContextPathSelector(baseNode.parent)(state);
     }
     return null;
 };
 
 export const grandParentNodeSelector = (state: GlobalState) => (baseNode: Node) => {
-    const parent = parentNodeContextPath(baseNode.contextPath);
-    if (parent !== null) {
-        const grandParent = parentNodeContextPath(parent);
-        if (grandParent !== null) {
-            byContextPathSelector(grandParent)(state);
+    if (baseNode.parent !== null) {
+        const parentNode = byContextPathSelector(baseNode.parent)(state);
+        if (parentNode && parentNode.parent) {
+            return byContextPathSelector(parentNode.parent)(state);
         }
     }
     return null;
@@ -244,13 +241,13 @@ export const getPathInNode = (state: GlobalState, contextPath: NodeContextPath,
     return $get(propertyPath, node);
 };
 
-export const makeGetAllowedChildNodeTypesSelector = (nodeTypesRegistry: NodeTypesRegistry, elevator: (id: string) => string | null = id => id) => createSelector(
+export const makeGetAllowedChildNodeTypesSelector = (nodeTypesRegistry: NodeTypesRegistry, elevator: (id: string, state: GlobalState) => string | null = id => id) => createSelector(
     [
         (state: GlobalState, {reference}: {reference: NodeContextPath | null, role: string}) => {
             if (reference === null) {
                 return null;
             }
-            const elevatedReference = elevator(reference);
+            const elevatedReference = elevator(reference, state);
             if (elevatedReference) {
                 return $get(['cr', 'nodes', 'byContextPath', elevatedReference], state) || null;
             }
@@ -260,9 +257,9 @@ export const makeGetAllowedChildNodeTypesSelector = (nodeTypesRegistry: NodeType
             if (reference === null) {
                 return null;
             }
-            const parentReference = parentNodeContextPath(reference);
+            const parentReference = getPathInNode(state, reference, 'parent');
             if (parentReference !== null) {
-                const elevatedReferenceParent = elevator(parentReference);
+                const elevatedReferenceParent = elevator(parentReference, state);
                 if (elevatedReferenceParent !== null) {
                     return $get(['cr', 'nodes', 'byContextPath', elevatedReferenceParent], state) || null;
                 }
@@ -286,7 +283,8 @@ export const makeGetAllowedChildNodeTypesSelector = (nodeTypesRegistry: NodeType
 );
 
 export const makeGetAllowedSiblingNodeTypesSelector = (nodeTypesRegistry: NodeTypesRegistry) =>
-    makeGetAllowedChildNodeTypesSelector(nodeTypesRegistry, parentNodeContextPath);
+    makeGetAllowedChildNodeTypesSelector(nodeTypesRegistry, (nodeContextPath, state) => getPathInNode(state, nodeContextPath, 'parent'));
+
 
 export const makeIsAllowedToAddChildOrSiblingNodes = (nodeTypesRegistry: NodeTypesRegistry) => createSelector(
     [
@@ -327,13 +325,13 @@ export const makeCanBeMovedIntoSelector = (nodeTypesRegistry: NodeTypesRegistry)
 export const makeCanBeMovedAlongsideSelector = (nodeTypesRegistry: NodeTypesRegistry) => createSelector(
     [
         makeCanBeCopiedAlongsideSelector(nodeTypesRegistry),
-        (_, {subject, reference}) => {
+        (state: GlobalState, {subject, reference}) => {
             if (reference === null) {
                 return false;
             }
             const subjectPath = subject && subject.split('@')[0];
-            const referenceParent = parentNodeContextPath(reference);
-            if (referenceParent === null) {
+            const referenceParent = getPathInNode(state, reference, 'parent') as string;
+            if (!referenceParent) {
                 return false;
             }
             return subjectPath ? referenceParent.indexOf(subjectPath) === 0 : false;
@@ -406,12 +404,14 @@ export const focusedNodeParentLineSelector = createSelector(
         let currentNode = focusedNode;
 
         while (currentNode) {
-            const parent = parentNodeContextPath(currentNode.contextPath);
-            if (parent !== null) {
+            const parent = currentNode.parent;
+            if (parent) {
                 currentNode = nodesByContextPath[parent] || null;
                 if (currentNode) {
                     result.push(currentNode);
                 }
+            } else {
+                break;
             }
         }
 

packages/neos-ui-sagas/src/CR/NodeOperations/addNode.js

@@ -1,7 +1,7 @@
-import {takeLatest, take, put, race, call} from 'redux-saga/effects';
+import {takeLatest, take, put, race, call, select} from 'redux-saga/effects';
 import {$get} from 'plow-js';
 
-import {actions, actionTypes} from '@neos-project/neos-ui-redux-store';
+import {actions, actionTypes, selectors} from '@neos-project/neos-ui-redux-store';
 
 import {calculateChangeTypeFromMode, calculateDomAddressesFromMode} from './helpers';
 
@@ -91,11 +91,15 @@ function * nodeCreationWorkflow(context, step = STEP_SELECT_NODETYPE, workflowDa
             if (nodeTypesRegistry.hasRole(nodeType, 'document')) {
                 yield put(actions.UI.ContentCanvas.startLoading());
             }
+
+            const referenceNodeSelector = selectors.CR.Nodes.makeGetNodeByContextPathSelector(referenceNodeContextPath);
+            const referenceNode = yield select(referenceNodeSelector);
+
             return yield put(actions.Changes.persistChanges([{
                 type: calculateChangeTypeFromMode(mode, 'Create'),
                 subject: referenceNodeContextPath,
                 payload: {
-                    ...calculateDomAddressesFromMode(mode, referenceNodeContextPath, referenceNodeFusionPath),
+                    ...calculateDomAddressesFromMode(mode, referenceNode, referenceNodeFusionPath),
                     nodeType,
                     data
                 }